kube

fmt.Println(DirectoryName("", "ClusterRole"))

Output:

_cluster/rbac

fmt.Println(DirectoryName("", "CustomResourceDefinition"))

Output:

_cluster/crd

fmt.Println(DirectoryName("myapps", "Deployment"))

Output:

myapps

package main

import (
	"fmt"
	"os"
	"sort"

	"github.com/volvo-cars/lingon/pkg/kube"
	"github.com/volvo-cars/lingon/pkg/kubeutil"
)

func main() {
	out := "./out/explode"
	_ = os.RemoveAll(out)
	defer func() {
		_ = os.RemoveAll(out)
	}()
	fp, err := os.Open("./testdata/karpenter.yaml")
	if err != nil {
		panic(fmt.Errorf("open file: %w", err))
	}
	defer func() {
		_ = fp.Close()
	}()

	// explode them into individual files
	if err = kube.Explode(fp, out); err != nil {
		panic(fmt.Errorf("explode manifest files: %w", err))
	}

	got, err := kubeutil.ListYAMLFiles("./out/explode")
	if err != nil {
		panic(fmt.Errorf("list yaml files: %w", err))
	}
	// sort the files to make the output deterministic
	sort.Strings(got)

	for _, f := range got {
		fmt.Println(f)
	}
}

Output:


out/explode/_cluster/rbac/1_karpenter-admin_cr.yaml
out/explode/_cluster/rbac/1_karpenter-core_cr.yaml
out/explode/_cluster/rbac/1_karpenter_cr.yaml
out/explode/_cluster/rbac/2_karpenter-core_crb.yaml
out/explode/_cluster/rbac/2_karpenter_crb.yaml
out/explode/_cluster/webhook/4_defaulting.webhook.karpenter.k8s.aws_mutatingwebhookconfigurations.yaml
out/explode/_cluster/webhook/4_defaulting.webhook.karpenter.sh_mutatingwebhookconfigurations.yaml
out/explode/_cluster/webhook/4_validation.webhook.config.karpenter.sh_validatingwebhookconfigurations.yaml
out/explode/_cluster/webhook/4_validation.webhook.karpenter.k8s.aws_validatingwebhookconfigurations.yaml
out/explode/_cluster/webhook/4_validation.webhook.karpenter.sh_validatingwebhookconfigurations.yaml
out/explode/karpenter/1_karpenter_role.yaml
out/explode/karpenter/1_karpenter_sa.yaml
out/explode/karpenter/1_karpenter_svc.yaml
out/explode/karpenter/2_config-logging_cm.yaml
out/explode/karpenter/2_karpenter-cert_secrets.yaml
out/explode/karpenter/2_karpenter-global-settings_cm.yaml
out/explode/karpenter/2_karpenter_rb.yaml
out/explode/karpenter/3_karpenter_deploy.yaml
out/explode/karpenter/4_karpenter_pdb.yaml
out/explode/kube-system/1_karpenter-dns_role.yaml
out/explode/kube-system/2_karpenter-dns_rb.yaml

package main

import (
	"fmt"
	"os"
	"strings"

	"github.com/volvo-cars/lingon/pkg/kube"
	"github.com/volvo-cars/lingon/pkg/kubeutil"
)

func main() {
	out := "./out/explodereader"
	_ = os.RemoveAll(out)
	defer func() {
		_ = os.RemoveAll(out)
	}()
	manifest, err := kubeutil.ManifestReadFile("./testdata/golden/reader.yaml")
	if err != nil {
		panic(fmt.Errorf("read manifest files: %w", err))
	}
	fakeManifest := `
apiVersion: v1
kind: ConfigMap
metadata:
  name: fake	
`
	manifest = append(manifest, fakeManifest)
	// join the manifest into a single string
	joined := strings.Join(manifest, "\n---\n")
	r := strings.NewReader(joined)

	// explode them into individual files
	// this will fail because the reader.yaml manifest is not valid
	_ = kube.Explode(r, out)

	// but we can still list the files already processed
	got, err := kubeutil.ListYAMLFiles(out)
	if err != nil {
		panic(fmt.Errorf("list yaml files: %w", err))
	}

	for _, f := range got {
		fmt.Println(f)
	}
}

Output:

out/explodereader/default/3_webapp_deploy.yaml

package main

import (
	"bytes"
	"fmt"

	"github.com/volvo-cars/lingon/pkg/kube"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// validate the struct implements the interface
var _ kube.Exporter = (*MyK8sApp)(nil)

// MyK8sApp contains kubernetes manifests
type MyK8sApp struct {
	kube.App
	// Namespace is the namespace for the tekton-pipelines
	PipelinesNS *corev1.Namespace
}

// New returns a new MyK8sApp
func New() *MyK8sApp {
	return &MyK8sApp{
		PipelinesNS: &corev1.Namespace{
			TypeMeta: metav1.TypeMeta{
				APIVersion: "v1",
				Kind:       "Namespace",
			},
			ObjectMeta: metav1.ObjectMeta{
				Name: "tekton-pipelines",
				Labels: map[string]string{
					"app.kubernetes.io/name": "tekton-pipelines",
				},
			},
		},
	}
}

func main() {
	tk := New()

	var buf bytes.Buffer
	_ = kube.Export(tk, kube.WithExportWriter(&buf))

	fmt.Printf("%s\n", buf.String())

}

Output:


-- out/0_pipelines_ns.yaml --
apiVersion: v1
kind: Namespace
metadata:
  labels:
    app.kubernetes.io/name: tekton-pipelines
  name: tekton-pipelines
spec: {}

package main

import (
	"bytes"
	"fmt"

	"github.com/volvo-cars/lingon/pkg/kube"
	"github.com/volvo-cars/lingon/pkg/kubeutil"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type SubApp struct {
	kube.App

	CM *corev1.ConfigMap
}

func NewSubApp() *SubApp {
	return &SubApp{
		CM: &corev1.ConfigMap{
			TypeMeta: kubeutil.TypeConfigMapV1,
			ObjectMeta: metav1.ObjectMeta{
				Name:      "config-map-name",
				Namespace: "my-ns",
			},
			Data: map[string]string{"key": "value"},
		},
	}
}

type MainApp struct {
	kube.App

	SubApp *SubApp
	NS     *corev1.Namespace
}

func NewApp() *MainApp {
	return &MainApp{
		SubApp: NewSubApp(),
		NS: &corev1.Namespace{
			TypeMeta:   kubeutil.TypeNamespaceV1,
			ObjectMeta: metav1.ObjectMeta{Name: "my-ns"},
		},
	}
}

func main() {
	app := NewApp()

	var buf bytes.Buffer
	_ = kube.Export(app, kube.WithExportWriter(&buf))

	fmt.Printf("%s\n", buf.String())

}

Output:


-- out/0_ns.yaml --
apiVersion: v1
kind: Namespace
metadata:
  name: my-ns
spec: {}
-- out/2_sub_appcm.yaml --
apiVersion: v1
data:
  key: value
kind: ConfigMap
metadata:
  name: config-map-name
  namespace: my-ns

out := filepath.Join("out", "tekton")
_ = os.RemoveAll(out)
defer os.RemoveAll(out)
err := kube.Import(
	// name of the application
	kube.WithImportAppName("tekton"),
	// name of the Go package where the code is generated to
	kube.WithImportPackageName("tekton"),
	// the directory to write the generated code to
	kube.WithImportOutputDirectory(out),
	// the list of manifest files to read and convert
	kube.WithImportManifestFiles([]string{"testdata/tekton.yaml"}),
	// define the types for the CRDs
	kube.WithImportSerializer(defaultSerializer()),
	// will try to remove "tekton" from the name of the variable in the Go code, make them shorter
	kube.WithImportRemoveAppName(true),
	// group all the resources from the same kind into one file each
	// example: 10 ConfigMaps => 1 file "config-map.go" containing 10 variables storing ConfigMap, etc...
	kube.WithImportGroupByKind(true),
	// add convenience methods to the App struct
	kube.WithImportAddMethods(true),
	// do not print verbose information
	kube.WithImportVerbose(false),
	// do not ignore errors
	kube.WithImportIgnoreErrors(false),
	// just for example purposes
	// how to create a logger (see [golang.org/x/tools/slog](https://golang.org/x/tools/slog))
	// this has no effect with WithImportVerbose(false)
	kube.WithImportLogger(kube.Logger(os.Stderr)),
	// remove the status field and
	// other output-only fields from the manifest code before importing it.
	// Note that ConfigMap are not cleaned up as the comments will be lost.
	kube.WithImportCleanUp(true),
)
if err != nil {
	panic(fmt.Errorf("import: %w", err))
}
got, err := kubeutil.ListGoFiles(out)
if err != nil {
	panic(fmt.Errorf("list go files: %w", err))
}
// sort the files to make the output deterministic
sort.Strings(got)

for _, f := range got {
	fmt.Println(f)
}

Output:


out/tekton/app.go
out/tekton/cluster-role-binding.go
out/tekton/cluster-role.go
out/tekton/config-map.go
out/tekton/custom-resource-definition.go
out/tekton/deployment.go
out/tekton/horizontal-pod-autoscaler.go
out/tekton/mutating-webhook-configuration.go
out/tekton/namespace.go
out/tekton/role-binding.go
out/tekton/role.go
out/tekton/secret.go
out/tekton/service-account.go
out/tekton/service.go
out/tekton/validating-webhook-configuration.go

package main

import (
	"bytes"
	"fmt"
	"os"
	"sort"
	"strings"

	"github.com/volvo-cars/lingon/pkg/kube"
	"github.com/volvo-cars/lingon/pkg/kubeutil"
	"golang.org/x/tools/txtar"
)

func main() {
	filename := "testdata/grafana.yaml"
	file, _ := os.Open(filename)

	var buf bytes.Buffer

	err := kube.Import(
		kube.WithImportAppName("grafana"),
		kube.WithImportPackageName("grafana"),
		// will prefix all files with path "manifests/"
		kube.WithImportOutputDirectory("manifests/"),
		// we could just use kube.WithImportManifestFiles([]string{filename})
		// but this is just an example to show how to use WithImportReader
		// and WithImportWriter
		kube.WithImportReader(file),
		kube.WithImportWriter(&buf),
		// We don't want to group the resources by kind,
		// each file will contain a single resource
		kube.WithImportGroupByKind(false),
		// We rename the files to avoid name collisions.
		// Tip: use the Kind and Name of the resource to
		// create a unique name and avoid collision.
		//
		// Here, we didn't use WithImportGroupByKind,
		// each file will contain a single resource.
		kube.WithImportNameFileFunc(
			func(m kubeutil.Metadata) string {
				return fmt.Sprintf(
					"%s-%s.go",
					strings.ToLower(m.Kind),
					m.Meta.Name,
				)
			},
		),
	)
	if err != nil {
		panic("failed to import")
	}

	// the output contained in bytes.Buffer is in the txtar format
	// for more details, see https://pkg.go.dev/golang.org/x/tools/txtar
	ar := txtar.Parse(buf.Bytes())

	// sort the files to make the output deterministic
	sort.SliceStable(
		ar.Files, func(i, j int) bool {
			return ar.Files[i].Name < ar.Files[j].Name
		},
	)
	for _, f := range ar.Files {
		fmt.Println(f.Name)
	}
}

Output:


manifests/app.go
manifests/clusterrole-grafana-clusterrole.go
manifests/clusterrolebinding-grafana-clusterrolebinding.go
manifests/configmap-grafana-dashboards-default.go
manifests/configmap-grafana-test.go
manifests/configmap-grafana.go
manifests/deployment-grafana.go
manifests/pod-grafana-test.go
manifests/role-grafana.go
manifests/rolebinding-grafana.go
manifests/secret-grafana.go
manifests/service-grafana.go
manifests/serviceaccount-grafana-test.go
manifests/serviceaccount-grafana.go

m := kubeutil.Metadata{
	Kind: "Deployment",
	Meta: kubeutil.Meta{Name: "super-duper-app"},
}
fmt.Println(NameFieldFunc(m))

Output:

SuperDuperAppDeploy

m := kubeutil.Metadata{
	Kind: "Deployment",
	Meta: kubeutil.Meta{Name: "super-duper-deployment"},
}
fmt.Println(NameFieldFunc(m))

Output:

SuperDuperDeploy

m := kubeutil.Metadata{
	Kind: "ClusterRole",
	Meta: kubeutil.Meta{Name: "argo-cluster-role"},
}
fmt.Println(NameFieldFunc(m))

Output:

ArgoCR

m := kubeutil.Metadata{
	Kind: "Deployment",
	Meta: kubeutil.Meta{Name: "super-duper-app"},
}
fmt.Println(NameFileFunc(m))

Output:

super-duper-app_deploy.go

m := kubeutil.Metadata{
	Kind: "Deployment",
	Meta: kubeutil.Meta{Name: "super-duper-app"},
}
fmt.Println(NameVarFunc(m))

Output:

SuperDuperAppDeploy

m := kubeutil.Metadata{
	Kind: "Deployment",
	Meta: kubeutil.Meta{Name: "super-duper-deployment"},
}
fmt.Println(NameVarFunc(m))

Output:

SuperDuperDeploy

m := kubeutil.Metadata{
	Kind: "ClusterRole",
	Meta: kubeutil.Meta{Name: "argo-cluster-role"},
}
fmt.Println(NameVarFunc(m))

Output:

ArgoCR