WIP: add Release version as an optional field in the CSV

Makefile

@@ -129,7 +129,7 @@ $(YQ): $(LOCALBIN)
 	GOBIN=$(LOCALBIN) go install $(GO_INSTALL_OPTS) github.com/mikefarah/yq/v4@$(YQ_VERSION)
 
 .PHONY: kind
-kind: $(KIND) ## Download yq locally if necessary.
+kind: $(KIND) ## Download kind locally if necessary.
 $(KIND): $(LOCALBIN)
 	GOBIN=$(LOCALBIN) go install $(GO_INSTALL_OPTS) sigs.k8s.io/kind@latest
 

crds/operators.coreos.com_clusterserviceversions.yaml

@@ -27,6 +27,10 @@ spec:
           jsonPath: .spec.version
           name: Version
           type: string
+        - description: The release version of the CSV
+          jsonPath: .spec.release
+          name: Release
+          type: string
         - description: The name of a CSV that this one replaces
           jsonPath: .spec.replaces
           name: Replaces
@@ -8988,6 +8992,8 @@ spec:
                         type: string
                       name:
                         type: string
+                release:
+                  type: string
                 replaces:
                   description: The name of a CSV this one replaces. Should match the `metadata.Name` field of the old CSV.
                   type: string

pkg/lib/release/release.go

@@ -0,0 +1,62 @@
+package release
+
+import (
+	"encoding/json"
+	"strings"
+
+	semver "github.com/blang/semver/v4"
+)
+
+// +k8s:openapi-gen=true
+// OperatorRelease is a wrapper around a slice of semver.PRVersion which supports correct
+// marshaling to YAML and JSON.
+// +kubebuilder:validation:Type=string
+type OperatorRelease struct {
+	Release []semver.PRVersion `json:"-"`
+}
+
+// DeepCopyInto creates a deep-copy of the Version value.
+func (v *OperatorRelease) DeepCopyInto(out *OperatorRelease) {
+	out.Release = make([]semver.PRVersion, len(v.Release))
+	copy(out.Release, v.Release)
+}
+
+// MarshalJSON implements the encoding/json.Marshaler interface.
+func (v OperatorRelease) MarshalJSON() ([]byte, error) {
+	segments := []string{}
+	for _, segment := range v.Release {
+		segments = append(segments, segment.String())
+	}
+	return json.Marshal(strings.Join(segments, "."))
+}
+
+// UnmarshalJSON implements the encoding/json.Unmarshaler interface.
+func (v *OperatorRelease) UnmarshalJSON(data []byte) (err error) {
+	var versionString string
+
+	if err = json.Unmarshal(data, &versionString); err != nil {
+		return
+	}
+
+	segments := strings.Split(versionString, ".")
+	for _, segment := range segments {
+		release, err := semver.NewPRVersion(segment)
+		if err != nil {
+			return err
+		}
+		v.Release = append(v.Release, release)
+	}
+
+	return nil
+}
+
+// OpenAPISchemaType is used by the kube-openapi generator when constructing
+// the OpenAPI spec of this type.
+//
+// See: https://github.com/kubernetes/kube-openapi/tree/master/pkg/generators
+func (_ OperatorRelease) OpenAPISchemaType() []string { return []string{"string"} }
+
+// OpenAPISchemaFormat is used by the kube-openapi generator when constructing
+// the OpenAPI spec of this type.
+// "semver" is not a standard openapi format but tooling may use the value regardless
+func (_ OperatorRelease) OpenAPISchemaFormat() string { return "semver" }

pkg/lib/release/release_test.go

@@ -0,0 +1,109 @@
+package release
+
+import (
+	"encoding/json"
+	"testing"
+
+	semver "github.com/blang/semver/v4"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOperatorReleaseMarshal(t *testing.T) {
+	tests := []struct {
+		name string
+		in   OperatorRelease
+		out  []byte
+		err  error
+	}{
+		{
+			name: "single-segment",
+			in:   OperatorRelease{Release: []semver.PRVersion{mustNewPRVersion("1")}},
+			out:  []byte(`"1"`),
+		},
+		{
+			name: "two-segments",
+			in:   OperatorRelease{Release: []semver.PRVersion{mustNewPRVersion("1"), mustNewPRVersion("0")}},
+			out:  []byte(`"1.0"`),
+		},
+		{
+			name: "multi-segment",
+			in: OperatorRelease{Release: []semver.PRVersion{
+				mustNewPRVersion("1"),
+				mustNewPRVersion("2"),
+				mustNewPRVersion("3"),
+			}},
+			out: []byte(`"1.2.3"`),
+		},
+		{
+			name: "numeric-segments",
+			in: OperatorRelease{Release: []semver.PRVersion{
+				mustNewPRVersion("20240101"),
+				mustNewPRVersion("12345"),
+			}},
+			out: []byte(`"20240101.12345"`),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m, err := tt.in.MarshalJSON()
+			require.Equal(t, tt.out, m, string(m))
+			require.Equal(t, tt.err, err)
+		})
+	}
+}
+
+func TestOperatorReleaseUnmarshal(t *testing.T) {
+	type TestStruct struct {
+		Release OperatorRelease `json:"r"`
+	}
+	tests := []struct {
+		name string
+		in   []byte
+		out  TestStruct
+		err  error
+	}{
+		{
+			name: "single-segment",
+			in:   []byte(`{"r": "1"}`),
+			out:  TestStruct{Release: OperatorRelease{Release: []semver.PRVersion{mustNewPRVersion("1")}}},
+		},
+		{
+			name: "two-segments",
+			in:   []byte(`{"r": "1.0"}`),
+			out:  TestStruct{Release: OperatorRelease{Release: []semver.PRVersion{mustNewPRVersion("1"), mustNewPRVersion("0")}}},
+		},
+		{
+			name: "multi-segment",
+			in:   []byte(`{"r": "1.2.3"}`),
+			out: TestStruct{Release: OperatorRelease{Release: []semver.PRVersion{
+				mustNewPRVersion("1"),
+				mustNewPRVersion("2"),
+				mustNewPRVersion("3"),
+			}}},
+		},
+		{
+			name: "numeric-segments",
+			in:   []byte(`{"r": "20240101.12345"}`),
+			out: TestStruct{Release: OperatorRelease{Release: []semver.PRVersion{
+				mustNewPRVersion("20240101"),
+				mustNewPRVersion("12345"),
+			}}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := TestStruct{}
+			err := json.Unmarshal(tt.in, &s)
+			require.Equal(t, tt.out, s)
+			require.Equal(t, tt.err, err)
+		})
+	}
+}
+
+func mustNewPRVersion(s string) semver.PRVersion {
+	v, err := semver.NewPRVersion(s)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}

pkg/operators/v1alpha1/clusterserviceversion_types.go

@@ -13,6 +13,7 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
+	"github.com/operator-framework/api/pkg/lib/release"
 	"github.com/operator-framework/api/pkg/lib/version"
 )
 
@@ -274,8 +275,10 @@ type APIServiceDefinitions struct {
 // that can manage apps for a given version.
 // +k8s:openapi-gen=true
 type ClusterServiceVersionSpec struct {
-	InstallStrategy           NamedInstallStrategy      `json:"install"`
-	Version                   version.OperatorVersion   `json:"version,omitempty"`
+	InstallStrategy NamedInstallStrategy    `json:"install"`
+	Version         version.OperatorVersion `json:"version,omitempty"`
+	// +optional
+	Release                   release.OperatorRelease   `json:"release,omitzero"`
 	Maturity                  string                    `json:"maturity,omitempty"`
 	CustomResourceDefinitions CustomResourceDefinitions `json:"customresourcedefinitions,omitempty"`
 	APIServiceDefinitions     APIServiceDefinitions     `json:"apiservicedefinitions,omitempty"`
@@ -595,6 +598,7 @@ type ResourceInstance struct {
 // +kubebuilder:subresource:status
 // +kubebuilder:printcolumn:name="Display",type=string,JSONPath=`.spec.displayName`,description="The name of the CSV"
 // +kubebuilder:printcolumn:name="Version",type=string,JSONPath=`.spec.version`,description="The version of the CSV"
+// +kubebuilder:printcolumn:name="Release",type=string,JSONPath=`.spec.release`,description="The release version of the CSV"
 // +kubebuilder:printcolumn:name="Replaces",type=string,JSONPath=`.spec.replaces`,description="The name of a CSV that this one replaces"
 // +kubebuilder:printcolumn:name="Phase",type=string,JSONPath=`.status.phase`
 

pkg/validation/internal/typecheck.go

@@ -28,7 +28,7 @@ func checkEmptyFields(result *errors.ManifestResult, v reflect.Value, parentStru
 
 		// Omitted field tags will contain ",omitempty", and ignored tags will
 		// match "-" exactly, respectively.
-		isOptionalField := strings.Contains(tag, ",omitempty") || tag == "-"
+		isOptionalField := strings.Contains(tag, ",omitempty") || strings.Contains(tag, ",omitzero") || tag == "-"
 		emptyVal := fieldValue.IsZero()
 
 		newParentStructName := fieldType.Name