vendor update for E2E framework

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

vendor/sigs.k8s.io/kustomize/pkg/target/kusttarget.go

@@ -0,0 +1,315 @@
+/*
+Copyright 2018 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 target implements state for the set of all resources to customize.
+package target
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/ghodss/yaml"
+	"github.com/pkg/errors"
+	"sigs.k8s.io/kustomize/pkg/constants"
+	"sigs.k8s.io/kustomize/pkg/ifc"
+	"sigs.k8s.io/kustomize/pkg/ifc/transformer"
+	interror "sigs.k8s.io/kustomize/pkg/internal/error"
+	patchtransformer "sigs.k8s.io/kustomize/pkg/patch/transformer"
+	"sigs.k8s.io/kustomize/pkg/resmap"
+	"sigs.k8s.io/kustomize/pkg/resource"
+	"sigs.k8s.io/kustomize/pkg/transformers"
+	"sigs.k8s.io/kustomize/pkg/transformers/config"
+	"sigs.k8s.io/kustomize/pkg/types"
+)
+
+// KustTarget encapsulates the entirety of a kustomization build.
+type KustTarget struct {
+	kustomization *types.Kustomization
+	ldr           ifc.Loader
+	rFactory      *resmap.Factory
+	tFactory      transformer.Factory
+}
+
+// NewKustTarget returns a new instance of KustTarget primed with a Loader.
+func NewKustTarget(
+	ldr ifc.Loader,
+	rFactory *resmap.Factory,
+	tFactory transformer.Factory) (*KustTarget, error) {
+	content, err := loadKustFile(ldr)
+	if err != nil {
+		return nil, err
+	}
+	content = types.DealWithDeprecatedFields(content)
+	var k types.Kustomization
+	err = unmarshal(content, &k)
+	if err != nil {
+		return nil, err
+	}
+	errs := k.EnforceFields()
+	if len(errs) > 0 {
+		return nil, fmt.Errorf("Failed to read kustomization file under %s:\n"+strings.Join(errs, "\n"), ldr.Root())
+	}
+	return &KustTarget{
+		kustomization: &k,
+		ldr:           ldr,
+		rFactory:      rFactory,
+		tFactory:      tFactory,
+	}, nil
+}
+
+func quoted(l []string) []string {
+	r := make([]string, len(l))
+	for i, v := range l {
+		r[i] = "'" + v + "'"
+	}
+	return r
+}
+
+func commaOr(q []string) string {
+	return strings.Join(q[:len(q)-1], ", ") + " or " + q[len(q)-1]
+}
+
+func loadKustFile(ldr ifc.Loader) ([]byte, error) {
+	var content []byte
+	match := 0
+	for _, kf := range constants.KustomizationFileNames {
+		c, err := ldr.Load(kf)
+		if err == nil {
+			match += 1
+			content = c
+		}
+	}
+	switch match {
+	case 0:
+		return nil, fmt.Errorf(
+			"unable to find one of %v in directory '%s'",
+			commaOr(quoted(constants.KustomizationFileNames)), ldr.Root())
+	case 1:
+		return content, nil
+	default:
+		return nil, fmt.Errorf("Found multiple kustomization files under: %s\n", ldr.Root())
+	}
+}
+
+func unmarshal(y []byte, o interface{}) error {
+	j, err := yaml.YAMLToJSON(y)
+	if err != nil {
+		return err
+	}
+	dec := json.NewDecoder(bytes.NewReader(j))
+	dec.DisallowUnknownFields()
+	return dec.Decode(o)
+}
+
+// MakeCustomizedResMap creates a ResMap per kustomization instructions.
+// The Resources in the returned ResMap are fully customized.
+func (kt *KustTarget) MakeCustomizedResMap() (resmap.ResMap, error) {
+	ra, err := kt.AccumulateTarget()
+	if err != nil {
+		return nil, err
+	}
+	err = ra.Transform(kt.tFactory.MakeHashTransformer())
+	if err != nil {
+		return nil, err
+	}
+	// Given that names have changed (prefixs/suffixes added),
+	// fix all the back references to those names.
+	err = ra.FixBackReferences()
+	if err != nil {
+		return nil, err
+	}
+	// With all the back references fixed, it's OK to resolve Vars.
+	err = ra.ResolveVars()
+	return ra.ResMap(), err
+}
+
+func (kt *KustTarget) shouldAddHashSuffixesToGeneratedResources() bool {
+	return kt.kustomization.GeneratorOptions == nil ||
+		!kt.kustomization.GeneratorOptions.DisableNameSuffixHash
+}
+
+// AccumulateTarget returns a new ResAccumulator,
+// holding customized resources and the data/rules used
+// to do so.  The name back references and vars are
+// not yet fixed.
+func (kt *KustTarget) AccumulateTarget() (
+	ra *ResAccumulator, err error) {
+	// TODO(monopole): Get rid of the KustomizationErrors accumulator.
+	// It's not consistently used, and complicates tests.
+	errs := &interror.KustomizationErrors{}
+	ra, errs = kt.accumulateBases()
+	resources, err := kt.rFactory.FromFiles(
+		kt.ldr, kt.kustomization.Resources)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "rawResources failed to read Resources"))
+	}
+	if len(errs.Get()) > 0 {
+		return ra, errs
+	}
+	err = ra.MergeResourcesWithErrorOnIdCollision(resources)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "MergeResourcesWithErrorOnIdCollision"))
+	}
+	tConfig, err := config.MakeTransformerConfig(
+		kt.ldr, kt.kustomization.Configurations)
+	if err != nil {
+		return nil, err
+	}
+	err = ra.MergeConfig(tConfig)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "MergeConfig"))
+	}
+	err = ra.MergeVars(kt.kustomization.Vars)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "MergeVars"))
+	}
+	crdTc, err := config.LoadConfigFromCRDs(kt.ldr, kt.kustomization.Crds)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "LoadCRDs"))
+	}
+	err = ra.MergeConfig(crdTc)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "merge CRDs"))
+	}
+	resMap, err := kt.generateConfigMapsAndSecrets(errs)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "generateConfigMapsAndSecrets"))
+	}
+	err = ra.MergeResourcesWithOverride(resMap)
+	if err != nil {
+		return nil, err
+	}
+	patches, err := kt.rFactory.RF().SliceFromPatches(
+		kt.ldr, kt.kustomization.PatchesStrategicMerge)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "SliceFromPatches"))
+	}
+	if len(errs.Get()) > 0 {
+		return nil, errs
+	}
+	t, err := kt.newTransformer(patches, ra.tConfig)
+	if err != nil {
+		return nil, err
+	}
+	err = ra.Transform(t)
+	if err != nil {
+		return nil, err
+	}
+	return ra, nil
+}
+
+func (kt *KustTarget) generateConfigMapsAndSecrets(
+	errs *interror.KustomizationErrors) (resmap.ResMap, error) {
+	kt.rFactory.Set(kt.ldr)
+	cms, err := kt.rFactory.NewResMapFromConfigMapArgs(
+		kt.kustomization.ConfigMapGenerator, kt.kustomization.GeneratorOptions)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "NewResMapFromConfigMapArgs"))
+	}
+	secrets, err := kt.rFactory.NewResMapFromSecretArgs(
+		kt.kustomization.SecretGenerator, kt.kustomization.GeneratorOptions)
+	if err != nil {
+		errs.Append(errors.Wrap(err, "NewResMapFromSecretArgs"))
+	}
+	return resmap.MergeWithErrorOnIdCollision(cms, secrets)
+}
+
+// accumulateBases returns a new ResAccumulator
+// holding customized resources and the data/rules
+// used to customized them from only the _bases_
+// of this KustTarget.
+func (kt *KustTarget) accumulateBases() (
+	ra *ResAccumulator, errs *interror.KustomizationErrors) {
+	errs = &interror.KustomizationErrors{}
+	ra = MakeEmptyAccumulator()
+
+	for _, path := range kt.kustomization.Bases {
+		ldr, err := kt.ldr.New(path)
+		if err != nil {
+			errs.Append(errors.Wrap(err, "couldn't make loader for "+path))
+			continue
+		}
+		subKt, err := NewKustTarget(
+			ldr, kt.rFactory, kt.tFactory)
+		if err != nil {
+			errs.Append(errors.Wrap(err, "couldn't make target for "+path))
+			ldr.Cleanup()
+			continue
+		}
+		subRa, err := subKt.AccumulateTarget()
+		if err != nil {
+			errs.Append(errors.Wrap(err, "AccumulateTarget"))
+			ldr.Cleanup()
+			continue
+		}
+		err = ra.MergeAccumulator(subRa)
+		if err != nil {
+			errs.Append(errors.Wrap(err, path))
+		}
+		ldr.Cleanup()
+	}
+	return ra, errs
+}
+
+// newTransformer makes a Transformer that does a collection
+// of object transformations.
+func (kt *KustTarget) newTransformer(
+	patches []*resource.Resource, tConfig *config.TransformerConfig) (
+	transformers.Transformer, error) {
+	var r []transformers.Transformer
+	t, err := kt.tFactory.MakePatchTransformer(patches, kt.rFactory.RF())
+	if err != nil {
+		return nil, err
+	}
+	r = append(r, t)
+	r = append(r, transformers.NewNamespaceTransformer(
+		string(kt.kustomization.Namespace), tConfig.NameSpace))
+	t, err = transformers.NewNamePrefixSuffixTransformer(
+		string(kt.kustomization.NamePrefix),
+		string(kt.kustomization.NameSuffix),
+		tConfig.NamePrefix,
+	)
+	if err != nil {
+		return nil, err
+	}
+	r = append(r, t)
+	t, err = transformers.NewLabelsMapTransformer(
+		kt.kustomization.CommonLabels, tConfig.CommonLabels)
+	if err != nil {
+		return nil, err
+	}
+	r = append(r, t)
+	t, err = transformers.NewAnnotationsMapTransformer(
+		kt.kustomization.CommonAnnotations, tConfig.CommonAnnotations)
+	if err != nil {
+		return nil, err
+	}
+	r = append(r, t)
+	t, err = patchtransformer.NewPatchJson6902Factory(kt.ldr).
+		MakePatchJson6902Transformer(kt.kustomization.PatchesJson6902)
+	if err != nil {
+		return nil, err
+	}
+	r = append(r, t)
+	t, err = transformers.NewImageTransformer(kt.kustomization.Images)
+	if err != nil {
+		return nil, err
+	}
+	r = append(r, t)
+	return transformers.NewMultiTransformer(r), nil
+}

vendor/sigs.k8s.io/kustomize/pkg/target/resaccumulator.go

@@ -0,0 +1,161 @@
+/*
+Copyright 2018 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 target
+
+import (
+	"fmt"
+	"log"
+	"strings"
+
+	"sigs.k8s.io/kustomize/pkg/resid"
+	"sigs.k8s.io/kustomize/pkg/resmap"
+	"sigs.k8s.io/kustomize/pkg/transformers"
+	"sigs.k8s.io/kustomize/pkg/transformers/config"
+	"sigs.k8s.io/kustomize/pkg/types"
+)
+
+// ResAccumulator accumulates resources and the rules
+// used to customize those resources.
+// TODO(monopole): Move to "accumulator" package and make members private.
+// This will make a better separation between KustTarget, which should
+// be mainly concerned with data loading, and this class, which could
+// become the home of all transformation data and logic.
+type ResAccumulator struct {
+	resMap  resmap.ResMap
+	tConfig *config.TransformerConfig
+	varSet  types.VarSet
+}
+
+func MakeEmptyAccumulator() *ResAccumulator {
+	ra := &ResAccumulator{}
+	ra.resMap = make(resmap.ResMap)
+	ra.tConfig = &config.TransformerConfig{}
+	ra.varSet = types.VarSet{}
+	return ra
+}
+
+// ResMap returns a copy of the internal resMap.
+func (ra *ResAccumulator) ResMap() resmap.ResMap {
+	result := make(resmap.ResMap)
+	for k, v := range ra.resMap {
+		result[k] = v
+	}
+	return result
+}
+
+// Vars returns a copy of underlying vars.
+func (ra *ResAccumulator) Vars() []types.Var {
+	return ra.varSet.Set()
+}
+
+func (ra *ResAccumulator) MergeResourcesWithErrorOnIdCollision(
+	resources resmap.ResMap) (err error) {
+	ra.resMap, err = resmap.MergeWithErrorOnIdCollision(
+		resources, ra.resMap)
+	return err
+}
+
+func (ra *ResAccumulator) MergeResourcesWithOverride(
+	resources resmap.ResMap) (err error) {
+	ra.resMap, err = resmap.MergeWithOverride(
+		ra.resMap, resources)
+	return err
+}
+
+func (ra *ResAccumulator) MergeConfig(
+	tConfig *config.TransformerConfig) (err error) {
+	ra.tConfig, err = ra.tConfig.Merge(tConfig)
+	return err
+}
+
+func (ra *ResAccumulator) MergeVars(incoming []types.Var) error {
+	return ra.varSet.MergeSlice(incoming)
+}
+
+func (ra *ResAccumulator) MergeAccumulator(other *ResAccumulator) (err error) {
+	err = ra.MergeResourcesWithErrorOnIdCollision(other.resMap)
+	if err != nil {
+		return err
+	}
+	err = ra.MergeConfig(other.tConfig)
+	if err != nil {
+		return err
+	}
+	return ra.varSet.MergeSet(&other.varSet)
+}
+
+// makeVarReplacementMap returns a map of Var names to
+// their final values. The values are strings intended
+// for substitution wherever the $(var.Name) occurs.
+func (ra *ResAccumulator) makeVarReplacementMap() (map[string]string, error) {
+	result := map[string]string{}
+	for _, v := range ra.Vars() {
+		matched := ra.resMap.GetMatchingIds(
+			resid.NewResId(v.ObjRef.GVK(), v.ObjRef.Name).GvknEquals)
+		if len(matched) > 1 {
+			return nil, fmt.Errorf(
+				"found %d resId matches for var %s "+
+					"(unable to disambiguate)",
+				len(matched), v)
+		}
+		if len(matched) == 1 {
+			s, err := ra.resMap[matched[0]].GetFieldValue(v.FieldRef.FieldPath)
+			if err != nil {
+				return nil, fmt.Errorf(
+					"field specified in var '%v' "+
+						"not found in corresponding resource", v)
+			}
+			result[v.Name] = s
+		} else {
+			return nil, fmt.Errorf(
+				"var '%v' cannot be mapped to a field "+
+					"in the set of known resources", v)
+		}
+	}
+	return result, nil
+}
+
+func (ra *ResAccumulator) Transform(t transformers.Transformer) error {
+	return t.Transform(ra.resMap)
+}
+
+func (ra *ResAccumulator) ResolveVars() error {
+	replacementMap, err := ra.makeVarReplacementMap()
+	if err != nil {
+		return err
+	}
+	if len(replacementMap) == 0 {
+		return nil
+	}
+	t := transformers.NewRefVarTransformer(
+		replacementMap, ra.tConfig.VarReference)
+	err = ra.Transform(t)
+	if len(t.UnusedVars()) > 0 {
+		log.Printf(
+			"well-defined vars that were never replaced: %s\n",
+			strings.Join(t.UnusedVars(), ","))
+	}
+	return err
+}
+
+func (ra *ResAccumulator) FixBackReferences() (err error) {
+	if ra.tConfig.NameReference == nil {
+		return nil
+	}
+	return ra.Transform(transformers.NewNameReferenceTransformer(
+		ra.tConfig.NameReference))
+}