K8SPS-567: automatic yaml generation (#1136)

* K8SPS-567: automatic cr.yaml generation

https://perconadev.atlassian.net/browse/K8SPS-567

* Update cmd/example-gen/defaults/preset.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fix commenting

* small fixes

* reduce size of `manual.go`

* generation of backups and restores

* fix shellcheck

* fix shellcheck

* fix shellcheck

* fix shellcheck

* fix shellcheck

* check

* Revert "check"

This reverts commit ed6a0a0.

* fix enableVolumeExpansion

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: pooknull

.github/workflows/reviewdog.yml

@@ -52,7 +52,7 @@ jobs:
         with:
           github_token: ${{ secrets.github_token }}
           reporter: github-pr-check
-          shellcheck_flags: -e SC2155
+          shellcheck_flags: -e SC2155 --external-sources
           exclude: "./vendor/*"
 
   misspell:

Makefile

@@ -106,7 +106,19 @@ kuttl-shfmt:
 e2e-test: kuttl-shfmt
 	ROOT_REPO=$(ROOT_REPO) kubectl kuttl test --config e2e-tests/kuttl.yaml
 
-manifests: kustomize generate ## Generate Kubernetes manifests (CRDs, RBAC, operator deployment)
+.PHONY: generate-cr-yaml
+generate-cr-yaml:
+	./cmd/example-gen/scripts/generate.sh ps
+
+.PHONY: generate-restore-yaml
+generate-restore-yaml:
+	./cmd/example-gen/scripts/generate.sh ps-restore
+
+.PHONY: generate-backup-yaml
+generate-backup-yaml:
+	./cmd/example-gen/scripts/generate.sh ps-backup
+
+manifests: kustomize generate generate-cr-yaml generate-restore-yaml generate-backup-yaml ## Generate Kubernetes manifests (CRDs, RBAC, operator deployment)
 	$(KUSTOMIZE) build config/crd/ > $(DEPLOYDIR)/crd.yaml
 	echo "---" >> $(DEPLOYDIR)/crd.yaml
 

api/v1/perconaservermysql_types.go

@@ -147,6 +147,8 @@ type MySQLSpec struct {
 
 	VaultSecretName string `json:"vaultSecretName,omitempty"`
 
+	VolumeSpec *VolumeSpec `json:"volumeSpec,omitempty"`
+
 	PodSpec `json:",inline"`
 }
 
@@ -194,7 +196,6 @@ type PodSpec struct {
 	Size        int32             `json:"size,omitempty"`
 	Annotations map[string]string `json:"annotations,omitempty"`
 	Labels      map[string]string `json:"labels,omitempty"`
-	VolumeSpec  *VolumeSpec       `json:"volumeSpec,omitempty"`
 
 	// Deprecated: not supported since v0.12.0. Use initContainer instead
 	InitImage     string             `json:"initImage,omitempty"`
@@ -409,7 +410,6 @@ type BackupStorageS3Spec struct {
 	CredentialsSecret string           `json:"credentialsSecret"`
 	Region            string           `json:"region,omitempty"`
 	EndpointURL       string           `json:"endpointUrl,omitempty"`
-	StorageClass      string           `json:"storageClass,omitempty"`
 }
 
 // BucketAndPrefix returns bucket name and backup prefix from Bucket concatenated with Prefix.

api/v1/zz_generated.deepcopy.go

@@ -18,8 +18,7 @@ request_data() {
 				        "endpointUrl": "$(json_escape "${AWS_ENDPOINT}")",
 				        "accessKey": "$(json_escape "${AWS_ACCESS_KEY_ID}")",
 				        "secretKey": "$(json_escape "${AWS_SECRET_ACCESS_KEY}")",
-				        "region": "$(json_escape "${AWS_DEFAULT_REGION}")",
-				        "storageClass": "$(json_escape "${S3_STORAGE_CLASS}")"
+				        "region": "$(json_escape "${AWS_DEFAULT_REGION}")"
 				    }
 				}
 			EOF

build/run-backup.sh

@@ -0,0 +1,147 @@
+package fill
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// ByType recursively fills zero or nil fields in the given pointer value `v`
+// using provided preset values matched by type. It modifies `v` in place.
+func ByType(v any, presets ...any) error {
+	rv := reflect.ValueOf(v)
+	if !rv.IsValid() {
+		return fmt.Errorf("nil value")
+	}
+	if rv.Kind() != reflect.Pointer || rv.IsNil() {
+		return fmt.Errorf("value must be a non-nil pointer")
+	}
+	fillValue(rv, buildRules(presets...))
+	return nil
+}
+
+type rules map[reflect.Type]reflect.Value
+
+func buildRules(presets ...any) rules {
+	r := make(rules, len(presets))
+	for _, p := range presets {
+		if p == nil {
+			continue
+		}
+		v := reflect.ValueOf(p)
+		r[v.Type()] = v
+	}
+	return r
+}
+
+func fillValue(v reflect.Value, r rules) {
+	for v.Kind() == reflect.Pointer {
+		if v.IsNil() {
+			if ok, def := lookup(v.Type(), r); ok {
+				v.Set(def)
+			} else {
+				return
+			}
+		}
+		v = v.Elem()
+	}
+
+	switch v.Kind() {
+	case reflect.Struct:
+		t := v.Type()
+		for i := 0; i < v.NumField(); i++ {
+			sf := t.Field(i)
+			if sf.PkgPath != "" { // not exported
+				continue
+			}
+			fv := v.Field(i)
+
+			setIfZero(fv, r)
+
+			switch fv.Kind() {
+			case reflect.Pointer, reflect.Struct, reflect.Slice, reflect.Map, reflect.Interface:
+				fillValue(fv, r)
+			}
+		}
+
+	case reflect.Slice:
+		for i := 0; i < v.Len(); i++ {
+			fillValue(v.Index(i), r)
+		}
+
+	case reflect.Map:
+		iter := v.MapRange()
+		for iter.Next() {
+			k, val := iter.Key(), iter.Value()
+
+			elem := reflect.New(v.Type().Elem()).Elem()
+			elem.Set(val)
+
+			setIfZero(elem, r)
+
+			switch elem.Kind() {
+			case reflect.Pointer, reflect.Struct, reflect.Slice, reflect.Map, reflect.Interface:
+				fillValue(elem, r)
+			}
+			v.SetMapIndex(k, elem)
+		}
+
+	case reflect.Interface:
+		if !v.IsNil() {
+			cur := v.Elem()
+			tmp := reflect.New(cur.Type()).Elem()
+			tmp.Set(cur)
+			fillValue(tmp, r)
+			v.Set(tmp)
+		}
+	}
+}
+
+func setIfZero(fv reflect.Value, r rules) {
+	need := false
+	switch fv.Kind() {
+	case reflect.Pointer, reflect.Map, reflect.Slice, reflect.Interface:
+		need = fv.IsNil()
+	default:
+		need = fv.IsZero()
+	}
+	if !need {
+		return
+	}
+	if ok, def := lookup(fv.Type(), r); ok {
+		fv.Set(def)
+		return
+	}
+}
+
+func lookup(t reflect.Type, r rules) (bool, reflect.Value) {
+	if dv, ok := r[t]; ok {
+		if dv.Type().AssignableTo(t) {
+			return true, dv
+		}
+		if dv.Type().ConvertibleTo(t) {
+			return true, dv.Convert(t)
+		}
+	}
+
+	if t.Kind() == reflect.Pointer {
+		elem := t.Elem()
+		if dv, ok := r[elem]; ok {
+			ptr := reflect.New(elem)
+			if dv.Type().AssignableTo(elem) {
+				ptr.Elem().Set(dv)
+				return true, ptr
+			}
+			if dv.Type().ConvertibleTo(elem) {
+				ptr.Elem().Set(dv.Convert(elem))
+				return true, ptr
+			}
+		}
+	}
+
+	if t.Kind() != reflect.Interface {
+		if dv, ok := r[reflect.PointerTo(t)]; ok && dv.Kind() == reflect.Pointer && !dv.IsNil() && dv.Type().Elem().AssignableTo(t) {
+			return true, dv.Elem()
+		}
+	}
+	return false, reflect.Value{}
+}