访问者模式在 Kubernetes 中的使用

kubectl get {resourcetype} {resource_name}
kubectl edit {resourcetype} {resource_name}
…

func (f *factoryImpl) NewBuilder() *resource.Builder {
  return resource.NewBuilder(f.clientGetter)
}

type VisitorFunc func(*Info, error) error
type Visitor interface {
  Visit(VisitorFunc) error
}
type Info struct {
  Namespace   string
  Name        string
  OtherThings string
}
func (info *Info) Visit(fn VisitorFunc) error {
  return fn(info, nil)
}

kubectl get pod pod1 -n test -l abc=true

type Selector struct {
  Client        RESTClient
  Mapping       *meta.RESTMapping
  Namespace     string
  LabelSelector string
  FieldSelector string
  LimitChunks   int64
}

list, err := helper.List(
    r.Namespace,
    r.ResourceMapping().GroupVersionKind.GroupVersion().String(),
    &options,
)
if err != nil {
    return nil, EnhanceListError(err, options, r.Mapping.Resource.String())
}
resourceVersion, _ := metadataAccessor.ResourceVersion(list)

info := &Info{
    Client:  r.Client,
    Mapping: r.Mapping,

    Namespace:       r.Namespace,
    ResourceVersion: resourceVersion,

    Object: list,
}

if err := fn(info, nil); err != nil {
    return nil, err
}

// DecoratedVisitor will invoke the decorators in order prior to invoking the visitor function
// passed to Visit. An error will terminate the visit.
type DecoratedVisitor struct {
 visitor    Visitor
 decorators []VisitorFunc
}

// NewDecoratedVisitor will create a visitor that invokes the provided visitor functions before
// the user supplied visitor function is invoked, giving them the opportunity to mutate the Info
// object or terminate early with an error.
func NewDecoratedVisitor(v Visitor, fn ...VisitorFunc) Visitor {
 if len(fn) == 0 {
  return v
 }
 return DecoratedVisitor{v, fn}
}

// Visit implements Visitor
func (v DecoratedVisitor) Visit(fn VisitorFunc) error {
 return v.visitor.Visit(func(info *Info, err error) error {
  if err != nil {
   return err
  }
  for i := range v.decorators {
   if err := v.decorators[i](info, nil "i"); err != nil {
    return err
   }
  }
  return fn(info, nil)
 })
}

if b.latest {
    // must set namespace prior to fetching
    if b.defaultNamespace {
        visitors = NewDecoratedVisitor(visitors, SetNamespace(b.namespace))
    }
    visitors = NewDecoratedVisitor(visitors, RetrieveLatest)
}

// visitor.go: RetrieveLatest updates the Object on each Info by invoking a standard client
// Get.
func RetrieveLatest(info *Info, err error) error {
 if err != nil {
  return err
 }
 if meta.IsListType(info.Object) {
  return fmt.Errorf("watch is only supported on individual resources and resource collections, but a list of resources is found")
 }
 if len(info.Name) == 0 {
  return nil
 }
 if info.Namespaced() && len(info.Namespace) == 0 {
  return fmt.Errorf("no namespace set on resource %s %q", info.Mapping.Resource, info.Name)
 }
 return info.Get()
}

type VisitorFunc func(*Info, error) error

type GroupRbacVisitor struct {
  visitor Visitor
  results map[string]GroupResult
}

func (v GroupRbacVisitor) Visit(fn VisitorFunc) error {
 return v.visitor.Visit(func(info *Info, err error) error {
   // ...
 }
}

type IdentityVisitor struct {
  visitor Visitor
  results map[string]IdentityResult
}

func (v IdentityVisitor) Visit(fn VisitorFunc) error {
  return v.visitor.Visit(func(info *Info, err error) error {
    // ...
  }
}

func FetchAll(c *cobra.Command, visitors []Visitor) error {
  // ...
  for _, visitor := range visitors {
    v.Visit(func(*Info, error) error {
    //...
   })
  }
// ...
}