Source file src/sigs.k8s.io/kustomize/api/internal/target/kusttarget_configplugin.go

Documentation: sigs.k8s.io/kustomize/api/internal/target

     1  // Copyright 2019 The Kubernetes Authors.
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package target
     5  
     6  import (
     7  	"fmt"
     8  	"path/filepath"
     9  
    10  	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
    11  	"sigs.k8s.io/kustomize/api/internal/plugins/builtinhelpers"
    12  	"sigs.k8s.io/kustomize/api/resmap"
    13  	"sigs.k8s.io/kustomize/api/resource"
    14  	"sigs.k8s.io/kustomize/api/types"
    15  	"sigs.k8s.io/kustomize/kyaml/errors"
    16  	"sigs.k8s.io/kustomize/kyaml/yaml"
    17  )
    18  
    19  // Functions dedicated to configuring the builtin
    20  // transformer and generator plugins using config data
    21  // read from a kustomization file and from the
    22  // config.TransformerConfig, whose data may be a
    23  // mix of hardcoded values and data read from file.
    24  //
    25  // Non-builtin plugins will get their configuration
    26  // from their own dedicated structs and YAML files.
    27  //
    28  // There are some loops in the functions below because
    29  // the kustomization file would, say, allow someone to
    30  // request multiple secrets be made, or run multiple
    31  // image tag transforms.  In these cases, we'll need
    32  // N plugin instances with differing configurations.
    33  
    34  func (kt *KustTarget) configureBuiltinGenerators() (
    35  	result []*resmap.GeneratorWithProperties, err error) {
    36  	for _, bpt := range []builtinhelpers.BuiltinPluginType{
    37  		builtinhelpers.ConfigMapGenerator,
    38  		builtinhelpers.SecretGenerator,
    39  		builtinhelpers.HelmChartInflationGenerator,
    40  	} {
    41  		r, err := generatorConfigurators[bpt](
    42  			kt, bpt, builtinhelpers.GeneratorFactories[bpt])
    43  		if err != nil {
    44  			return nil, err
    45  		}
    46  
    47  		var generatorOrigin *resource.Origin
    48  		if kt.origin != nil {
    49  			generatorOrigin = &resource.Origin{
    50  				Repo:         kt.origin.Repo,
    51  				Ref:          kt.origin.Ref,
    52  				ConfiguredIn: filepath.Join(kt.origin.Path, kt.kustFileName),
    53  				ConfiguredBy: yaml.ResourceIdentifier{
    54  					TypeMeta: yaml.TypeMeta{
    55  						APIVersion: "builtin",
    56  						Kind:       bpt.String(),
    57  					},
    58  				},
    59  			}
    60  		}
    61  
    62  		for i := range r {
    63  			result = append(result, &resmap.GeneratorWithProperties{Generator: r[i], Origin: generatorOrigin})
    64  		}
    65  	}
    66  	return result, nil
    67  }
    68  
    69  func (kt *KustTarget) configureBuiltinTransformers(
    70  	tc *builtinconfig.TransformerConfig) (
    71  	result []*resmap.TransformerWithProperties, err error) {
    72  	for _, bpt := range []builtinhelpers.BuiltinPluginType{
    73  		builtinhelpers.PatchStrategicMergeTransformer,
    74  		builtinhelpers.PatchTransformer,
    75  		builtinhelpers.NamespaceTransformer,
    76  		builtinhelpers.PrefixTransformer,
    77  		builtinhelpers.SuffixTransformer,
    78  		builtinhelpers.LabelTransformer,
    79  		builtinhelpers.AnnotationsTransformer,
    80  		builtinhelpers.PatchJson6902Transformer,
    81  		builtinhelpers.ReplicaCountTransformer,
    82  		builtinhelpers.ImageTagTransformer,
    83  		builtinhelpers.ReplacementTransformer,
    84  	} {
    85  		r, err := transformerConfigurators[bpt](
    86  			kt, bpt, builtinhelpers.TransformerFactories[bpt], tc)
    87  		if err != nil {
    88  			return nil, err
    89  		}
    90  		var transformerOrigin *resource.Origin
    91  		if kt.origin != nil {
    92  			transformerOrigin = &resource.Origin{
    93  				Repo:         kt.origin.Repo,
    94  				Ref:          kt.origin.Ref,
    95  				ConfiguredIn: filepath.Join(kt.origin.Path, kt.kustFileName),
    96  				ConfiguredBy: yaml.ResourceIdentifier{
    97  					TypeMeta: yaml.TypeMeta{
    98  						APIVersion: "builtin",
    99  						Kind:       bpt.String(),
   100  					},
   101  				},
   102  			}
   103  		}
   104  		for i := range r {
   105  			result = append(result, &resmap.TransformerWithProperties{Transformer: r[i], Origin: transformerOrigin})
   106  		}
   107  	}
   108  	return result, nil
   109  }
   110  
   111  type gFactory func() resmap.GeneratorPlugin
   112  
   113  var generatorConfigurators = map[builtinhelpers.BuiltinPluginType]func(
   114  	kt *KustTarget,
   115  	bpt builtinhelpers.BuiltinPluginType,
   116  	factory gFactory) (result []resmap.Generator, err error){
   117  	builtinhelpers.SecretGenerator: func(kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f gFactory) (
   118  		result []resmap.Generator, err error) {
   119  		var c struct {
   120  			types.SecretArgs
   121  		}
   122  		for _, args := range kt.kustomization.SecretGenerator {
   123  			c.SecretArgs = args
   124  			c.SecretArgs.Options = types.MergeGlobalOptionsIntoLocal(
   125  				c.SecretArgs.Options, kt.kustomization.GeneratorOptions)
   126  			p := f()
   127  			err := kt.configureBuiltinPlugin(p, c, bpt)
   128  			if err != nil {
   129  				return nil, err
   130  			}
   131  			result = append(result, p)
   132  		}
   133  		return
   134  	},
   135  
   136  	builtinhelpers.ConfigMapGenerator: func(kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f gFactory) (
   137  		result []resmap.Generator, err error) {
   138  		var c struct {
   139  			types.ConfigMapArgs
   140  		}
   141  		for _, args := range kt.kustomization.ConfigMapGenerator {
   142  			c.ConfigMapArgs = args
   143  			c.ConfigMapArgs.Options = types.MergeGlobalOptionsIntoLocal(
   144  				c.ConfigMapArgs.Options, kt.kustomization.GeneratorOptions)
   145  			p := f()
   146  			err := kt.configureBuiltinPlugin(p, c, bpt)
   147  			if err != nil {
   148  				return nil, err
   149  			}
   150  			result = append(result, p)
   151  		}
   152  		return
   153  	},
   154  
   155  	builtinhelpers.HelmChartInflationGenerator: func(
   156  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f gFactory) (
   157  		result []resmap.Generator, err error) {
   158  		var c struct {
   159  			types.HelmGlobals
   160  			types.HelmChart
   161  		}
   162  		var globals types.HelmGlobals
   163  		if kt.kustomization.HelmGlobals != nil {
   164  			globals = *kt.kustomization.HelmGlobals
   165  		}
   166  		for _, chart := range kt.kustomization.HelmCharts {
   167  			c.HelmGlobals = globals
   168  			c.HelmChart = chart
   169  			p := f()
   170  			if err = kt.configureBuiltinPlugin(p, c, bpt); err != nil {
   171  				return nil, err
   172  			}
   173  			result = append(result, p)
   174  		}
   175  		return
   176  	},
   177  }
   178  
   179  type tFactory func() resmap.TransformerPlugin
   180  
   181  var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
   182  	kt *KustTarget,
   183  	bpt builtinhelpers.BuiltinPluginType,
   184  	f tFactory,
   185  	tc *builtinconfig.TransformerConfig) (result []resmap.Transformer, err error){
   186  	builtinhelpers.NamespaceTransformer: func(
   187  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   188  		result []resmap.Transformer, err error) {
   189  		if kt.kustomization.Namespace == "" {
   190  			return
   191  		}
   192  		var c struct {
   193  			types.ObjectMeta `json:"metadata,omitempty" yaml:"metadata,omitempty"`
   194  			FieldSpecs       []types.FieldSpec
   195  		}
   196  		c.Namespace = kt.kustomization.Namespace
   197  		c.FieldSpecs = tc.NameSpace
   198  		p := f()
   199  		err = kt.configureBuiltinPlugin(p, c, bpt)
   200  		if err != nil {
   201  			return nil, err
   202  		}
   203  		result = append(result, p)
   204  		return
   205  	},
   206  
   207  	builtinhelpers.PatchJson6902Transformer: func(
   208  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, _ *builtinconfig.TransformerConfig) (
   209  		result []resmap.Transformer, err error) {
   210  		var c struct {
   211  			Target *types.Selector `json:"target,omitempty" yaml:"target,omitempty"`
   212  			Path   string          `json:"path,omitempty" yaml:"path,omitempty"`
   213  			JsonOp string          `json:"jsonOp,omitempty" yaml:"jsonOp,omitempty"`
   214  		}
   215  		for _, args := range kt.kustomization.PatchesJson6902 {
   216  			c.Target = args.Target
   217  			c.Path = args.Path
   218  			c.JsonOp = args.Patch
   219  			p := f()
   220  			err = kt.configureBuiltinPlugin(p, c, bpt)
   221  			if err != nil {
   222  				return nil, err
   223  			}
   224  			result = append(result, p)
   225  		}
   226  		return
   227  	},
   228  	builtinhelpers.PatchStrategicMergeTransformer: func(
   229  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, _ *builtinconfig.TransformerConfig) (
   230  		result []resmap.Transformer, err error) {
   231  		if len(kt.kustomization.PatchesStrategicMerge) == 0 {
   232  			return
   233  		}
   234  		var c struct {
   235  			Paths []types.PatchStrategicMerge `json:"paths,omitempty" yaml:"paths,omitempty"`
   236  		}
   237  		c.Paths = kt.kustomization.PatchesStrategicMerge
   238  		p := f()
   239  		err = kt.configureBuiltinPlugin(p, c, bpt)
   240  		if err != nil {
   241  			return nil, err
   242  		}
   243  		result = append(result, p)
   244  		return
   245  	},
   246  	builtinhelpers.PatchTransformer: func(
   247  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, _ *builtinconfig.TransformerConfig) (
   248  		result []resmap.Transformer, err error) {
   249  		if len(kt.kustomization.Patches) == 0 {
   250  			return
   251  		}
   252  		var c struct {
   253  			Path    string          `json:"path,omitempty" yaml:"path,omitempty"`
   254  			Patch   string          `json:"patch,omitempty" yaml:"patch,omitempty"`
   255  			Target  *types.Selector `json:"target,omitempty" yaml:"target,omitempty"`
   256  			Options map[string]bool `json:"options,omitempty" yaml:"options,omitempty"`
   257  		}
   258  		for _, pc := range kt.kustomization.Patches {
   259  			c.Target = pc.Target
   260  			c.Patch = pc.Patch
   261  			c.Path = pc.Path
   262  			c.Options = pc.Options
   263  			p := f()
   264  			err = kt.configureBuiltinPlugin(p, c, bpt)
   265  			if err != nil {
   266  				return nil, err
   267  			}
   268  			result = append(result, p)
   269  		}
   270  		return
   271  	},
   272  	builtinhelpers.LabelTransformer: func(
   273  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   274  		result []resmap.Transformer, err error) {
   275  		if len(kt.kustomization.Labels) == 0 && len(kt.kustomization.CommonLabels) == 0 {
   276  			return
   277  		}
   278  		for _, label := range kt.kustomization.Labels {
   279  			var c struct {
   280  				Labels     map[string]string
   281  				FieldSpecs []types.FieldSpec
   282  			}
   283  			c.Labels = label.Pairs
   284  			fss := types.FsSlice(label.FieldSpecs)
   285  			// merge the custom fieldSpecs with the default
   286  			if label.IncludeSelectors {
   287  				fss, err = fss.MergeAll(tc.CommonLabels)
   288  			} else {
   289  				// merge spec/template/metadata fieldSpecs if includeTemplate flag is true
   290  				if label.IncludeTemplates {
   291  					fss, err = fss.MergeAll(tc.TemplateLabels)
   292  					if err != nil {
   293  						return nil, errors.WrapPrefixf(err, "failed to merge template fieldSpec")
   294  					}
   295  				}
   296  				// only add to metadata by default
   297  				fss, err = fss.MergeOne(types.FieldSpec{Path: "metadata/labels", CreateIfNotPresent: true})
   298  			}
   299  			if err != nil {
   300  				return nil, err
   301  			}
   302  			c.FieldSpecs = fss
   303  			p := f()
   304  			err = kt.configureBuiltinPlugin(p, c, bpt)
   305  			if err != nil {
   306  				return nil, err
   307  			}
   308  			result = append(result, p)
   309  		}
   310  		var c struct {
   311  			Labels     map[string]string
   312  			FieldSpecs []types.FieldSpec
   313  		}
   314  		c.Labels = kt.kustomization.CommonLabels
   315  		c.FieldSpecs = tc.CommonLabels
   316  		p := f()
   317  		err = kt.configureBuiltinPlugin(p, c, bpt)
   318  		if err != nil {
   319  			return nil, err
   320  		}
   321  		result = append(result, p)
   322  		return
   323  	},
   324  	builtinhelpers.AnnotationsTransformer: func(
   325  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   326  		result []resmap.Transformer, err error) {
   327  		if len(kt.kustomization.CommonAnnotations) == 0 {
   328  			return
   329  		}
   330  		var c struct {
   331  			Annotations map[string]string
   332  			FieldSpecs  []types.FieldSpec
   333  		}
   334  		c.Annotations = kt.kustomization.CommonAnnotations
   335  		c.FieldSpecs = tc.CommonAnnotations
   336  		p := f()
   337  		err = kt.configureBuiltinPlugin(p, c, bpt)
   338  		if err != nil {
   339  			return nil, err
   340  		}
   341  		result = append(result, p)
   342  		return
   343  	},
   344  	builtinhelpers.PrefixTransformer: func(
   345  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   346  		result []resmap.Transformer, err error) {
   347  		if kt.kustomization.NamePrefix == "" {
   348  			return
   349  		}
   350  		var c struct {
   351  			Prefix     string            `json:"prefix,omitempty" yaml:"prefix,omitempty"`
   352  			FieldSpecs []types.FieldSpec `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"`
   353  		}
   354  		c.Prefix = kt.kustomization.NamePrefix
   355  		c.FieldSpecs = tc.NamePrefix
   356  		p := f()
   357  		err = kt.configureBuiltinPlugin(p, c, bpt)
   358  		if err != nil {
   359  			return nil, err
   360  		}
   361  		result = append(result, p)
   362  		return
   363  	},
   364  	builtinhelpers.SuffixTransformer: func(
   365  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   366  		result []resmap.Transformer, err error) {
   367  		if kt.kustomization.NameSuffix == "" {
   368  			return
   369  		}
   370  		var c struct {
   371  			Suffix     string            `json:"suffix,omitempty" yaml:"suffix,omitempty"`
   372  			FieldSpecs []types.FieldSpec `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"`
   373  		}
   374  		c.Suffix = kt.kustomization.NameSuffix
   375  		c.FieldSpecs = tc.NameSuffix
   376  		p := f()
   377  		err = kt.configureBuiltinPlugin(p, c, bpt)
   378  		if err != nil {
   379  			return nil, err
   380  		}
   381  		result = append(result, p)
   382  		return
   383  	},
   384  	builtinhelpers.ImageTagTransformer: func(
   385  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   386  		result []resmap.Transformer, err error) {
   387  		var c struct {
   388  			ImageTag   types.Image
   389  			FieldSpecs []types.FieldSpec
   390  		}
   391  		for _, args := range kt.kustomization.Images {
   392  			c.ImageTag = args
   393  			c.FieldSpecs = tc.Images
   394  			p := f()
   395  			err = kt.configureBuiltinPlugin(p, c, bpt)
   396  			if err != nil {
   397  				return nil, err
   398  			}
   399  			result = append(result, p)
   400  		}
   401  		return
   402  	},
   403  	builtinhelpers.ReplacementTransformer: func(
   404  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, _ *builtinconfig.TransformerConfig) (
   405  		result []resmap.Transformer, err error) {
   406  		if len(kt.kustomization.Replacements) == 0 {
   407  			return
   408  		}
   409  		var c struct {
   410  			Replacements []types.ReplacementField
   411  		}
   412  		c.Replacements = kt.kustomization.Replacements
   413  		p := f()
   414  		err = kt.configureBuiltinPlugin(p, c, bpt)
   415  		if err != nil {
   416  			return nil, err
   417  		}
   418  		result = append(result, p)
   419  		return result, nil
   420  	},
   421  	builtinhelpers.ReplicaCountTransformer: func(
   422  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   423  		result []resmap.Transformer, err error) {
   424  		var c struct {
   425  			Replica    types.Replica
   426  			FieldSpecs []types.FieldSpec
   427  		}
   428  		for _, args := range kt.kustomization.Replicas {
   429  			c.Replica = args
   430  			c.FieldSpecs = tc.Replicas
   431  			p := f()
   432  			err = kt.configureBuiltinPlugin(p, c, bpt)
   433  			if err != nil {
   434  				return nil, err
   435  			}
   436  			result = append(result, p)
   437  		}
   438  		return
   439  	},
   440  	// No kustomization file keyword for this yet.
   441  	builtinhelpers.ValueAddTransformer: func(
   442  		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, tc *builtinconfig.TransformerConfig) (
   443  		result []resmap.Transformer, err error) {
   444  		return nil, fmt.Errorf("valueadd keyword not yet defined")
   445  	},
   446  }
   447  

View as plain text