diff --git a/bin/pluginator.sh b/bin/pluginator.sh new file mode 100755 index 000000000..7e0c93b47 --- /dev/null +++ b/bin/pluginator.sh @@ -0,0 +1,46 @@ +#!/bin/bash +# +# Converts Go-based kustomize plugins in +# sigs.k8s.io/kustomize/plugin/builtin +# (all in package 'main') to generator and +# transformer factory functions in +# sigs.k8s.io/kustomize/plugin/builtingen +# (all in package 'builtingen'). +# +# Cannot put all these in the same dir, since +# plugins must be in the 'main' package, +# the factory functions cannot be in 'main', +# Go disallows multiple packages in one dir. + +set -e + +myGoPath=$1 +if [ -z ${1+x} ]; then + myGoPath=$GOPATH +fi + +if [ -z "$myGoPath" ]; then + echo "Must specify a GOPATH" + exit 1 +fi + +dir=$myGoPath/src/sigs.k8s.io/kustomize + +if [ ! -d "$dir" ]; then + echo "$dir is not a directory." + exit 1 +fi + +echo Generating linkable plugins... + +pushd $dir >& /dev/null + +/bin/rm -rf plugin/builtingen +mkdir plugin/builtingen +GOPATH=$myGoPath go generate --tags plugin \ + sigs.k8s.io/kustomize/plugin/builtin +ls -C1 plugin/builtingen + +popd >& /dev/null + +echo All done. diff --git a/bin/pre-commit.sh b/bin/pre-commit.sh index 4e8a48e94..f2ca63916 100755 --- a/bin/pre-commit.sh +++ b/bin/pre-commit.sh @@ -46,6 +46,10 @@ function testExamples { mdrip --mode test --label test README.md ./examples } +function generateCode { + ./bin/pluginator.sh $oldGoPath +} + # Use of GOPATH is optional if go modules are # used. This script tries to work for people who # don't have GOPATH set, and work for travis. @@ -90,6 +94,7 @@ echo pwd=`pwd` echo " " echo "Working..." +runFunc generateCode runFunc testGoLangCILint runFunc testGoTest diff --git a/cmd/pluginator/main.go b/cmd/pluginator/main.go new file mode 100644 index 000000000..f3e646b6d --- /dev/null +++ b/cmd/pluginator/main.go @@ -0,0 +1,338 @@ +/* +Copyright 2019 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. +*/ + +// pluginator is a code generator that converts +// kustomize generator (G) and/or transformer (T) +// Go plugins to statically linkable code. +// +// Arises from following requirements: +// +// * extension +// +// kustomize does two things - generate or +// transform k8s resources. Plugins let +// users write their own G&T's without +// having to fork kustomize and learn its +// internals. +// +// * dogfooding +// +// A G&T extension framework one can trust +// should be used by its authors to deliver +// builtin G&T's. +// +// * distribution +// +// kustomize should be distributable via +// `go get` and should run where Go +// programs are expected to run. +// +// The extension requirement led to the creation +// of a framework that accommodates writing a +// G or T as either +// +// * an 'exec' plugin (any executable file +// runnable as a kustomize subprocess), or +// +// * as a Go plugin - see +// https://golang.org/pkg/plugin. +// +// The dogfooding (and an implicit performance +// requirement) requires a 'builtin' G or T to +// be written as a Go plugin. +// +// The distribution ('go get') requirement demands +// conversion of Go plugins to statically linked +// code, hence this program. +// +// +// HOW PLUGINS RUN +// +// Assume a file 'secGen.yaml' containing +// +// apiVersion: someteam.example.com/v1 +// kind: SecretGenerator +// metadata: +// name: makesecrets +// name: mySecret +// behavior: merge +// envs: +// - db.env +// - fruit.env +// +// If this file were referenced by a kustomization +// file in its 'generators' field, kustomize would +// +// * Read 'secGen.yaml'. +// +// * Use the value of $XGD_CONFIG_HOME and +// 'apiversion' and to find an executable +// named 'SecretGenerator' to use as +// an exec plugin, or failing that, +// +// * use the same info to load a Go plugin +// object file called 'SecretGenerator.so'. +// +// * Send either the file name 'secGen.yaml' as +// the first arg to the exec plugin, or send its +// contents to the go plugin's Config method. +// +// * Use the plugin to generate and/or transform. +// +// +// GO PLUGIN CONVENTIONS +// +// A .go file can be a Go plugin if it declares +// 'main' as it's package, and exports a symbol to +// which useful functions are attached. It can +// further be used as a _kustomize_ plugin if +// those functions implement the Configurable, +// Generator and Transformer interfaces. +// +// Converting the plugin file to a normal .go package +// file is a matter string substitution permitted +// by the following conventions. +// +// * Configuration of builtin plugins: +// +// Config file looks like +// +// --------------------------------------------- +// apiVersion: builtin +// kind: SecretGenerator +// metadata: +// name: whatever +// otherFields: whatever +// --------------------------------------------- +// +// The apiVersion must be 'builtin'. +// +// For non-builtins the apiVersion can be any legal +// apiVersion value, e.g. 'someteam.example.com/v1beta1' +// +// The builtin source must be at: +// +// ${repo}/plugin/${apiVersion}/${kind}.go +// +// where repo=$GOPATH/src/sigs.k8s.io/kustomize +// +// k8s wants 'kind' values to follow CamelCase, +// while Go style wants (but doesn't demand) +// lowercase file names. +// +// kustomize will accept either idiom, but the Go file +// name must be ${kind}.go (CamelCase allowed). +// +// * Source follows this pattern +// +// --------------------------------------------- +// // +build plugin +// +// //go:generate go run sigs.k8s.io/kustomize/cmd/pluginator +// package main +// import ... +// type plugin struct{...} +// var KustomizePlugin plugin +// func (p *plugin) Config( +// ldr ifc.Loader, rf *resmap.Factory, +// k ifc.Kunstructured) error {...} +// func (p *plugin) Generate( +// ) (resmap.ResMap, error) {...} +// func (p *plugin) Transform( +// m resmap.ResMap) error {...} +// --------------------------------------------- +// +// - The 2nd line must be empty. +// - One may `go fmt` this file. +// - There's no mention of 'SecretGenerator' +// in this file; that binding is done by +// the plugin loader or pluginator. +// +// * To compile this for loading as a Go plugin: +// +// repo=$GOPATH/src/sigs.k8s.io/kustomize +// dir=$repo/plugin/builtin +// go build -buildmode plugin -tags=plugin \ +// -o $dir/SecretGenerator.so \ +// $dir/SecretGenerator.go +// +// * To generate code: +// +// repo=$GOPATH/src/sigs.k8s.io/kustomize +// cd $repo/plugin/builtin +// go generate --tags plugin . +// +// This creates +// +// $repo/plugin/builtingen/SecretGenerator.go +// +// etc. +// +// * Generated plugins are used in kustomize via +// +// --------------------------------------------- +// package whatever +// import "sigs.k8s.io/kustomize/plugin/builtingen +// ... +// g := builtingen.NewSecretGenerator() +// g.Config(l, rf, k) +// resources, err := g.Generate() +// err = g.Transform(resources) +// // Eventually emit resources. +// --------------------------------------------- +// +package main + +import ( + "bufio" + "fmt" + "log" + "os" + "path/filepath" + "strings" + + "sigs.k8s.io/kustomize/pkg/pgmconfig" + "sigs.k8s.io/kustomize/pkg/plugins" +) + +func main() { + root := fileRoot() + file, err := os.Open(root + ".go") + if err != nil { + log.Fatal(err) + } + defer file.Close() + scanner := bufio.NewScanner(file) + processBoilerPlate(scanner, file.Name()) + + w := NewWriter(root) + defer w.close() + + // This particular phrasing is required. + w.write( + fmt.Sprintf( + "// Code generated by pluginator on %s; DO NOT EDIT.", + root)) + w.write("package builtingen") + + for scanner.Scan() { + l := scanner.Text() + if strings.HasPrefix(l, "//go:generate") { + continue + } + if l == "var "+plugins.PluginSymbol+" plugin" { + w.write("func New" + root + "Plugin() *" + root + "Plugin {") + w.write(" return &" + root + "Plugin{}") + w.write("}") + continue + } + w.write(l) + } + if err := scanner.Err(); err != nil { + log.Fatal(err) + } +} + +func fileRoot() string { + n := os.Getenv("GOFILE") + if !strings.HasSuffix(n, ".go") { + log.Fatalf("expecting .go suffix on %s", n) + } + return n[:len(n)-len(".go")] +} + +func processBoilerPlate(s *bufio.Scanner, f string) { + if !s.Scan() { + log.Fatalf("1: %s not long enough", f) + } + first := s.Text() + if !s.Scan() { + log.Fatalf("2: %s not long enough", f) + } + next := s.Text() + if !hasPluginTag(first, next) { + log.Fatalf("%s lacks plugin tag", f) + } + gotMain := false + for !gotMain && s.Scan() { + next = s.Text() + gotMain = strings.HasPrefix(next, "package main") + } + if !gotMain { + log.Fatalf("%s missing package main", f) + } +} + +func hasPluginTag(first, next string) bool { + return strings.HasPrefix(first, "// +build plugin") && + len(next) == 0 +} + +type writer struct { + root string + f *os.File +} + +func NewWriter(r string) *writer { + n := makeSrcFileName(r) + f, err := os.Create(n) + if err != nil { + log.Fatalf("unable to create `%s`; %v", n, err) + } + return &writer{root: r, f: f} +} + +func makeSrcFileName(root string) string { + return filepath.Join( + os.Getenv("GOPATH"), + "src", + pgmconfig.DomainName, + pgmconfig.ProgramName, + pgmconfig.PluginRoot, + "builtingen", + root+".go") +} + +func (w *writer) close() { w.f.Close() } + +func (w *writer) write(line string) { + _, err := w.f.WriteString(w.filter(line) + "\n") + if err != nil { + log.Printf("Trouble writing: %s", line) + log.Fatal(err) + } +} + +func (w *writer) filter(in string) string { + if ok, newer := w.replace(in, "type plugin struct"); ok { + return newer + } + if ok, newer := w.replace(in, "*plugin)"); ok { + return newer + } + return in +} + +// replace 'plugin' with 'FooPlugin' in context +// sensitive manner. +func (w *writer) replace(in, target string) (bool, string) { + if !strings.Contains(in, target) { + return false, "" + } + newer := strings.Replace( + target, "plugin", w.root+"Plugin", 1) + return true, strings.Replace(in, target, newer, 1) +} diff --git a/pkg/target/kusttarget.go b/pkg/target/kusttarget.go index 1f7e7eb67..6a5576bdb 100644 --- a/pkg/target/kusttarget.go +++ b/pkg/target/kusttarget.go @@ -231,16 +231,6 @@ func (kt *KustTarget) AccumulateTarget() ( return nil, errors.Wrapf( err, "merging CRDs %v", crdTc) } - resMap, err := kt.generateConfigMapsAndSecrets() - if err != nil { - return nil, errors.Wrap( - err, "generating legacy configMaps and secrets") - } - err = ra.MergeResourcesWithOverride(resMap) - if err != nil { - return nil, errors.Wrap( - err, "merging legacy configMaps and secrets") - } err = kt.generateFromPlugins(ra) if err != nil { return nil, err @@ -265,14 +255,29 @@ func (kt *KustTarget) AccumulateTarget() ( func (kt *KustTarget) generateFromPlugins( ra *accumulator.ResAccumulator) error { - generators, err := kt.loadGeneratorPlugins() + generators, err := kt.configureBuiltinGenerators() + if err != nil { + return err + } + for _, g := range generators { + resMap, err := g.Generate() + if err != nil { + return err + } + // The legacy generators allow override. + err = ra.MergeResourcesWithOverride(resMap) + if err != nil { + return errors.Wrapf(err, "merging from generator %v", g) + } + } + generators, err = kt.loadGeneratorPlugins() if err != nil { return errors.Wrap(err, "loading generator plugins") } for _, g := range generators { resMap, err := g.Generate() if err != nil { - return errors.Wrapf(err, "generating from %v", g) + return err } err = ra.MergeResourcesWithErrorOnIdCollision(resMap) if err != nil { @@ -282,26 +287,6 @@ func (kt *KustTarget) generateFromPlugins( return nil } -func (kt *KustTarget) generateConfigMapsAndSecrets() (resmap.ResMap, error) { - cms, err := kt.rFactory.NewResMapFromConfigMapArgs( - kt.ldr, - kt.kustomization.GeneratorOptions, - kt.kustomization.ConfigMapGenerator) - if err != nil { - return nil, errors.Wrapf( - err, "configmapgenerator: %v", kt.kustomization.ConfigMapGenerator) - } - secrets, err := kt.rFactory.NewResMapFromSecretArgs( - kt.ldr, - kt.kustomization.GeneratorOptions, - kt.kustomization.SecretGenerator) - if err != nil { - return nil, errors.Wrapf( - err, "secretgenerator: %v", kt.kustomization.SecretGenerator) - } - return resmap.MergeWithErrorOnIdCollision(cms, secrets) -} - // accumulateResources fills the given resourceAccumulator // with resources read from the given list of paths. func (kt *KustTarget) accumulateResources( @@ -397,11 +382,11 @@ func (kt *KustTarget) newTransformer( return nil, err } r = append(r, t) - t, err = transformers.NewImageTransformer(kt.kustomization.Images, tConfig.Images) + lts, err := kt.configureBuiltinTransformers(tConfig) if err != nil { return nil, err } - r = append(r, t) + r = append(r, lts...) tp, err := kt.loadTransformerPlugins() if err != nil { return nil, err diff --git a/pkg/target/kusttarget_configplugin.go b/pkg/target/kusttarget_configplugin.go new file mode 100644 index 000000000..f4031a3af --- /dev/null +++ b/pkg/target/kusttarget_configplugin.go @@ -0,0 +1,165 @@ +/* +Copyright 2019 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 ( + "github.com/pkg/errors" + "sigs.k8s.io/kustomize/pkg/image" + "sigs.k8s.io/kustomize/pkg/plugins" + "sigs.k8s.io/kustomize/pkg/transformers" + "sigs.k8s.io/kustomize/pkg/transformers/config" + "sigs.k8s.io/kustomize/pkg/types" + "sigs.k8s.io/kustomize/plugin/builtingen" + "sigs.k8s.io/yaml" +) + +// Functions dedicated to configuring the builtin +// transformer and generator plugins using config data +// read from a kustomization file. +// +// Non-builtin plugins will get their configuration +// from their own dedicated structs and yaml files. +// +// There are some loops in the functions below because +// the kustomization file would, say, allow one to +// request multiple secrets be made, or run multiple +// image tag transforms, so we need to run the plugins +// N times (plugins are easier to write, configure and +// test if they do just one thing). +// +// TODO: Push code down into the plugins, as the first pass +// at this writes plugins as thin layers over calls +// into existing packages. The builtin plugins should +// be viewed as examples, and the packages they access +// directory should be public, while everything else +// should go into internal. + +type generatorConfigurator func() ([]transformers.Generator, error) +type transformerConfigurator func( + tConfig *config.TransformerConfig) ([]transformers.Transformer, error) + +func (kt *KustTarget) configureBuiltinGenerators() ( + []transformers.Generator, error) { + configurators := []generatorConfigurator{ + kt.configureBuiltinConfigMapGenerator, + kt.configureBuiltinSecretGenerator, + } + var result []transformers.Generator + for _, f := range configurators { + r, err := f() + if err != nil { + return nil, err + } + result = append(result, r...) + } + return result, nil +} + +func (kt *KustTarget) configureBuiltinTransformers( + tConfig *config.TransformerConfig) ( + []transformers.Transformer, error) { + // TODO: Convert remaining legacy transformers to plugins + // (patch SMP/JSON, name prefix/suffix, labels/annos). + // with tests. + configurators := []transformerConfigurator{ + kt.configureBuiltinImageTagTransformer, + } + var result []transformers.Transformer + for _, f := range configurators { + r, err := f(tConfig) + if err != nil { + return nil, err + } + result = append(result, r...) + } + return result, nil +} + +func (kt *KustTarget) configureBuiltinSecretGenerator() ( + result []transformers.Generator, err error) { + var c struct { + types.GeneratorOptions + types.SecretArgs + } + if kt.kustomization.GeneratorOptions != nil { + c.GeneratorOptions = *kt.kustomization.GeneratorOptions + } + for _, args := range kt.kustomization.SecretGenerator { + c.SecretArgs = args + p := builtingen.NewSecretGeneratorPlugin() + err = kt.configureBuiltinPlugin(p, c, "secret") + if err != nil { + return nil, err + } + result = append(result, p) + } + return +} + +func (kt *KustTarget) configureBuiltinConfigMapGenerator() ( + result []transformers.Generator, err error) { + var c struct { + types.GeneratorOptions + types.ConfigMapArgs + } + if kt.kustomization.GeneratorOptions != nil { + c.GeneratorOptions = *kt.kustomization.GeneratorOptions + } + for _, args := range kt.kustomization.ConfigMapGenerator { + c.ConfigMapArgs = args + p := builtingen.NewConfigMapGeneratorPlugin() + err = kt.configureBuiltinPlugin(p, c, "configmap") + if err != nil { + return nil, err + } + result = append(result, p) + } + return +} + +func (kt *KustTarget) configureBuiltinImageTagTransformer( + tConfig *config.TransformerConfig) ( + result []transformers.Transformer, err error) { + var c struct { + ImageTag image.Image + FieldSpecs []config.FieldSpec + } + for _, args := range kt.kustomization.Images { + c.ImageTag = args + c.FieldSpecs = tConfig.Images + p := builtingen.NewImageTagTransformerPlugin() + err = kt.configureBuiltinPlugin(p, c, "imageTag") + if err != nil { + return nil, err + } + result = append(result, p) + } + return +} + +func (kt *KustTarget) configureBuiltinPlugin( + p plugins.Configurable, c interface{}, id string) error { + y, err := yaml.Marshal(c) + if err != nil { + return errors.Wrapf(err, "builtin %s marshal", id) + } + err = p.Config(kt.ldr, kt.rFactory, y) + if err != nil { + return errors.Wrapf(err, "builtin %s config: %v", id, y) + } + return nil +} diff --git a/plugin/builtin/ConfigMapGenerator.go b/plugin/builtin/ConfigMapGenerator.go index c3c316b07..ea895a20b 100644 --- a/plugin/builtin/ConfigMapGenerator.go +++ b/plugin/builtin/ConfigMapGenerator.go @@ -16,6 +16,7 @@ See the License for the specific language governing permissions and limitations under the License. */ +//go:generate go run sigs.k8s.io/kustomize/cmd/pluginator package main import ( diff --git a/plugin/builtin/ImageTagTransformer.go b/plugin/builtin/ImageTagTransformer.go new file mode 100644 index 000000000..14d835e91 --- /dev/null +++ b/plugin/builtin/ImageTagTransformer.go @@ -0,0 +1,56 @@ +// +build plugin + +/* +Copyright 2019 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. +*/ + +//go:generate go run sigs.k8s.io/kustomize/cmd/pluginator +package main + +import ( + "sigs.k8s.io/kustomize/pkg/ifc" + "sigs.k8s.io/kustomize/pkg/image" + "sigs.k8s.io/kustomize/pkg/resmap" + "sigs.k8s.io/kustomize/pkg/transformers" + "sigs.k8s.io/kustomize/pkg/transformers/config" + "sigs.k8s.io/yaml" +) + +// Find matching image declarations and replace +// the name, tag and/or digest. +type plugin struct { + ImageTag image.Image `json:"imageTag,omitempty" yaml:"imageTag,omitempty"` + FieldSpecs []config.FieldSpec `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"` +} + +var KustomizePlugin plugin + +func (p *plugin) Config( + ldr ifc.Loader, rf *resmap.Factory, c []byte) (err error) { + p.ImageTag = image.Image{} + p.FieldSpecs = nil + return yaml.Unmarshal(c, p) +} + +func (p *plugin) Transform(m resmap.ResMap) error { + argsList := make([]image.Image, 1) + argsList[0] = p.ImageTag + t, err := transformers.NewImageTransformer(argsList, p.FieldSpecs) + if err != nil { + return err + } + return t.Transform(m) +} + diff --git a/plugin/builtin/ImageTagTransformer_test.go b/plugin/builtin/ImageTagTransformer_test.go new file mode 100644 index 000000000..9320e42d9 --- /dev/null +++ b/plugin/builtin/ImageTagTransformer_test.go @@ -0,0 +1,91 @@ +/* +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 main_test + +import ( + "testing" + + "sigs.k8s.io/kustomize/internal/plugintest" + "sigs.k8s.io/kustomize/k8sdeps/kv/plugin" + "sigs.k8s.io/kustomize/pkg/kusttest" + "sigs.k8s.io/kustomize/pkg/loader" +) + +func TestImageTagTransformer(t *testing.T) { + tc := plugintest_test.NewPluginTestEnv(t).Set() + defer tc.Reset() + + tc.BuildGoPlugin( + "builtin", "", "ImageTagTransformer") + + th := kusttest_test.NewKustTestHarnessFull( + t, "/app", loader.RestrictionRootOnly, plugin.ActivePluginConfig()) + + rm := th.LoadAndRunTransformer(` +apiVersion: builtin +kind: ImageTagTransformer +metadata: + name: notImportantHere +imageTag: + name: nginx + newTag: v2 +`,` +group: apps +apiVersion: v1 +kind: Deployment +metadata: + name: deploy1 +spec: + template: + spec: + initContainers: + - name: nginx2 + image: my-nginx:1.8.0 + - name: init-alpine + image: alpine:1.8.0 + containers: + - name: ngnix + image: nginx:1.7.9 + - name: repliaced-with-digest + image: foobar:1 + - name: postgresdb + image: postgres:1.8.0 +`) + + th.AssertActualEqualsExpected(rm, ` +apiVersion: v1 +group: apps +kind: Deployment +metadata: + name: deploy1 +spec: + template: + spec: + containers: + - image: nginx:v2 + name: ngnix + - image: foobar:1 + name: repliaced-with-digest + - image: postgres:1.8.0 + name: postgresdb + initContainers: + - image: my-nginx:1.8.0 + name: nginx2 + - image: alpine:1.8.0 + name: init-alpine +`) +} diff --git a/plugin/builtin/SecretGenerator.go b/plugin/builtin/SecretGenerator.go index aacbb4d02..e0c5f87b6 100644 --- a/plugin/builtin/SecretGenerator.go +++ b/plugin/builtin/SecretGenerator.go @@ -16,6 +16,7 @@ See the License for the specific language governing permissions and limitations under the License. */ +//go:generate go run sigs.k8s.io/kustomize/cmd/pluginator package main import ( diff --git a/plugin/builtingen/ConfigMapGenerator.go b/plugin/builtingen/ConfigMapGenerator.go new file mode 100644 index 000000000..027345c9b --- /dev/null +++ b/plugin/builtingen/ConfigMapGenerator.go @@ -0,0 +1,37 @@ +// Code generated by pluginator on ConfigMapGenerator; DO NOT EDIT. +package builtingen + +import ( + "sigs.k8s.io/kustomize/pkg/ifc" + "sigs.k8s.io/kustomize/pkg/resmap" + "sigs.k8s.io/kustomize/pkg/types" + "sigs.k8s.io/yaml" +) + +type ConfigMapGeneratorPlugin struct { + ldr ifc.Loader + rf *resmap.Factory + types.GeneratorOptions + types.ConfigMapArgs +} + +func NewConfigMapGeneratorPlugin() *ConfigMapGeneratorPlugin { + return &ConfigMapGeneratorPlugin{} +} + +func (p *ConfigMapGeneratorPlugin) Config( + ldr ifc.Loader, rf *resmap.Factory, config []byte) (err error) { + p.GeneratorOptions = types.GeneratorOptions{} + p.ConfigMapArgs = types.ConfigMapArgs{} + err = yaml.Unmarshal(config, p) + p.ldr = ldr + p.rf = rf + return +} + +func (p *ConfigMapGeneratorPlugin) Generate() (resmap.ResMap, error) { + argsList := make([]types.ConfigMapArgs, 1) + argsList[0] = p.ConfigMapArgs + return p.rf.NewResMapFromConfigMapArgs( + p.ldr, &p.GeneratorOptions, argsList) +} diff --git a/plugin/builtingen/ImageTagTransformer.go b/plugin/builtingen/ImageTagTransformer.go new file mode 100644 index 000000000..660197f5c --- /dev/null +++ b/plugin/builtingen/ImageTagTransformer.go @@ -0,0 +1,40 @@ +// Code generated by pluginator on ImageTagTransformer; DO NOT EDIT. +package builtingen + +import ( + "sigs.k8s.io/kustomize/pkg/ifc" + "sigs.k8s.io/kustomize/pkg/image" + "sigs.k8s.io/kustomize/pkg/resmap" + "sigs.k8s.io/kustomize/pkg/transformers" + "sigs.k8s.io/kustomize/pkg/transformers/config" + "sigs.k8s.io/yaml" +) + +// Find matching image declarations and replace +// the name, tag and/or digest. +type ImageTagTransformerPlugin struct { + ImageTag image.Image `json:"imageTag,omitempty" yaml:"imageTag,omitempty"` + FieldSpecs []config.FieldSpec `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"` +} + +func NewImageTagTransformerPlugin() *ImageTagTransformerPlugin { + return &ImageTagTransformerPlugin{} +} + +func (p *ImageTagTransformerPlugin) Config( + ldr ifc.Loader, rf *resmap.Factory, c []byte) (err error) { + p.ImageTag = image.Image{} + p.FieldSpecs = nil + return yaml.Unmarshal(c, p) +} + +func (p *ImageTagTransformerPlugin) Transform(m resmap.ResMap) error { + argsList := make([]image.Image, 1) + argsList[0] = p.ImageTag + t, err := transformers.NewImageTransformer(argsList, p.FieldSpecs) + if err != nil { + return err + } + return t.Transform(m) +} + diff --git a/plugin/builtingen/SecretGenerator.go b/plugin/builtingen/SecretGenerator.go new file mode 100644 index 000000000..4e660c310 --- /dev/null +++ b/plugin/builtingen/SecretGenerator.go @@ -0,0 +1,37 @@ +// Code generated by pluginator on SecretGenerator; DO NOT EDIT. +package builtingen + +import ( + "sigs.k8s.io/kustomize/pkg/ifc" + "sigs.k8s.io/kustomize/pkg/resmap" + "sigs.k8s.io/kustomize/pkg/types" + "sigs.k8s.io/yaml" +) + +type SecretGeneratorPlugin struct { + ldr ifc.Loader + rf *resmap.Factory + types.GeneratorOptions + types.SecretArgs +} + +func NewSecretGeneratorPlugin() *SecretGeneratorPlugin { + return &SecretGeneratorPlugin{} +} + +func (p *SecretGeneratorPlugin) Config( + ldr ifc.Loader, rf *resmap.Factory, config []byte) (err error) { + p.GeneratorOptions = types.GeneratorOptions{} + p.SecretArgs = types.SecretArgs{} + err = yaml.Unmarshal(config, p) + p.ldr = ldr + p.rf = rf + return +} + +func (p *SecretGeneratorPlugin) Generate() (resmap.ResMap, error) { + argsList := make([]types.SecretArgs, 1) + argsList[0] = p.SecretArgs + return p.rf.NewResMapFromSecretArgs( + p.ldr, &p.GeneratorOptions, argsList) +}