Fixes unstructured for patches and application transform

Author: somtochiama

pkg/patterns/addon/application.go

@@ -21,6 +21,7 @@ import (
 	"errors"
 	"fmt"
 
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	addonsv1alpha1 "sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/addon/pkg/apis/v1alpha1"
 	"sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/declarative"
 	"sigs.k8s.io/kubebuilder-declarative-pattern/pkg/patterns/declarative/pkg/manifest"
@@ -42,8 +43,22 @@ const (
 
 // TransformApplicationFromStatus modifies the Application in the deployment based off the CommonStatus
 func TransformApplicationFromStatus(ctx context.Context, instance declarative.DeclarativeObject, objects *manifest.Objects) error {
-	addonObject, ok := instance.(addonsv1alpha1.CommonObject)
-	if !ok {
+	var version string
+	var healthy bool
+	var addonObject addonsv1alpha1.CommonObject
+
+	if unstruct, ok := instance.(*unstructured.Unstructured); ok {
+		v, _, err := unstructured.NestedString(unstruct.Object, "spec", "version")
+		if err != nil {
+			return fmt.Errorf("unable to get version from unstuctured: %v", err)
+		}
+		version = v
+
+		healthy, _, err = unstructured.NestedBool(unstruct.Object, "spec", "healthy")
+	} else if addonObject, ok = instance.(addonsv1alpha1.CommonObject); ok {
+		version = addonObject.CommonSpec().Version
+		healthy = addonObject.GetCommonStatus().Healthy
+	} else {
 		return fmt.Errorf("instance %T was not an addonsv1alpha1.CommonObject", instance)
 	}
 
@@ -56,12 +71,12 @@ func TransformApplicationFromStatus(ctx context.Context, instance declarative.De
 	}
 
 	assemblyPhase := Pending
-	if addonObject.GetCommonStatus().Healthy {
+	if healthy {
 		assemblyPhase = Succeeded
 	}
 
 	// TODO: Version should be on CommonStatus as well
-	app.SetNestedField(addonObject.CommonSpec().Version, "spec", "descriptor", "version")
+	app.SetNestedField(version, "spec", "descriptor", "version")
 	app.SetNestedField(assemblyPhase, "spec", "assemblyPhase")
 
 	return nil

pkg/patterns/addon/patch.go

@@ -35,25 +35,38 @@ import (
 func ApplyPatches(ctx context.Context, object declarative.DeclarativeObject, objects *manifest.Objects) error {
 	log := log.Log
 
-	p, ok := object.(addonsv1alpha1.Patchable)
-	if !ok {
-		return fmt.Errorf("provided object (%T) does not implement Patchable type", object)
-	}
-
+	var p addonsv1alpha1.Patchable
 	var patches []*unstructured.Unstructured
 
-	for _, p := range p.PatchSpec().Patches {
-		// Object is nil, Raw  is populated (with json, even when input was yaml)
-		r := bytes.NewReader(p.Raw)
-		decoder := yaml.NewYAMLOrJSONDecoder(r, 1024)
-		patch := &unstructured.Unstructured{}
+	unstruct, ok := object.(*unstructured.Unstructured)
+	if ok {
+		patch, _, err := unstructured.NestedSlice(unstruct.Object, "spec", "patches")
+		if err != nil {
+			return fmt.Errorf("unable to get patches from unstruct: %v", err)
+		}
 
-		if err := decoder.Decode(patch); err != nil {
-			return fmt.Errorf("error parsing json into unstructured object: %v", err)
+		for _, p := range patch {
+			m := p.(map[string]interface{})
+			patches = append(patches, &unstructured.Unstructured{
+				Object: m,
+			})
 		}
-		log.WithValues("patch", patch).V(1).Info("parsed patch")
+	} else if p, ok = object.(addonsv1alpha1.Patchable); ok{
+		for _, p := range p.PatchSpec().Patches {
+			// Object is nil, Raw  is populated (with json, even when input was yaml)
+			r := bytes.NewReader(p.Raw)
+			decoder := yaml.NewYAMLOrJSONDecoder(r, 1024)
+			patch := &unstructured.Unstructured{}
 
-		patches = append(patches, patch)
+			if err := decoder.Decode(patch); err != nil {
+				return fmt.Errorf("error parsing json into unstructured object: %v", err)
+			}
+			log.WithValues("patch", patch).V(1).Info("parsed patch")
+
+			patches = append(patches, patch)
+		}
+	} else {
+		return fmt.Errorf("provided object (%T) does not implement Patchable type", object)
 	}
 
 	return objects.Patch(patches)