fix: support creating v1beta CRDs to avoid data loss during conversion to v1

Author: exdx

pkg/controller/operators/catalog/step.go

@@ -98,13 +98,42 @@ func (b *builder) NewCRDStep(manifest string, client clientset.Interface, status
 				return v1alpha1.StepStatusCreated, nil
 			}
 		case v1alpha1.StepStatusUnknown, v1alpha1.StepStatusNotPresent:
-			crd, err := crdlib.Serialize(manifest)
+			// data loss converting from v1beta1 -> v1 CRDs requires we create v1beta1 CRDs with the v1beta1 client
+			// first establish APIVersion of provided CRD
+			var crdi interface{}
+			var createError error
+			version, err := crdlib.Version(&manifest)
 			if err != nil {
 				return v1alpha1.StepStatusUnknown, err
 			}
+			logger.Debugf("crd version %s", version)
+			if version == crdlib.V1Version {
+				crd, err := crdlib.SerializeV1(manifest)
+				if err != nil {
+					return v1alpha1.StepStatusUnknown, err
+				}
+				_, createError = client.ApiextensionsV1().CustomResourceDefinitions().Create(context.TODO(), crd, metav1.CreateOptions{})
+				crdi = crd
+			} else if version == crdlib.V1Beta1Version {
+				crd, err := crdlib.SerializeV1Beta1(manifest)
+				if err != nil {
+					return v1alpha1.StepStatusUnknown, err
+				}
+				logger.Debugf("creating CRD %v", crdi)
+				_, createError = client.ApiextensionsV1beta1().CustomResourceDefinitions().Create(context.TODO(), crd, metav1.CreateOptions{})
+				crdi = crd
+			} else {
+				return v1alpha1.StepStatusUnknown, fmt.Errorf("unkown CRD version: %s", version)
+			}
+
+			// convert to v1 type for remaining CRD reconciliation logic
+			crd, err := crdlib.SerializeV1FromExisting(crdi)
+			logger.Debugf("converted crd %v", crd)
+			if err != nil {
+				return v1alpha1.StepStatusUnknown, fmt.Errorf("unable to serialize into v1 CRD from existing manifest: %s", err)
+			}
 
-			_, err = client.ApiextensionsV1().CustomResourceDefinitions().Create(context.TODO(), crd, metav1.CreateOptions{})
-			if k8serrors.IsAlreadyExists(err) {
+			if k8serrors.IsAlreadyExists(createError) {
 				currentCRD, _ := client.ApiextensionsV1().CustomResourceDefinitions().Get(context.TODO(), crd.GetName(), metav1.GetOptions{})
 				// Compare 2 CRDs to see if it needs to be updatetd
 				if crdlib.NotEqual(currentCRD, crd) {
@@ -149,7 +178,7 @@ func (b *builder) NewCRDStep(manifest string, client clientset.Interface, status
 				// If it already existed, mark the step as Present.
 				// they were equal - mark CRD as present
 				return v1alpha1.StepStatusPresent, nil
-			} else if err != nil {
+			} else if createError != nil {
 				// Unexpected error creating the CRD.
 				return v1alpha1.StepStatusUnknown, err
 			}

pkg/lib/crd/serialize.go

@@ -7,14 +7,15 @@ import (
 
 	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/install"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/yaml"
 )
 
 const (
-	Kind       = "CustomResourceDefinition"
-	APIVersion = "apiextensions.k8s.io/v1"
+	Kind  = "CustomResourceDefinition"
+	Group = "apiextensions.k8s.io/"
 )
 
 var (
@@ -26,17 +27,16 @@ func init() {
 	install.Install(scheme)
 }
 
-// Serialize takes in a CRD manifest and returns a v1 versioned CRD object.
+// SerializeV1 takes in a CRD manifest and returns a v1 versioned CRD object.
 // Compatible with v1beta1 or v1 CRD manifests.
-func Serialize(manifest string) (*apiextensionsv1.CustomResourceDefinition, error) {
+func SerializeV1(manifest string) (*apiextensionsv1.CustomResourceDefinition, error) {
 	u := &unstructured.Unstructured{}
 	reader := bytes.NewReader([]byte(manifest))
 	decoder := yaml.NewYAMLOrJSONDecoder(reader, 30)
 	if err := decoder.Decode(u); err != nil {
 		return nil, fmt.Errorf("crd unmarshaling failed: %s", err)
 	}
 
-
 	// Step through unversioned type to support v1beta1 -> v1
 	unversioned := &apiextensions.CustomResourceDefinition{}
 	if err := scheme.Convert(u, unversioned, nil); err != nil {
@@ -51,18 +51,64 @@ func Serialize(manifest string) (*apiextensionsv1.CustomResourceDefinition, erro
 	// set CRD type meta
 	// for purposes of fake client for unit tests to pass
 	crd.TypeMeta.Kind = Kind
-	crd.TypeMeta.APIVersion = APIVersion
-
+	crd.TypeMeta.APIVersion = Group + V1Version
 
 	// for each version in the CRD, check and make sure there is a schema
 	// if not a schema, give a default schema of props
 	for i := range crd.Spec.Versions {
 		if crd.Spec.Versions[i].Schema == nil {
 			schema := &apiextensionsv1.JSONSchemaProps{Type: "object"}
-			crd.Spec.Versions[i].Schema = &apiextensionsv1.CustomResourceValidation{OpenAPIV3Schema:schema}
+			crd.Spec.Versions[i].Schema = &apiextensionsv1.CustomResourceValidation{OpenAPIV3Schema: schema}
 		}
 	}
 
+	return crd, nil
+}
+
+// SerializeV1 takes in a CRD manifest and returns a v1 versioned CRD object.
+// Compatible with v1beta1 or v1 CRD manifests.
+func SerializeV1Beta1(manifest string) (*apiextensionsv1beta1.CustomResourceDefinition, error) {
+	u := &unstructured.Unstructured{}
+	reader := bytes.NewReader([]byte(manifest))
+	decoder := yaml.NewYAMLOrJSONDecoder(reader, 30)
+	if err := decoder.Decode(u); err != nil {
+		return nil, fmt.Errorf("crd unmarshaling failed: %s", err)
+	}
+
+	unversioned := &apiextensions.CustomResourceDefinition{}
+	if err := scheme.Convert(u, unversioned, nil); err != nil {
+		return nil, fmt.Errorf("failed to convert crd from unstructured to internal: %s\nto v1: %s", u, err)
+	}
+
+	crd := &apiextensionsv1beta1.CustomResourceDefinition{}
+	if err := scheme.Convert(unversioned, crd, nil); err != nil {
+		return nil, fmt.Errorf("failed to convert crd from internal to v1: %s\nto v1: %s", u, err)
+	}
+
+	// set CRD type meta
+	// for purposes of fake client for unit tests to pass
+	crd.TypeMeta.Kind = Kind
+	crd.TypeMeta.APIVersion = Group + V1Beta1Version
 
 	return crd, nil
 }
+
+// SerializeV1FromExisting takes in either a v1beta1 CRD or a v1 CRD type and returns a v1 CRD type.
+func SerializeV1FromExisting(crd interface{}) (*apiextensionsv1.CustomResourceDefinition, error) {
+	if c, ok := crd.(*apiextensionsv1.CustomResourceDefinition); ok {
+		return c, nil
+	}
+	if c, ok := crd.(*apiextensionsv1beta1.CustomResourceDefinition); ok {
+		unversioned := &apiextensions.CustomResourceDefinition{}
+		if err := scheme.Convert(c, unversioned, nil); err != nil {
+			return nil, fmt.Errorf("failed to convert crd from unstructured to internal: %s\nto v1: %s", c.String(), err)
+		}
+
+		c := &apiextensionsv1.CustomResourceDefinition{}
+		if err := scheme.Convert(unversioned, crd, nil); err != nil {
+			return nil, fmt.Errorf("failed to convert crd from internal to v1: %s\nto v1: %s", c.String(), err)
+		}
+		return c, nil
+	}
+	return nil, fmt.Errorf("unable to determine crd type")
+}

pkg/lib/crd/version.go

@@ -23,15 +23,24 @@ var supportedCRDVersions = map[string]struct{}{
 
 // Version takes a CRD manifest and determines whether it is v1 or v1beta1 type based on the APIVersion.
 func Version(manifest *string) (string, error) {
+	if manifest == nil {
+		return "", fmt.Errorf("empty CRD manifest")
+	}
+
 	dec := yaml.NewYAMLOrJSONDecoder(strings.NewReader(*manifest), 10)
 	unst := &unstructured.Unstructured{}
 	if err := dec.Decode(unst); err != nil {
 		return "", err
 	}
 
 	v := unst.GetObjectKind().GroupVersionKind().Version
+	// some e2e test fixtures do not provide an API version in their typemeta
+	// assume these are v1beta types
+	if v == "" {
+		v = V1Beta1Version
+	}
 	if _, ok := supportedCRDVersions[v]; !ok {
-		return "", fmt.Errorf("could not determine CRD version from manifest")
+		return "", fmt.Errorf("CRD APIVersion from manifest not supported: %s", v)
 	}
 
 	return v, nil