Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
154 lines (129 sloc) 3.96 KB
/*
Copyright 2019 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package markers
import (
"fmt"
"sync"
)
// Registry keeps track of registered definitions, and allows for easy lookup.
// It's thread-safe, and the zero-value can be safely used.
type Registry struct {
forPkg map[string]*Definition
forType map[string]*Definition
forField map[string]*Definition
helpFor map[*Definition]*DefinitionHelp
mu sync.RWMutex
initOnce sync.Once
}
func (r *Registry) init() {
r.initOnce.Do(func() {
if r.forPkg == nil {
r.forPkg = make(map[string]*Definition)
}
if r.forType == nil {
r.forType = make(map[string]*Definition)
}
if r.forField == nil {
r.forField = make(map[string]*Definition)
}
if r.helpFor == nil {
r.helpFor = make(map[*Definition]*DefinitionHelp)
}
})
}
// Define defines a new marker with the given name, target, and output type.
// It's a shortcut around
// r.Register(MakeDefinition(name, target, obj))
func (r *Registry) Define(name string, target TargetType, obj interface{}) error {
def, err := MakeDefinition(name, target, obj)
if err != nil {
return err
}
return r.Register(def)
}
// Register registers the given marker definition with this registry for later lookup.
func (r *Registry) Register(def *Definition) error {
r.init()
r.mu.Lock()
defer r.mu.Unlock()
switch def.Target {
case DescribesPackage:
r.forPkg[def.Name] = def
case DescribesType:
r.forType[def.Name] = def
case DescribesField:
r.forField[def.Name] = def
default:
return fmt.Errorf("unknown target type %v", def.Target)
}
return nil
}
// AddHelp stores the given help in the registry, marking it as associated with
// the given definition.
func (r *Registry) AddHelp(def *Definition, help *DefinitionHelp) {
r.init()
r.mu.Lock()
defer r.mu.Unlock()
r.helpFor[def] = help
}
// Lookup fetches the definition corresponding to the given name and target type.
func (r *Registry) Lookup(name string, target TargetType) *Definition {
r.init()
r.mu.RLock()
defer r.mu.RUnlock()
switch target {
case DescribesPackage:
return tryAnonLookup(name, r.forPkg)
case DescribesType:
return tryAnonLookup(name, r.forType)
case DescribesField:
return tryAnonLookup(name, r.forField)
default:
return nil
}
}
// HelpFor fetches the help for a given definition, if present.
func (r *Registry) HelpFor(def *Definition) *DefinitionHelp {
r.init()
r.mu.RLock()
defer r.mu.RUnlock()
return r.helpFor[def]
}
// AllDefinitions returns all marker definitions known to this registry.
func (r *Registry) AllDefinitions() []*Definition {
res := make([]*Definition, 0, len(r.forPkg)+len(r.forType)+len(r.forField))
for _, def := range r.forPkg {
res = append(res, def)
}
for _, def := range r.forType {
res = append(res, def)
}
for _, def := range r.forField {
res = append(res, def)
}
return res
}
// tryAnonLookup tries looking up the given marker as both an struct-based
// marker and an anonymous marker, returning whichever format matches first,
// preferring the longer (anonymous) name in case of conflicts.
func tryAnonLookup(name string, defs map[string]*Definition) *Definition {
// NB(directxman12): we look up anonymous names first to work with
// legacy style marker definitions that have a namespaced approach
// (e.g. deepcopy-gen, which uses `+k8s:deepcopy-gen=foo,bar` *and*
// `+k8s.io:deepcopy-gen:interfaces=foo`).
name, anonName, _ := splitMarker(name)
if def, exists := defs[anonName]; exists {
return def
}
return defs[name]
}
You can’t perform that action at this time.