Upgrade k8s package verison (#5358)

* upgrade k8s package version

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

* Script upgrade and code formatting.

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

vendor/sigs.k8s.io/kustomize/api/internal/target/kusttarget.go

@@ -6,18 +6,22 @@ package target
 import (
 	"encoding/json"
 	"fmt"
-	"path/filepath"
 	"strings"
 
 	"github.com/pkg/errors"
-	"sigs.k8s.io/kustomize/api/builtins"
+
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/internal/accumulator"
+	"sigs.k8s.io/kustomize/api/internal/builtins"
+	"sigs.k8s.io/kustomize/api/internal/kusterr"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinhelpers"
 	"sigs.k8s.io/kustomize/api/internal/plugins/loader"
+	"sigs.k8s.io/kustomize/api/internal/utils"
 	"sigs.k8s.io/kustomize/api/konfig"
+	load "sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/openapi"
 	"sigs.k8s.io/yaml"
@@ -26,10 +30,12 @@ import (
 // KustTarget encapsulates the entirety of a kustomization build.
 type KustTarget struct {
 	kustomization *types.Kustomization
+	kustFileName  string
 	ldr           ifc.Loader
 	validator     ifc.Validator
 	rFactory      *resmap.Factory
 	pLdr          *loader.Loader
+	origin        *resource.Origin
 }
 
 // NewKustTarget returns a new instance of KustTarget.
@@ -38,17 +44,19 @@ func NewKustTarget(
 	validator ifc.Validator,
 	rFactory *resmap.Factory,
 	pLdr *loader.Loader) *KustTarget {
+	pLdrCopy := *pLdr
+	pLdrCopy.SetWorkDir(ldr.Root())
 	return &KustTarget{
 		ldr:       ldr,
 		validator: validator,
 		rFactory:  rFactory,
-		pLdr:      pLdr,
+		pLdr:      &pLdrCopy,
 	}
 }
 
 // Load attempts to load the target's kustomization file.
 func (kt *KustTarget) Load() error {
-	content, err := loadKustFile(kt.ldr)
+	content, kustFileName, err := loadKustFile(kt.ldr)
 	if err != nil {
 		return err
 	}
@@ -69,6 +77,7 @@ func (kt *KustTarget) Load() error {
 				strings.Join(errs, "\n"), kt.ldr.Root())
 	}
 	kt.kustomization = &k
+	kt.kustFileName = kustFileName
 	return nil
 }
 
@@ -80,23 +89,25 @@ func (kt *KustTarget) Kustomization() types.Kustomization {
 	return result
 }
 
-func loadKustFile(ldr ifc.Loader) ([]byte, error) {
+func loadKustFile(ldr ifc.Loader) ([]byte, string, error) {
 	var content []byte
 	match := 0
+	var kustFileName string
 	for _, kf := range konfig.RecognizedKustomizationFileNames() {
 		c, err := ldr.Load(kf)
 		if err == nil {
 			match += 1
 			content = c
+			kustFileName = kf
 		}
 	}
 	switch match {
 	case 0:
-		return nil, NewErrMissingKustomization(ldr.Root())
+		return nil, "", NewErrMissingKustomization(ldr.Root())
 	case 1:
-		return content, nil
+		return content, kustFileName, nil
 	default:
-		return nil, fmt.Errorf(
+		return nil, "", fmt.Errorf(
 			"Found multiple kustomization files under: %s\n", ldr.Root())
 	}
 }
@@ -108,6 +119,11 @@ func (kt *KustTarget) MakeCustomizedResMap() (resmap.ResMap, error) {
 }
 
 func (kt *KustTarget) makeCustomizedResMap() (resmap.ResMap, error) {
+	var origin *resource.Origin
+	if len(kt.kustomization.BuildMetadata) != 0 {
+		origin = &resource.Origin{}
+	}
+	kt.origin = origin
 	ra, err := kt.AccumulateTarget()
 	if err != nil {
 		return nil, err
@@ -151,6 +167,15 @@ func (kt *KustTarget) addHashesToNames(
 // holding customized resources and the data/rules used
 // to do so.  The name back references and vars are
 // not yet fixed.
+// The origin parameter is used through the recursive calls
+// to annotate each resource with information about where
+// the resource came from, e.g. the file and/or the repository
+// it originated from.
+// As an entrypoint, one can pass an empty resource.Origin object to
+// AccumulateTarget. As AccumulateTarget moves recursively
+// through kustomization directories, it updates `origin.path`
+// accordingly. When a remote base is found, it updates `origin.repo`
+// and `origin.ref` accordingly.
 func (kt *KustTarget) AccumulateTarget() (
 	ra *accumulator.ResAccumulator, err error) {
 	return kt.accumulateTarget(accumulator.MakeEmptyAccumulator())
@@ -205,27 +230,51 @@ func (kt *KustTarget) accumulateTarget(ra *accumulator.ResAccumulator) (
 		return nil, errors.Wrapf(
 			err, "merging vars %v", kt.kustomization.Vars)
 	}
+	err = kt.IgnoreLocal(ra)
+	if err != nil {
+		return nil, err
+	}
 	return ra, nil
 }
 
+// IgnoreLocal drops the local resource by checking the annotation "config.kubernetes.io/local-config".
+func (kt *KustTarget) IgnoreLocal(ra *accumulator.ResAccumulator) error {
+	rf := kt.rFactory.RF()
+	if rf.IncludeLocalConfigs {
+		return nil
+	}
+	remainRes, err := rf.DropLocalNodes(ra.ResMap().ToRNodeSlice())
+	if err != nil {
+		return err
+	}
+	return ra.Intersection(kt.rFactory.FromResourceSlice(remainRes))
+}
+
 func (kt *KustTarget) runGenerators(
 	ra *accumulator.ResAccumulator) error {
-	var generators []resmap.Generator
+	var generators []*resmap.GeneratorWithProperties
 	gs, err := kt.configureBuiltinGenerators()
 	if err != nil {
 		return err
 	}
 	generators = append(generators, gs...)
+
 	gs, err = kt.configureExternalGenerators()
 	if err != nil {
 		return errors.Wrap(err, "loading generator plugins")
 	}
 	generators = append(generators, gs...)
-	for _, g := range generators {
+	for i, g := range generators {
 		resMap, err := g.Generate()
 		if err != nil {
 			return err
 		}
+		if resMap != nil {
+			err = resMap.AddOriginAnnotation(generators[i].Origin)
+			if err != nil {
+				return errors.Wrapf(err, "adding origin annotations for generator %v", g)
+			}
+		}
 		err = ra.AbsorbAll(resMap)
 		if err != nil {
 			return errors.Wrapf(err, "merging from generator %v", g)
@@ -234,7 +283,8 @@ func (kt *KustTarget) runGenerators(
 	return nil
 }
 
-func (kt *KustTarget) configureExternalGenerators() ([]resmap.Generator, error) {
+func (kt *KustTarget) configureExternalGenerators() (
+	[]*resmap.GeneratorWithProperties, error) {
 	ra := accumulator.MakeEmptyAccumulator()
 	var generatorPaths []string
 	for _, p := range kt.kustomization.Generators {
@@ -245,7 +295,17 @@ func (kt *KustTarget) configureExternalGenerators() ([]resmap.Generator, error)
 			generatorPaths = append(generatorPaths, p)
 			continue
 		}
-		ra.AppendAll(rm)
+		// inline config, track the origin
+		if kt.origin != nil {
+			resources := rm.Resources()
+			for _, r := range resources {
+				r.SetOrigin(kt.origin.Append(kt.kustFileName))
+				rm.Replace(r)
+			}
+		}
+		if err = ra.AppendAll(rm); err != nil {
+			return nil, errors.Wrapf(err, "configuring external generator")
+		}
 	}
 	ra, err := kt.accumulateResources(ra, generatorPaths)
 	if err != nil {
@@ -255,7 +315,7 @@ func (kt *KustTarget) configureExternalGenerators() ([]resmap.Generator, error)
 }
 
 func (kt *KustTarget) runTransformers(ra *accumulator.ResAccumulator) error {
-	var r []resmap.Transformer
+	var r []*resmap.TransformerWithProperties
 	tConfig := ra.GetTransformerConfig()
 	lts, err := kt.configureBuiltinTransformers(tConfig)
 	if err != nil {
@@ -270,7 +330,7 @@ func (kt *KustTarget) runTransformers(ra *accumulator.ResAccumulator) error {
 	return ra.Transform(newMultiTransformer(r))
 }
 
-func (kt *KustTarget) configureExternalTransformers(transformers []string) ([]resmap.Transformer, error) {
+func (kt *KustTarget) configureExternalTransformers(transformers []string) ([]*resmap.TransformerWithProperties, error) {
 	ra := accumulator.MakeEmptyAccumulator()
 	var transformerPaths []string
 	for _, p := range transformers {
@@ -281,10 +341,20 @@ func (kt *KustTarget) configureExternalTransformers(transformers []string) ([]re
 			transformerPaths = append(transformerPaths, p)
 			continue
 		}
-		ra.AppendAll(rm)
+		// inline config, track the origin
+		if kt.origin != nil {
+			resources := rm.Resources()
+			for _, r := range resources {
+				r.SetOrigin(kt.origin.Append(kt.kustFileName))
+				rm.Replace(r)
+			}
+		}
+
+		if err = ra.AppendAll(rm); err != nil {
+			return nil, errors.Wrapf(err, "configuring external transformer")
+		}
 	}
 	ra, err := kt.accumulateResources(ra, transformerPaths)
-
 	if err != nil {
 		return nil, err
 	}
@@ -303,16 +373,18 @@ func (kt *KustTarget) runValidators(ra *accumulator.ResAccumulator) error {
 		if err != nil {
 			return err
 		}
-		new := ra.ResMap().DeepCopy()
-		kt.removeValidatedByLabel(new)
-		if err = orignal.ErrorIfNotEqualSets(new); err != nil {
+		newMap := ra.ResMap().DeepCopy()
+		if err = kt.removeValidatedByLabel(newMap); err != nil {
+			return err
+		}
+		if err = orignal.ErrorIfNotEqualSets(newMap); err != nil {
 			return fmt.Errorf("validator shouldn't modify the resource map: %v", err)
 		}
 	}
 	return nil
 }
 
-func (kt *KustTarget) removeValidatedByLabel(rm resmap.ResMap) {
+func (kt *KustTarget) removeValidatedByLabel(rm resmap.ResMap) error {
 	resources := rm.Resources()
 	for _, r := range resources {
 		labels := r.GetLabels()
@@ -320,12 +392,11 @@ func (kt *KustTarget) removeValidatedByLabel(rm resmap.ResMap) {
 			continue
 		}
 		delete(labels, konfig.ValidatedByLabelKey)
-		if len(labels) == 0 {
-			r.SetLabels(nil)
-		} else {
-			r.SetLabels(labels)
+		if err := r.SetLabels(labels); err != nil {
+			return err
 		}
 	}
+	return nil
 }
 
 // accumulateResources fills the given resourceAccumulator
@@ -335,13 +406,32 @@ func (kt *KustTarget) accumulateResources(
 	for _, path := range paths {
 		// try loading resource as file then as base (directory or git repository)
 		if errF := kt.accumulateFile(ra, path); errF != nil {
+			// not much we can do if the error is an HTTP error so we bail out
+			if errors.Is(errF, load.ErrHTTP) {
+				return nil, errF
+			}
 			ldr, err := kt.ldr.New(path)
 			if err != nil {
+				if kusterr.IsMalformedYAMLError(errF) { // Some error occurred while tyring to decode YAML file
+					return nil, errF
+				}
 				return nil, errors.Wrapf(
 					err, "accumulation err='%s'", errF.Error())
 			}
-			ra, err = kt.accumulateDirectory(ra, ldr, false)
+			// store the origin, we'll need it later
+			origin := kt.origin.Copy()
+			if kt.origin != nil {
+				kt.origin = kt.origin.Append(path)
+				ra, err = kt.accumulateDirectory(ra, ldr, false)
+				// after we are done recursing through the directory, reset the origin
+				kt.origin = &origin
+			} else {
+				ra, err = kt.accumulateDirectory(ra, ldr, false)
+			}
 			if err != nil {
+				if kusterr.IsMalformedYAMLError(errF) { // Some error occurred while tyring to decode YAML file
+					return nil, errF
+				}
 				return nil, errors.Wrapf(
 					err, "accumulation err='%s'", errF.Error())
 			}
@@ -361,7 +451,16 @@ func (kt *KustTarget) accumulateComponents(
 			return nil, fmt.Errorf("loader.New %q", errL)
 		}
 		var errD error
-		ra, errD = kt.accumulateDirectory(ra, ldr, true)
+		// store the origin, we'll need it later
+		origin := kt.origin.Copy()
+		if kt.origin != nil {
+			kt.origin = kt.origin.Append(path)
+			ra, errD = kt.accumulateDirectory(ra, ldr, true)
+			// after we are done recursing through the directory, reset the origin
+			kt.origin = &origin
+		} else {
+			ra, errD = kt.accumulateDirectory(ra, ldr, true)
+		}
 		if errD != nil {
 			return nil, fmt.Errorf("accumulateDirectory: %q", errD)
 		}
@@ -378,10 +477,11 @@ func (kt *KustTarget) accumulateDirectory(
 		return nil, errors.Wrapf(
 			err, "couldn't make target for path '%s'", ldr.Root())
 	}
+	subKt.kustomization.BuildMetadata = kt.kustomization.BuildMetadata
+	subKt.origin = kt.origin
 	var bytes []byte
-	path := ldr.Root()
 	if openApiPath, exists := subKt.Kustomization().OpenAPI["path"]; exists {
-		bytes, err = ldr.Load(filepath.Join(path, openApiPath))
+		bytes, err = ldr.Load(openApiPath)
 		if err != nil {
 			return nil, err
 		}
@@ -426,6 +526,16 @@ func (kt *KustTarget) accumulateFile(
 	if err != nil {
 		return errors.Wrapf(err, "accumulating resources from '%s'", path)
 	}
+	if kt.origin != nil {
+		originAnno, err := kt.origin.Append(path).String()
+		if err != nil {
+			return errors.Wrapf(err, "cannot add path annotation for '%s'", path)
+		}
+		err = resources.AnnotateAll(utils.OriginAnnotationKey, originAnno)
+		if err != nil || originAnno == "" {
+			return errors.Wrapf(err, "cannot add path annotation for '%s'", path)
+		}
+	}
 	err = ra.AppendAll(resources)
 	if err != nil {
 		return errors.Wrapf(err, "merging resources from '%s'", path)

vendor/sigs.k8s.io/kustomize/api/internal/target/kusttarget_configplugin.go

@@ -5,11 +5,15 @@ package target
 
 import (
 	"fmt"
+	"path/filepath"
 
+	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinhelpers"
 	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
 // Functions dedicated to configuring the builtin
@@ -28,7 +32,7 @@ import (
 // N plugin instances with differing configurations.
 
 func (kt *KustTarget) configureBuiltinGenerators() (
-	result []resmap.Generator, err error) {
+	result []*resmap.GeneratorWithProperties, err error) {
 	for _, bpt := range []builtinhelpers.BuiltinPluginType{
 		builtinhelpers.ConfigMapGenerator,
 		builtinhelpers.SecretGenerator,
@@ -39,31 +43,67 @@ func (kt *KustTarget) configureBuiltinGenerators() (
 		if err != nil {
 			return nil, err
 		}
-		result = append(result, r...)
+
+		var generatorOrigin *resource.Origin
+		if kt.origin != nil {
+			generatorOrigin = &resource.Origin{
+				Repo:         kt.origin.Repo,
+				Ref:          kt.origin.Ref,
+				ConfiguredIn: filepath.Join(kt.origin.Path, kt.kustFileName),
+				ConfiguredBy: yaml.ResourceIdentifier{
+					TypeMeta: yaml.TypeMeta{
+						APIVersion: "builtin",
+						Kind:       bpt.String(),
+					},
+				},
+			}
+		}
+
+		for i := range r {
+			result = append(result, &resmap.GeneratorWithProperties{Generator: r[i], Origin: generatorOrigin})
+		}
 	}
 	return result, nil
 }
 
 func (kt *KustTarget) configureBuiltinTransformers(
 	tc *builtinconfig.TransformerConfig) (
-	result []resmap.Transformer, err error) {
+	result []*resmap.TransformerWithProperties, err error) {
 	for _, bpt := range []builtinhelpers.BuiltinPluginType{
 		builtinhelpers.PatchStrategicMergeTransformer,
 		builtinhelpers.PatchTransformer,
 		builtinhelpers.NamespaceTransformer,
-		builtinhelpers.PrefixSuffixTransformer,
+		builtinhelpers.PrefixTransformer,
+		builtinhelpers.SuffixTransformer,
 		builtinhelpers.LabelTransformer,
 		builtinhelpers.AnnotationsTransformer,
 		builtinhelpers.PatchJson6902Transformer,
 		builtinhelpers.ReplicaCountTransformer,
 		builtinhelpers.ImageTagTransformer,
+		builtinhelpers.ReplacementTransformer,
 	} {
 		r, err := transformerConfigurators[bpt](
 			kt, bpt, builtinhelpers.TransformerFactories[bpt], tc)
 		if err != nil {
 			return nil, err
 		}
-		result = append(result, r...)
+		var transformerOrigin *resource.Origin
+		if kt.origin != nil {
+			transformerOrigin = &resource.Origin{
+				Repo:         kt.origin.Repo,
+				Ref:          kt.origin.Ref,
+				ConfiguredIn: filepath.Join(kt.origin.Path, kt.kustFileName),
+				ConfiguredBy: yaml.ResourceIdentifier{
+					TypeMeta: yaml.TypeMeta{
+						APIVersion: "builtin",
+						Kind:       bpt.String(),
+					},
+				},
+			}
+		}
+		for i := range r {
+			result = append(result, &resmap.TransformerWithProperties{Transformer: r[i], Origin: transformerOrigin})
+		}
 	}
 	return result, nil
 }
@@ -146,6 +186,9 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 	builtinhelpers.NamespaceTransformer: func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {
+		if kt.kustomization.Namespace == "" {
+			return
+		}
 		var c struct {
 			types.ObjectMeta `json:"metadata,omitempty" yaml:"metadata,omitempty"`
 			FieldSpecs       []types.FieldSpec
@@ -229,6 +272,9 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 	builtinhelpers.LabelTransformer: func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {
+		if len(kt.kustomization.Labels) == 0 && len(kt.kustomization.CommonLabels) == 0 {
+			return
+		}
 		for _, label := range kt.kustomization.Labels {
 			var c struct {
 				Labels     map[string]string
@@ -240,6 +286,13 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 			if label.IncludeSelectors {
 				fss, err = fss.MergeAll(tc.CommonLabels)
 			} else {
+				// merge spec/template/metadata fieldSpec if includeTemplate flag is true
+				if label.IncludeTemplates {
+					fss, err = fss.MergeOne(types.FieldSpec{Path: "spec/template/metadata/labels", CreateIfNotPresent: false})
+					if err != nil {
+						return nil, errors.Wrap(err, "failed to merge template fieldSpec")
+					}
+				}
 				// only add to metadata by default
 				fss, err = fss.MergeOne(types.FieldSpec{Path: "metadata/labels", CreateIfNotPresent: true})
 			}
@@ -271,6 +324,9 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 	builtinhelpers.AnnotationsTransformer: func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {
+		if len(kt.kustomization.CommonAnnotations) == 0 {
+			return
+		}
 		var c struct {
 			Annotations map[string]string
 			FieldSpecs  []types.FieldSpec
@@ -285,16 +341,17 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 		result = append(result, p)
 		return
 	},
-	builtinhelpers.PrefixSuffixTransformer: func(
+	builtinhelpers.PrefixTransformer: func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {
+		if kt.kustomization.NamePrefix == "" {
+			return
+		}
 		var c struct {
-			Prefix     string
-			Suffix     string
-			FieldSpecs []types.FieldSpec
+			Prefix     string            `json:"prefix,omitempty" yaml:"prefix,omitempty"`
+			FieldSpecs []types.FieldSpec `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"`
 		}
 		c.Prefix = kt.kustomization.NamePrefix
-		c.Suffix = kt.kustomization.NameSuffix
 		c.FieldSpecs = tc.NamePrefix
 		p := f()
 		err = kt.configureBuiltinPlugin(p, c, bpt)
@@ -304,6 +361,26 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 		result = append(result, p)
 		return
 	},
+	builtinhelpers.SuffixTransformer: func(
+		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
+		result []resmap.Transformer, err error) {
+		if kt.kustomization.NameSuffix == "" {
+			return
+		}
+		var c struct {
+			Suffix     string            `json:"suffix,omitempty" yaml:"suffix,omitempty"`
+			FieldSpecs []types.FieldSpec `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"`
+		}
+		c.Suffix = kt.kustomization.NameSuffix
+		c.FieldSpecs = tc.NameSuffix
+		p := f()
+		err = kt.configureBuiltinPlugin(p, c, bpt)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, p)
+		return
+	},
 	builtinhelpers.ImageTagTransformer: func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {
@@ -323,6 +400,24 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 		}
 		return
 	},
+	builtinhelpers.ReplacementTransformer: func(
+		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, _ *builtinconfig.TransformerConfig) (
+		result []resmap.Transformer, err error) {
+		if len(kt.kustomization.Replacements) == 0 {
+			return
+		}
+		var c struct {
+			Replacements []types.ReplacementField
+		}
+		c.Replacements = kt.kustomization.Replacements
+		p := f()
+		err = kt.configureBuiltinPlugin(p, c, bpt)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, p)
+		return result, nil
+	},
 	builtinhelpers.ReplicaCountTransformer: func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {

vendor/sigs.k8s.io/kustomize/api/internal/target/multitransformer.go

@@ -9,15 +9,15 @@ import (
 
 // multiTransformer contains a list of transformers.
 type multiTransformer struct {
-	transformers []resmap.Transformer
+	transformers []*resmap.TransformerWithProperties
 }
 
 var _ resmap.Transformer = &multiTransformer{}
 
 // newMultiTransformer constructs a multiTransformer.
-func newMultiTransformer(t []resmap.Transformer) resmap.Transformer {
+func newMultiTransformer(t []*resmap.TransformerWithProperties) resmap.Transformer {
 	r := &multiTransformer{
-		transformers: make([]resmap.Transformer, len(t)),
+		transformers: make([]*resmap.TransformerWithProperties, len(t)),
 	}
 	copy(r.transformers, t)
 	return r
@@ -30,6 +30,11 @@ func (o *multiTransformer) Transform(m resmap.ResMap) error {
 		if err := t.Transform(m); err != nil {
 			return err
 		}
+		if t.Origin != nil {
+			if err := m.AddTransformerAnnotation(t.Origin); err != nil {
+				return err
+			}
+		}
 		m.DropEmpties()
 	}
 	return nil