working commit
This commit is contained in:
+145
@@ -0,0 +1,145 @@
|
||||
// Copyright 2019 The Kubernetes Authors.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package resmap
|
||||
|
||||
import (
|
||||
"sigs.k8s.io/kustomize/api/ifc"
|
||||
"sigs.k8s.io/kustomize/api/internal/kusterr"
|
||||
"sigs.k8s.io/kustomize/api/resource"
|
||||
"sigs.k8s.io/kustomize/api/types"
|
||||
"sigs.k8s.io/kustomize/kyaml/errors"
|
||||
"sigs.k8s.io/kustomize/kyaml/yaml"
|
||||
)
|
||||
|
||||
// Factory makes instances of ResMap.
|
||||
type Factory struct {
|
||||
// Makes resources.
|
||||
resF *resource.Factory
|
||||
}
|
||||
|
||||
// NewFactory returns a new resmap.Factory.
|
||||
func NewFactory(rf *resource.Factory) *Factory {
|
||||
return &Factory{resF: rf}
|
||||
}
|
||||
|
||||
// RF returns a resource.Factory.
|
||||
func (rmF *Factory) RF() *resource.Factory {
|
||||
return rmF.resF
|
||||
}
|
||||
|
||||
func New() ResMap {
|
||||
return newOne()
|
||||
}
|
||||
|
||||
// FromResource returns a ResMap with one entry.
|
||||
func (rmF *Factory) FromResource(res *resource.Resource) ResMap {
|
||||
m, err := newResMapFromResourceSlice([]*resource.Resource{res})
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// FromResourceSlice returns a ResMap with a slice of resources.
|
||||
func (rmF *Factory) FromResourceSlice(ress []*resource.Resource) ResMap {
|
||||
m, err := newResMapFromResourceSlice(ress)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// FromFile returns a ResMap given a resource path.
|
||||
func (rmF *Factory) FromFile(
|
||||
loader ifc.Loader, path string) (ResMap, error) {
|
||||
content, err := loader.Load(path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
m, err := rmF.NewResMapFromBytes(content)
|
||||
if err != nil {
|
||||
return nil, kusterr.Handler(err, path)
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// NewResMapFromBytes decodes a list of objects in byte array format.
|
||||
func (rmF *Factory) NewResMapFromBytes(b []byte) (ResMap, error) {
|
||||
resources, err := rmF.resF.SliceFromBytes(b)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return newResMapFromResourceSlice(resources)
|
||||
}
|
||||
|
||||
// NewResMapFromConfigMapArgs returns a Resource slice given
|
||||
// a configmap metadata slice from kustomization file.
|
||||
func (rmF *Factory) NewResMapFromConfigMapArgs(
|
||||
kvLdr ifc.KvLoader, argList []types.ConfigMapArgs) (ResMap, error) {
|
||||
var resources []*resource.Resource
|
||||
for i := range argList {
|
||||
res, err := rmF.resF.MakeConfigMap(kvLdr, &argList[i])
|
||||
if err != nil {
|
||||
return nil, errors.WrapPrefixf(err, "NewResMapFromConfigMapArgs")
|
||||
}
|
||||
resources = append(resources, res)
|
||||
}
|
||||
return newResMapFromResourceSlice(resources)
|
||||
}
|
||||
|
||||
// FromConfigMapArgs creates a new ResMap containing one ConfigMap.
|
||||
func (rmF *Factory) FromConfigMapArgs(
|
||||
kvLdr ifc.KvLoader, args types.ConfigMapArgs) (ResMap, error) {
|
||||
res, err := rmF.resF.MakeConfigMap(kvLdr, &args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return rmF.FromResource(res), nil
|
||||
}
|
||||
|
||||
// NewResMapFromSecretArgs takes a SecretArgs slice, generates
|
||||
// secrets from each entry, and accumulates them in a ResMap.
|
||||
func (rmF *Factory) NewResMapFromSecretArgs(
|
||||
kvLdr ifc.KvLoader, argsList []types.SecretArgs) (ResMap, error) {
|
||||
var resources []*resource.Resource
|
||||
for i := range argsList {
|
||||
res, err := rmF.resF.MakeSecret(kvLdr, &argsList[i])
|
||||
if err != nil {
|
||||
return nil, errors.WrapPrefixf(err, "NewResMapFromSecretArgs")
|
||||
}
|
||||
resources = append(resources, res)
|
||||
}
|
||||
return newResMapFromResourceSlice(resources)
|
||||
}
|
||||
|
||||
// FromSecretArgs creates a new ResMap containing one secret.
|
||||
func (rmF *Factory) FromSecretArgs(
|
||||
kvLdr ifc.KvLoader, args types.SecretArgs) (ResMap, error) {
|
||||
res, err := rmF.resF.MakeSecret(kvLdr, &args)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return rmF.FromResource(res), nil
|
||||
}
|
||||
|
||||
func newResMapFromResourceSlice(
|
||||
resources []*resource.Resource) (ResMap, error) {
|
||||
result := New()
|
||||
for _, res := range resources {
|
||||
err := result.Append(res)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// NewResMapFromRNodeSlice returns a ResMap from a slice of RNodes
|
||||
func (rmF *Factory) NewResMapFromRNodeSlice(s []*yaml.RNode) (ResMap, error) {
|
||||
rs, err := rmF.resF.ResourcesFromRNodes(s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return newResMapFromResourceSlice(rs)
|
||||
}
|
||||
+333
@@ -0,0 +1,333 @@
|
||||
// Copyright 2019 The Kubernetes Authors.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Package resmap implements a map from ResId to Resource that
|
||||
// tracks all resources in a kustomization.
|
||||
package resmap
|
||||
|
||||
import (
|
||||
"sigs.k8s.io/kustomize/api/ifc"
|
||||
"sigs.k8s.io/kustomize/api/resource"
|
||||
"sigs.k8s.io/kustomize/api/types"
|
||||
"sigs.k8s.io/kustomize/kyaml/kio"
|
||||
"sigs.k8s.io/kustomize/kyaml/resid"
|
||||
"sigs.k8s.io/kustomize/kyaml/yaml"
|
||||
)
|
||||
|
||||
// A Transformer modifies an instance of ResMap.
|
||||
type Transformer interface {
|
||||
// Transform modifies data in the argument,
|
||||
// e.g. adding labels to resources that can be labelled.
|
||||
Transform(m ResMap) error
|
||||
}
|
||||
|
||||
// A TransformerWithProperties contains a Transformer and stores
|
||||
// some of its properties
|
||||
type TransformerWithProperties struct {
|
||||
Transformer
|
||||
Origin *resource.Origin
|
||||
}
|
||||
|
||||
// A Generator creates an instance of ResMap.
|
||||
type Generator interface {
|
||||
Generate() (ResMap, error)
|
||||
}
|
||||
|
||||
// A GeneratorWithProperties contains a Generator and stores
|
||||
// some of its properties
|
||||
type GeneratorWithProperties struct {
|
||||
Generator
|
||||
Origin *resource.Origin
|
||||
}
|
||||
|
||||
// Something that's configurable accepts an
|
||||
// instance of PluginHelpers and a raw config
|
||||
// object (YAML in []byte form).
|
||||
type Configurable interface {
|
||||
Config(h *PluginHelpers, config []byte) error
|
||||
}
|
||||
|
||||
// NewPluginHelpers makes an instance of PluginHelpers.
|
||||
func NewPluginHelpers(
|
||||
ldr ifc.Loader, v ifc.Validator, rf *Factory,
|
||||
pc *types.PluginConfig) *PluginHelpers {
|
||||
return &PluginHelpers{ldr: ldr, v: v, rf: rf, pc: pc}
|
||||
}
|
||||
|
||||
// PluginHelpers holds things that any or all plugins might need.
|
||||
// This should be available to each plugin, in addition to
|
||||
// any plugin-specific configuration.
|
||||
type PluginHelpers struct {
|
||||
ldr ifc.Loader
|
||||
v ifc.Validator
|
||||
rf *Factory
|
||||
pc *types.PluginConfig
|
||||
}
|
||||
|
||||
func (c *PluginHelpers) GeneralConfig() *types.PluginConfig {
|
||||
return c.pc
|
||||
}
|
||||
|
||||
func (c *PluginHelpers) Loader() ifc.Loader {
|
||||
return c.ldr
|
||||
}
|
||||
|
||||
func (c *PluginHelpers) ResmapFactory() *Factory {
|
||||
return c.rf
|
||||
}
|
||||
|
||||
func (c *PluginHelpers) Validator() ifc.Validator {
|
||||
return c.v
|
||||
}
|
||||
|
||||
type GeneratorPlugin interface {
|
||||
Generator
|
||||
Configurable
|
||||
}
|
||||
|
||||
type TransformerPlugin interface {
|
||||
Transformer
|
||||
Configurable
|
||||
}
|
||||
|
||||
// ResMap is an interface describing operations on the
|
||||
// core kustomize data structure, a list of Resources.
|
||||
//
|
||||
// Every Resource has two ResIds: OrgId and CurId.
|
||||
//
|
||||
// In a ResMap, no two resources may have the same CurId,
|
||||
// but they may have the same OrgId. The latter can happen
|
||||
// when mixing two or more different overlays apply different
|
||||
// transformations to a common base. When looking for a
|
||||
// resource to transform, try the OrgId first, and if this
|
||||
// fails or finds too many, it might make sense to then try
|
||||
// the CurrId. Depends on the situation.
|
||||
//
|
||||
// TODO: get rid of this interface (use bare resWrangler).
|
||||
// There aren't multiple implementations any more.
|
||||
type ResMap interface {
|
||||
// Size reports the number of resources.
|
||||
Size() int
|
||||
|
||||
// Resources provides a discardable slice
|
||||
// of resource pointers, returned in the order
|
||||
// as appended.
|
||||
Resources() []*resource.Resource
|
||||
|
||||
// Append adds a Resource. Error on CurId collision.
|
||||
//
|
||||
// A class invariant of ResMap is that all of its
|
||||
// resources must differ in their value of
|
||||
// CurId(), aka current Id. The Id is the tuple
|
||||
// of {namespace, group, version, kind, name}
|
||||
// (see ResId).
|
||||
//
|
||||
// This invariant reflects the invariant of a
|
||||
// kubernetes cluster, where if one tries to add
|
||||
// a resource to the cluster whose Id matches
|
||||
// that of a resource already in the cluster,
|
||||
// only two outcomes are allowed. Either the
|
||||
// incoming resource is _merged_ into the existing
|
||||
// one, or the incoming resource is rejected.
|
||||
// One cannot end up with two resources
|
||||
// in the cluster with the same Id.
|
||||
Append(*resource.Resource) error
|
||||
|
||||
// AppendAll appends another ResMap to self,
|
||||
// failing on any CurId collision.
|
||||
AppendAll(ResMap) error
|
||||
|
||||
// AbsorbAll appends, replaces or merges the contents
|
||||
// of another ResMap into self,
|
||||
// allowing and sometimes demanding ID collisions.
|
||||
// A collision would be demanded, say, when a generated
|
||||
// ConfigMap has the "replace" option in its generation
|
||||
// instructions, meaning it _must_ replace
|
||||
// something in the known set of resources.
|
||||
// If a resource id for resource X is found to already
|
||||
// be in self, then the behavior field for X must
|
||||
// be BehaviorMerge or BehaviorReplace. If X is not in
|
||||
// self, then its behavior _cannot_ be merge or replace.
|
||||
AbsorbAll(ResMap) error
|
||||
|
||||
// AddOriginAnnotation will add the provided origin as
|
||||
// an origin annotation to all resources in the ResMap, if
|
||||
// the origin is not nil.
|
||||
AddOriginAnnotation(origin *resource.Origin) error
|
||||
|
||||
// RemoveOriginAnnotation will remove the origin annotation
|
||||
// from all resources in the ResMap
|
||||
RemoveOriginAnnotations() error
|
||||
|
||||
// AddTransformerAnnotation will add the provided origin as
|
||||
// an origin annotation if the resource doesn't have one; a
|
||||
// transformer annotation otherwise; to all resources in
|
||||
// ResMap
|
||||
AddTransformerAnnotation(origin *resource.Origin) error
|
||||
|
||||
// RemoveTransformerAnnotation will remove the transformer annotation
|
||||
// from all resources in the ResMap
|
||||
RemoveTransformerAnnotations() error
|
||||
|
||||
// AnnotateAll annotates all resources in the ResMap with
|
||||
// the provided key value pair.
|
||||
AnnotateAll(key string, value string) error
|
||||
|
||||
// AsYaml returns the yaml form of resources.
|
||||
AsYaml() ([]byte, error)
|
||||
|
||||
// GetByIndex returns a resource at the given index,
|
||||
// nil if out of range.
|
||||
GetByIndex(int) *resource.Resource
|
||||
|
||||
// GetIndexOfCurrentId returns the index of the resource
|
||||
// with the given CurId.
|
||||
// Returns error if there is more than one match.
|
||||
// Returns (-1, nil) if there is no match.
|
||||
GetIndexOfCurrentId(id resid.ResId) (int, error)
|
||||
|
||||
// GetMatchingResourcesByCurrentId returns the resources
|
||||
// who's CurId is matched by the argument.
|
||||
GetMatchingResourcesByCurrentId(matches IdMatcher) []*resource.Resource
|
||||
|
||||
// GetMatchingResourcesByAnyId returns the resources
|
||||
// who's current or previous IDs is matched by the argument.
|
||||
GetMatchingResourcesByAnyId(matches IdMatcher) []*resource.Resource
|
||||
|
||||
// GetByCurrentId is shorthand for calling
|
||||
// GetMatchingResourcesByCurrentId with a matcher requiring
|
||||
// an exact match, returning an error on multiple or no matches.
|
||||
GetByCurrentId(resid.ResId) (*resource.Resource, error)
|
||||
|
||||
// GetById is shorthand for calling
|
||||
// GetMatchingResourcesByAnyId with a matcher requiring
|
||||
// an exact match, returning an error on multiple or no matches.
|
||||
GetById(resid.ResId) (*resource.Resource, error)
|
||||
|
||||
// GroupedByCurrentNamespace returns a map of namespace
|
||||
// to a slice of *Resource in that namespace.
|
||||
// Cluster-scoped Resources are not included (see ClusterScoped).
|
||||
// Resources with an empty namespace are placed
|
||||
// in the resid.DefaultNamespace entry.
|
||||
GroupedByCurrentNamespace() map[string][]*resource.Resource
|
||||
|
||||
// GroupedByOriginalNamespace performs as GroupByNamespace
|
||||
// but use the original namespace instead of the current
|
||||
// one to perform the grouping.
|
||||
GroupedByOriginalNamespace() map[string][]*resource.Resource
|
||||
|
||||
// ClusterScoped returns a slice of resources that
|
||||
// cannot be placed in a namespace, e.g.
|
||||
// Node, ClusterRole, Namespace itself, etc.
|
||||
ClusterScoped() []*resource.Resource
|
||||
|
||||
// AllIds returns all CurrentIds.
|
||||
AllIds() []resid.ResId
|
||||
|
||||
// Replace replaces the resource with the matching CurId.
|
||||
// Error if there's no match or more than one match.
|
||||
// Returns the index where the replacement happened.
|
||||
Replace(*resource.Resource) (int, error)
|
||||
|
||||
// Remove removes the resource whose CurId matches the argument.
|
||||
// Error if not found.
|
||||
Remove(resid.ResId) error
|
||||
|
||||
// Clear removes all resources and Ids.
|
||||
Clear()
|
||||
|
||||
// DropEmpties drops empty resources from the ResMap.
|
||||
DropEmpties()
|
||||
|
||||
// SubsetThatCouldBeReferencedByResource returns a ResMap subset
|
||||
// of self with resources that could be referenced by the
|
||||
// resource argument.
|
||||
// This is a filter; it excludes things that cannot be
|
||||
// referenced by the resource, e.g. objects in other
|
||||
// namespaces. Cluster wide objects are never excluded.
|
||||
SubsetThatCouldBeReferencedByResource(*resource.Resource) (ResMap, error)
|
||||
|
||||
// DeAnchor replaces YAML aliases with structured data copied from anchors.
|
||||
// This cannot be undone; if desired, call DeepCopy first.
|
||||
// Subsequent marshalling to YAML will no longer have anchor
|
||||
// definitions ('&') or aliases ('*').
|
||||
//
|
||||
// Anchors are not expected to work across YAML 'documents'.
|
||||
// If three resources are loaded from one file containing three YAML docs:
|
||||
//
|
||||
// {resourceA}
|
||||
// ---
|
||||
// {resourceB}
|
||||
// ---
|
||||
// {resourceC}
|
||||
//
|
||||
// then anchors defined in A cannot be seen from B and C and vice versa.
|
||||
// OTOH, cross-resource links (a field in B referencing fields in A) will
|
||||
// work if the resources are gathered in a ResourceList:
|
||||
//
|
||||
// apiVersion: config.kubernetes.io/v1
|
||||
// kind: ResourceList
|
||||
// metadata:
|
||||
// name: someList
|
||||
// items:
|
||||
// - {resourceA}
|
||||
// - {resourceB}
|
||||
// - {resourceC}
|
||||
//
|
||||
DeAnchor() error
|
||||
|
||||
// DeepCopy copies the ResMap and underlying resources.
|
||||
DeepCopy() ResMap
|
||||
|
||||
// ShallowCopy copies the ResMap but
|
||||
// not the underlying resources.
|
||||
ShallowCopy() ResMap
|
||||
|
||||
// ErrorIfNotEqualSets returns an error if the
|
||||
// argument doesn't have the same resources as self.
|
||||
// Ordering is _not_ taken into account,
|
||||
// as this function was solely used in tests written
|
||||
// before internal resource order was maintained,
|
||||
// and those tests are initialized with maps which
|
||||
// by definition have random ordering, and will
|
||||
// fail spuriously.
|
||||
// TODO: modify tests to not use resmap.FromMap,
|
||||
// TODO: - and replace this with a stricter equals.
|
||||
ErrorIfNotEqualSets(ResMap) error
|
||||
|
||||
// ErrorIfNotEqualLists returns an error if the
|
||||
// argument doesn't have the resource objects
|
||||
// data as self, in the same order.
|
||||
// Meta information is ignored; this is similar
|
||||
// to comparing the AsYaml() strings, but allows
|
||||
// for more informed errors on not equals.
|
||||
ErrorIfNotEqualLists(ResMap) error
|
||||
|
||||
// Debug prints the ResMap.
|
||||
Debug(title string)
|
||||
|
||||
// Select returns a list of resources that
|
||||
// are selected by a Selector
|
||||
Select(types.Selector) ([]*resource.Resource, error)
|
||||
|
||||
// ToRNodeSlice returns a copy of the resources as RNodes.
|
||||
ToRNodeSlice() []*yaml.RNode
|
||||
|
||||
// ApplySmPatch applies a strategic-merge patch to the
|
||||
// selected set of resources.
|
||||
ApplySmPatch(
|
||||
selectedSet *resource.IdSet, patch *resource.Resource) error
|
||||
|
||||
// RemoveBuildAnnotations removes annotations created by the build process.
|
||||
RemoveBuildAnnotations()
|
||||
|
||||
// ApplyFilter applies an RNode filter to all Resources in the ResMap.
|
||||
// TODO: Send/recover ancillary Resource data to/from subprocesses.
|
||||
// Assure that the ancillary data in Resource (everything not in the RNode)
|
||||
// is sent to and re-captured from transformer subprocess (as the process
|
||||
// might edit that information). One way to do this would be to solely use
|
||||
// RNode metadata annotation reading and writing instead of using Resource
|
||||
// struct data members, i.e. the Resource struct is replaced by RNode
|
||||
// and use of (slow) k8s metadata annotations inside the RNode.
|
||||
ApplyFilter(f kio.Filter) error
|
||||
}
|
||||
+767
@@ -0,0 +1,767 @@
|
||||
// Copyright 2019 The Kubernetes Authors.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package resmap
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"reflect"
|
||||
|
||||
"sigs.k8s.io/kustomize/api/filters/annotations"
|
||||
"sigs.k8s.io/kustomize/api/resource"
|
||||
"sigs.k8s.io/kustomize/api/types"
|
||||
"sigs.k8s.io/kustomize/kyaml/errors"
|
||||
"sigs.k8s.io/kustomize/kyaml/kio"
|
||||
"sigs.k8s.io/kustomize/kyaml/resid"
|
||||
kyaml "sigs.k8s.io/kustomize/kyaml/yaml"
|
||||
)
|
||||
|
||||
// resWrangler implements ResMap.
|
||||
type resWrangler struct {
|
||||
// Resource list maintained in load (append) order.
|
||||
// This is important for transformers, which must
|
||||
// be performed in a specific order, and for users
|
||||
// who for whatever reasons wish the order they
|
||||
// specify in kustomizations to be maintained and
|
||||
// available as an option for final YAML rendering.
|
||||
rList []*resource.Resource
|
||||
}
|
||||
|
||||
func newOne() *resWrangler {
|
||||
result := &resWrangler{}
|
||||
result.Clear()
|
||||
return result
|
||||
}
|
||||
|
||||
// Clear implements ResMap.
|
||||
func (m *resWrangler) Clear() {
|
||||
m.rList = nil
|
||||
}
|
||||
|
||||
// DropEmpties quickly drops empty resources.
|
||||
// It doesn't use Append, which checks for Id collisions.
|
||||
func (m *resWrangler) DropEmpties() {
|
||||
var rList []*resource.Resource
|
||||
for _, r := range m.rList {
|
||||
if !r.IsNilOrEmpty() {
|
||||
rList = append(rList, r)
|
||||
}
|
||||
}
|
||||
m.rList = rList
|
||||
}
|
||||
|
||||
// Size implements ResMap.
|
||||
func (m *resWrangler) Size() int {
|
||||
return len(m.rList)
|
||||
}
|
||||
|
||||
func (m *resWrangler) indexOfResource(other *resource.Resource) int {
|
||||
for i, r := range m.rList {
|
||||
if r == other {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// Resources implements ResMap.
|
||||
func (m *resWrangler) Resources() []*resource.Resource {
|
||||
tmp := make([]*resource.Resource, len(m.rList))
|
||||
copy(tmp, m.rList)
|
||||
return tmp
|
||||
}
|
||||
|
||||
// Append implements ResMap.
|
||||
func (m *resWrangler) Append(res *resource.Resource) error {
|
||||
id := res.CurId()
|
||||
if r := m.GetMatchingResourcesByCurrentId(id.Equals); len(r) > 0 {
|
||||
return fmt.Errorf(
|
||||
"may not add resource with an already registered id: %s", id)
|
||||
}
|
||||
m.append(res)
|
||||
return nil
|
||||
}
|
||||
|
||||
// append appends without performing an Id check
|
||||
func (m *resWrangler) append(res *resource.Resource) {
|
||||
m.rList = append(m.rList, res)
|
||||
}
|
||||
|
||||
// Remove implements ResMap.
|
||||
func (m *resWrangler) Remove(adios resid.ResId) error {
|
||||
var rList []*resource.Resource
|
||||
for _, r := range m.rList {
|
||||
if r.CurId() != adios {
|
||||
rList = append(rList, r)
|
||||
}
|
||||
}
|
||||
if len(rList) != m.Size()-1 {
|
||||
return fmt.Errorf("id %s not found in removal", adios)
|
||||
}
|
||||
m.rList = rList
|
||||
return nil
|
||||
}
|
||||
|
||||
// Replace implements ResMap.
|
||||
func (m *resWrangler) Replace(res *resource.Resource) (int, error) {
|
||||
id := res.CurId()
|
||||
i, err := m.GetIndexOfCurrentId(id)
|
||||
if err != nil {
|
||||
return -1, errors.WrapPrefixf(err, "in Replace")
|
||||
}
|
||||
if i < 0 {
|
||||
return -1, fmt.Errorf("cannot find resource with id %s to replace", id)
|
||||
}
|
||||
m.rList[i] = res
|
||||
return i, nil
|
||||
}
|
||||
|
||||
// AllIds implements ResMap.
|
||||
func (m *resWrangler) AllIds() (ids []resid.ResId) {
|
||||
ids = make([]resid.ResId, m.Size())
|
||||
for i, r := range m.rList {
|
||||
ids[i] = r.CurId()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Debug implements ResMap.
|
||||
func (m *resWrangler) Debug(title string) {
|
||||
fmt.Println("--------------------------- " + title)
|
||||
firstObj := true
|
||||
for i, r := range m.rList {
|
||||
if firstObj {
|
||||
firstObj = false
|
||||
} else {
|
||||
fmt.Println("---")
|
||||
}
|
||||
fmt.Printf("# %d %s\n%s\n", i, r.OrgId(), r.String())
|
||||
}
|
||||
}
|
||||
|
||||
type IdMatcher func(resid.ResId) bool
|
||||
|
||||
// GetByIndex implements ResMap.
|
||||
func (m *resWrangler) GetByIndex(i int) *resource.Resource {
|
||||
if i < 0 || i >= m.Size() {
|
||||
return nil
|
||||
}
|
||||
return m.rList[i]
|
||||
}
|
||||
|
||||
// GetIndexOfCurrentId implements ResMap.
|
||||
func (m *resWrangler) GetIndexOfCurrentId(id resid.ResId) (int, error) {
|
||||
count := 0
|
||||
result := -1
|
||||
for i, r := range m.rList {
|
||||
if id.Equals(r.CurId()) {
|
||||
count++
|
||||
result = i
|
||||
}
|
||||
}
|
||||
if count > 1 {
|
||||
return -1, fmt.Errorf("id matched %d resources", count)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
type IdFromResource func(r *resource.Resource) resid.ResId
|
||||
|
||||
func GetCurrentId(r *resource.Resource) resid.ResId { return r.CurId() }
|
||||
|
||||
// GetMatchingResourcesByCurrentId implements ResMap.
|
||||
func (m *resWrangler) GetMatchingResourcesByCurrentId(
|
||||
matches IdMatcher) []*resource.Resource {
|
||||
return m.filteredById(matches, GetCurrentId)
|
||||
}
|
||||
|
||||
// GetMatchingResourcesByAnyId implements ResMap.
|
||||
func (m *resWrangler) GetMatchingResourcesByAnyId(
|
||||
matches IdMatcher) []*resource.Resource {
|
||||
var result []*resource.Resource
|
||||
for _, r := range m.rList {
|
||||
if r.RNode.IsNilOrEmpty() {
|
||||
continue
|
||||
}
|
||||
|
||||
for _, id := range append(r.PrevIds(), r.CurId()) {
|
||||
if matches(id) {
|
||||
result = append(result, r)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func (m *resWrangler) filteredById(
|
||||
matches IdMatcher, idGetter IdFromResource) []*resource.Resource {
|
||||
var result []*resource.Resource
|
||||
for _, r := range m.rList {
|
||||
if matches(idGetter(r)) {
|
||||
result = append(result, r)
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// GetByCurrentId implements ResMap.
|
||||
func (m *resWrangler) GetByCurrentId(
|
||||
id resid.ResId) (*resource.Resource, error) {
|
||||
return demandOneMatch(m.GetMatchingResourcesByCurrentId, id, "Current")
|
||||
}
|
||||
|
||||
// GetById implements ResMap.
|
||||
func (m *resWrangler) GetById(
|
||||
id resid.ResId) (*resource.Resource, error) {
|
||||
r, err := demandOneMatch(m.GetMatchingResourcesByAnyId, id, "Id")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf(
|
||||
"%s; failed to find unique target for patch %s",
|
||||
err.Error(), id.String())
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
type resFinder func(IdMatcher) []*resource.Resource
|
||||
|
||||
func demandOneMatch(
|
||||
f resFinder, id resid.ResId, s string) (*resource.Resource, error) {
|
||||
r := f(id.Equals)
|
||||
if len(r) == 1 {
|
||||
return r[0], nil
|
||||
}
|
||||
if len(r) > 1 {
|
||||
return nil, fmt.Errorf("multiple matches for %s %s", s, id)
|
||||
}
|
||||
return nil, fmt.Errorf("no matches for %s %s", s, id)
|
||||
}
|
||||
|
||||
// GroupedByCurrentNamespace implements ResMap.
|
||||
func (m *resWrangler) GroupedByCurrentNamespace() map[string][]*resource.Resource {
|
||||
items := m.groupedByCurrentNamespace()
|
||||
delete(items, resid.TotallyNotANamespace)
|
||||
return items
|
||||
}
|
||||
|
||||
// ClusterScoped implements ResMap.
|
||||
func (m *resWrangler) ClusterScoped() []*resource.Resource {
|
||||
return m.groupedByCurrentNamespace()[resid.TotallyNotANamespace]
|
||||
}
|
||||
|
||||
func (m *resWrangler) groupedByCurrentNamespace() map[string][]*resource.Resource {
|
||||
byNamespace := make(map[string][]*resource.Resource)
|
||||
for _, res := range m.rList {
|
||||
namespace := res.CurId().EffectiveNamespace()
|
||||
if _, found := byNamespace[namespace]; !found {
|
||||
byNamespace[namespace] = []*resource.Resource{}
|
||||
}
|
||||
byNamespace[namespace] = append(byNamespace[namespace], res)
|
||||
}
|
||||
return byNamespace
|
||||
}
|
||||
|
||||
// GroupedByOriginalNamespace implements ResMap.
|
||||
func (m *resWrangler) GroupedByOriginalNamespace() map[string][]*resource.Resource {
|
||||
items := m.groupedByOriginalNamespace()
|
||||
delete(items, resid.TotallyNotANamespace)
|
||||
return items
|
||||
}
|
||||
|
||||
func (m *resWrangler) groupedByOriginalNamespace() map[string][]*resource.Resource {
|
||||
byNamespace := make(map[string][]*resource.Resource)
|
||||
for _, res := range m.rList {
|
||||
namespace := res.OrgId().EffectiveNamespace()
|
||||
if _, found := byNamespace[namespace]; !found {
|
||||
byNamespace[namespace] = []*resource.Resource{}
|
||||
}
|
||||
byNamespace[namespace] = append(byNamespace[namespace], res)
|
||||
}
|
||||
return byNamespace
|
||||
}
|
||||
|
||||
// AsYaml implements ResMap.
|
||||
func (m *resWrangler) AsYaml() ([]byte, error) {
|
||||
firstObj := true
|
||||
var b []byte
|
||||
buf := bytes.NewBuffer(b)
|
||||
for _, res := range m.rList {
|
||||
out, err := res.AsYAML()
|
||||
if err != nil {
|
||||
m, _ := res.Map()
|
||||
return nil, errors.WrapPrefixf(err, "%#v", m)
|
||||
}
|
||||
if firstObj {
|
||||
firstObj = false
|
||||
} else {
|
||||
if _, err = buf.WriteString("---\n"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if _, err = buf.Write(out); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return buf.Bytes(), nil
|
||||
}
|
||||
|
||||
// ErrorIfNotEqualSets implements ResMap.
|
||||
func (m *resWrangler) ErrorIfNotEqualSets(other ResMap) error {
|
||||
m2, ok := other.(*resWrangler)
|
||||
if !ok {
|
||||
return fmt.Errorf("bad cast to resWrangler 1")
|
||||
}
|
||||
if m.Size() != m2.Size() {
|
||||
return fmt.Errorf(
|
||||
"lists have different number of entries: %#v doesn't equal %#v",
|
||||
m.rList, m2.rList)
|
||||
}
|
||||
seen := make(map[int]bool)
|
||||
for _, r1 := range m.rList {
|
||||
id := r1.CurId()
|
||||
others := m2.GetMatchingResourcesByCurrentId(id.Equals)
|
||||
if len(others) == 0 {
|
||||
return fmt.Errorf(
|
||||
"id in self missing from other; id: %s", id)
|
||||
}
|
||||
if len(others) > 1 {
|
||||
return fmt.Errorf(
|
||||
"id in self matches %d in other; id: %s", len(others), id)
|
||||
}
|
||||
r2 := others[0]
|
||||
if !reflect.DeepEqual(r1.RNode, r2.RNode) {
|
||||
return fmt.Errorf(
|
||||
"nodes unequal: \n -- %s,\n -- %s\n\n--\n%#v\n------\n%#v\n",
|
||||
r1, r2, r1, r2)
|
||||
}
|
||||
seen[m2.indexOfResource(r2)] = true
|
||||
}
|
||||
if len(seen) != m.Size() {
|
||||
return fmt.Errorf("counting problem %d != %d", len(seen), m.Size())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ErrorIfNotEqualLists implements ResMap.
|
||||
func (m *resWrangler) ErrorIfNotEqualLists(other ResMap) error {
|
||||
m2, ok := other.(*resWrangler)
|
||||
if !ok {
|
||||
return fmt.Errorf("bad cast to resWrangler 2")
|
||||
}
|
||||
if m.Size() != m2.Size() {
|
||||
return fmt.Errorf(
|
||||
"lists have different number of entries: %#v doesn't equal %#v",
|
||||
m.rList, m2.rList)
|
||||
}
|
||||
for i, r1 := range m.rList {
|
||||
r2 := m2.rList[i]
|
||||
if err := r1.ErrIfNotEquals(r2); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type resCopier func(r *resource.Resource) *resource.Resource
|
||||
|
||||
// ShallowCopy implements ResMap.
|
||||
func (m *resWrangler) ShallowCopy() ResMap {
|
||||
return m.makeCopy(
|
||||
func(r *resource.Resource) *resource.Resource {
|
||||
return r
|
||||
})
|
||||
}
|
||||
|
||||
// DeepCopy implements ResMap.
|
||||
func (m *resWrangler) DeepCopy() ResMap {
|
||||
return m.makeCopy(
|
||||
func(r *resource.Resource) *resource.Resource {
|
||||
return r.DeepCopy()
|
||||
})
|
||||
}
|
||||
|
||||
// makeCopy copies the ResMap.
|
||||
func (m *resWrangler) makeCopy(copier resCopier) ResMap {
|
||||
result := &resWrangler{}
|
||||
result.rList = make([]*resource.Resource, m.Size())
|
||||
for i, r := range m.rList {
|
||||
result.rList[i] = copier(r)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// SubsetThatCouldBeReferencedByResource implements ResMap.
|
||||
func (m *resWrangler) SubsetThatCouldBeReferencedByResource(
|
||||
referrer *resource.Resource) (ResMap, error) {
|
||||
referrerId := referrer.CurId()
|
||||
if referrerId.IsClusterScoped() {
|
||||
// A cluster scoped resource can refer to anything.
|
||||
return m, nil
|
||||
}
|
||||
result := newOne()
|
||||
roleBindingNamespaces, err := getNamespacesForRoleBinding(referrer)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, possibleTarget := range m.rList {
|
||||
id := possibleTarget.CurId()
|
||||
if id.IsClusterScoped() {
|
||||
// A cluster-scoped resource can be referred to by anything.
|
||||
result.append(possibleTarget)
|
||||
continue
|
||||
}
|
||||
if id.IsNsEquals(referrerId) {
|
||||
// The two objects are in the same namespace.
|
||||
result.append(possibleTarget)
|
||||
continue
|
||||
}
|
||||
// The two objects are namespaced (not cluster-scoped), AND
|
||||
// are in different namespaces.
|
||||
// There's still a chance they can refer to each other.
|
||||
if roleBindingNamespaces[possibleTarget.GetNamespace()] {
|
||||
result.append(possibleTarget)
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// getNamespacesForRoleBinding returns referenced ServiceAccount namespaces
|
||||
// if the resource is a RoleBinding
|
||||
func getNamespacesForRoleBinding(r *resource.Resource) (map[string]bool, error) {
|
||||
result := make(map[string]bool)
|
||||
if r.GetKind() != "RoleBinding" {
|
||||
return result, nil
|
||||
}
|
||||
subjects, err := r.GetSlice("subjects")
|
||||
if err != nil || subjects == nil {
|
||||
return result, nil
|
||||
}
|
||||
for _, s := range subjects {
|
||||
subject := s.(map[string]interface{})
|
||||
if ns, ok1 := subject["namespace"]; ok1 {
|
||||
if kind, ok2 := subject["kind"]; ok2 {
|
||||
if kind.(string) == "ServiceAccount" {
|
||||
if n, ok3 := ns.(string); ok3 {
|
||||
result[n] = true
|
||||
} else {
|
||||
return nil, errors.Errorf("Invalid Input: namespace is blank for resource %q\n", r.CurId())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// AppendAll implements ResMap.
|
||||
func (m *resWrangler) AppendAll(other ResMap) error {
|
||||
if other == nil {
|
||||
return nil
|
||||
}
|
||||
m2, ok := other.(*resWrangler)
|
||||
if !ok {
|
||||
return fmt.Errorf("bad cast to resWrangler 3")
|
||||
}
|
||||
return m.appendAll(m2.rList)
|
||||
}
|
||||
|
||||
// appendAll appends all the resources, error on Id collision.
|
||||
func (m *resWrangler) appendAll(list []*resource.Resource) error {
|
||||
for _, res := range list {
|
||||
if err := m.Append(res); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AbsorbAll implements ResMap.
|
||||
func (m *resWrangler) AbsorbAll(other ResMap) error {
|
||||
if other == nil {
|
||||
return nil
|
||||
}
|
||||
m2, ok := other.(*resWrangler)
|
||||
if !ok {
|
||||
return fmt.Errorf("bad cast to resWrangler 4")
|
||||
}
|
||||
for _, r := range m2.rList {
|
||||
err := m.appendReplaceOrMerge(r)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddOriginAnnotation implements ResMap.
|
||||
func (m *resWrangler) AddOriginAnnotation(origin *resource.Origin) error {
|
||||
if origin == nil {
|
||||
return nil
|
||||
}
|
||||
for _, res := range m.rList {
|
||||
or, err := res.GetOrigin()
|
||||
if or != nil || err != nil {
|
||||
// if any resources already have an origin annotation,
|
||||
// skip it
|
||||
continue
|
||||
}
|
||||
if err := res.SetOrigin(origin); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// RemoveOriginAnnotation implements ResMap
|
||||
func (m *resWrangler) RemoveOriginAnnotations() error {
|
||||
for _, res := range m.rList {
|
||||
if err := res.SetOrigin(nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddTransformerAnnotation implements ResMap
|
||||
func (m *resWrangler) AddTransformerAnnotation(origin *resource.Origin) error {
|
||||
for _, res := range m.rList {
|
||||
or, err := res.GetOrigin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if or == nil {
|
||||
// the resource does not have an origin annotation, so
|
||||
// we assume that the transformer generated the resource
|
||||
// rather than modifying it
|
||||
err = res.SetOrigin(origin)
|
||||
} else {
|
||||
// the resource already has an origin annotation, so we
|
||||
// record the provided origin as a transformation
|
||||
err = res.AddTransformation(origin)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// RemoveTransformerAnnotations implements ResMap
|
||||
func (m *resWrangler) RemoveTransformerAnnotations() error {
|
||||
for _, res := range m.rList {
|
||||
if err := res.ClearTransformations(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *resWrangler) appendReplaceOrMerge(res *resource.Resource) error {
|
||||
id := res.CurId()
|
||||
matches := m.GetMatchingResourcesByAnyId(id.Equals)
|
||||
switch len(matches) {
|
||||
case 0:
|
||||
switch res.Behavior() {
|
||||
case types.BehaviorMerge, types.BehaviorReplace:
|
||||
return fmt.Errorf(
|
||||
"id %#v does not exist; cannot merge or replace", id)
|
||||
default:
|
||||
// presumably types.BehaviorCreate
|
||||
return m.Append(res)
|
||||
}
|
||||
case 1:
|
||||
old := matches[0]
|
||||
if old == nil {
|
||||
return fmt.Errorf("id lookup failure")
|
||||
}
|
||||
index := m.indexOfResource(old)
|
||||
if index < 0 {
|
||||
return fmt.Errorf("indexing problem")
|
||||
}
|
||||
switch res.Behavior() {
|
||||
case types.BehaviorReplace:
|
||||
res.CopyMergeMetaDataFieldsFrom(old)
|
||||
case types.BehaviorMerge:
|
||||
// ensure the origin annotation doesn't get overwritten
|
||||
orig, err := old.GetOrigin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
res.CopyMergeMetaDataFieldsFrom(old)
|
||||
res.MergeDataMapFrom(old)
|
||||
res.MergeBinaryDataMapFrom(old)
|
||||
if orig != nil {
|
||||
res.SetOrigin(orig)
|
||||
}
|
||||
|
||||
default:
|
||||
return fmt.Errorf(
|
||||
"id %#v exists; can not use behavior: '%s', behavior must be merge or replace", id, res.Behavior())
|
||||
}
|
||||
i, err := m.Replace(res)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if i != index {
|
||||
return fmt.Errorf("unexpected target index in replacement")
|
||||
}
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf(
|
||||
"found multiple objects %v that could accept merge of %v",
|
||||
matches, id)
|
||||
}
|
||||
}
|
||||
|
||||
// AnnotateAll implements ResMap
|
||||
func (m *resWrangler) AnnotateAll(key string, value string) error {
|
||||
return m.ApplyFilter(annotations.Filter{
|
||||
Annotations: map[string]string{
|
||||
key: value,
|
||||
},
|
||||
FsSlice: []types.FieldSpec{{
|
||||
Path: "metadata/annotations",
|
||||
CreateIfNotPresent: true,
|
||||
}},
|
||||
})
|
||||
}
|
||||
|
||||
// Select returns a list of resources that
|
||||
// are selected by a Selector
|
||||
func (m *resWrangler) Select(s types.Selector) ([]*resource.Resource, error) {
|
||||
var result []*resource.Resource
|
||||
sr, err := types.NewSelectorRegex(&s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, r := range m.rList {
|
||||
curId := r.CurId()
|
||||
orgId := r.OrgId()
|
||||
|
||||
// It first tries to match with the original namespace
|
||||
// then matches with the current namespace
|
||||
if !sr.MatchNamespace(orgId.EffectiveNamespace()) &&
|
||||
!sr.MatchNamespace(curId.EffectiveNamespace()) {
|
||||
continue
|
||||
}
|
||||
|
||||
// It first tries to match with the original name
|
||||
// then matches with the current name
|
||||
if !sr.MatchName(orgId.Name) &&
|
||||
!sr.MatchName(curId.Name) {
|
||||
continue
|
||||
}
|
||||
|
||||
// matches the GVK
|
||||
if !sr.MatchGvk(r.GetGvk()) {
|
||||
continue
|
||||
}
|
||||
|
||||
// matches the label selector
|
||||
matched, err := r.MatchesLabelSelector(s.LabelSelector)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !matched {
|
||||
continue
|
||||
}
|
||||
|
||||
// matches the annotation selector
|
||||
matched, err = r.MatchesAnnotationSelector(s.AnnotationSelector)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !matched {
|
||||
continue
|
||||
}
|
||||
result = append(result, r)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// ToRNodeSlice returns a copy of the resources as RNodes.
|
||||
func (m *resWrangler) ToRNodeSlice() []*kyaml.RNode {
|
||||
result := make([]*kyaml.RNode, len(m.rList))
|
||||
for i := range m.rList {
|
||||
result[i] = m.rList[i].Copy()
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// DeAnchor implements ResMap.
|
||||
func (m *resWrangler) DeAnchor() (err error) {
|
||||
for i := range m.rList {
|
||||
if err = m.rList[i].DeAnchor(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ApplySmPatch applies the patch, and errors on Id collisions.
|
||||
func (m *resWrangler) ApplySmPatch(selectedSet *resource.IdSet, patch *resource.Resource) error {
|
||||
var list []*resource.Resource
|
||||
for _, res := range m.rList {
|
||||
if selectedSet.Contains(res.CurId()) {
|
||||
patchCopy := patch.DeepCopy()
|
||||
patchCopy.CopyMergeMetaDataFieldsFrom(patch)
|
||||
patchCopy.SetGvk(res.GetGvk())
|
||||
patchCopy.SetKind(patch.GetKind())
|
||||
if err := res.ApplySmPatch(patchCopy); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if !res.IsNilOrEmpty() {
|
||||
list = append(list, res)
|
||||
}
|
||||
}
|
||||
m.Clear()
|
||||
return m.appendAll(list)
|
||||
}
|
||||
|
||||
func (m *resWrangler) RemoveBuildAnnotations() {
|
||||
for _, r := range m.rList {
|
||||
r.RemoveBuildAnnotations()
|
||||
}
|
||||
}
|
||||
|
||||
// ApplyFilter implements ResMap.
|
||||
func (m *resWrangler) ApplyFilter(f kio.Filter) error {
|
||||
reverseLookup := make(map[*kyaml.RNode]*resource.Resource, len(m.rList))
|
||||
nodes := make([]*kyaml.RNode, len(m.rList))
|
||||
for i, r := range m.rList {
|
||||
ptr := &(r.RNode)
|
||||
nodes[i] = ptr
|
||||
reverseLookup[ptr] = r
|
||||
}
|
||||
// The filter can modify nodes, but also delete and create them.
|
||||
// The filtered list might be smaller or larger than the nodes list.
|
||||
filtered, err := f.Filter(nodes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Rebuild the resmap from the filtered RNodes.
|
||||
var nRList []*resource.Resource
|
||||
for _, rn := range filtered {
|
||||
if rn.IsNilOrEmpty() {
|
||||
// A node might make it through the filter as an object,
|
||||
// but still be empty. Drop such entries.
|
||||
continue
|
||||
}
|
||||
res, ok := reverseLookup[rn]
|
||||
if !ok {
|
||||
// A node was created; make a Resource to wrap it.
|
||||
res = &resource.Resource{
|
||||
RNode: *rn,
|
||||
// Leave remaining fields empty.
|
||||
// At at time of writing, seeking to eliminate those fields.
|
||||
// Alternatively, could just return error on creation attempt
|
||||
// until remaining fields eliminated.
|
||||
}
|
||||
}
|
||||
nRList = append(nRList, res)
|
||||
}
|
||||
m.rList = nRList
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user