Handle channelName

.gitignore

@@ -30,6 +30,8 @@ install.sh
 *.swp
 *.swo
 *~
+\#*\#
+.\#*
 
 # TODO dfranz remove this line and the bin folder when tools binaries are moved to their own folder
 !bin/.dockerignore

api/v1alpha1/operator_types.go

@@ -39,7 +39,7 @@ type OperatorSpec struct {
 	Version string `json:"version,omitempty"`
 
 	//+kubebuilder:validation:MaxLength:=48
-	//+kubebuilder:validation:Pattern:=^[a-z0-9]+(-[a-z0-9]+)*$
+	//+kubebuilder:validation:Pattern:=^[a-z0-9]+([\.-][a-z0-9]+)*$
 	// Channel constraint defintion
 	Channel string `json:"channel,omitempty"`
 }

config/crd/bases/operators.operatorframework.io_operators.yaml

@@ -38,7 +38,7 @@ spec:
               channel:
                 description: Channel constraint defintion
                 maxLength: 48
-                pattern: ^[a-z0-9]+(-[a-z0-9]+)*$
+                pattern: ^[a-z0-9]+([\.-][a-z0-9]+)*$
                 type: string
               packageName:
                 maxLength: 48

controllers/admission_test.go

@@ -72,4 +72,49 @@ var _ = Describe("Operator Spec Validations", func() {
 			Expect(err.Error()).To(ContainSubstring("spec.version in body should match '^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(-(0|[1-9]\\d*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(\\.(0|[1-9]\\d*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\\+([0-9a-zA-Z-]+(\\.[0-9a-zA-Z-]+)*))?$'"))
 		}
 	})
+	It("should fail if an invalid channel name is given", func() {
+		invalidChannels := []string{
+			"spaces spaces",
+			"Capitalized",
+			"camelCase",
+			"many/invalid$characters+in_name",
+			"-start-with-hyphen",
+			"end-with-hyphen-",
+			".start-with-period",
+			"end-with-period.",
+		}
+		for _, invalidChannel := range invalidChannels {
+			err := cl.Create(ctx, operator(operatorsv1alpha1.OperatorSpec{
+				PackageName: "package",
+				Channel:     invalidChannel,
+			}))
+			Expect(err).To(HaveOccurred(), "expected error for invalid channel '%q'", invalidChannel)
+			Expect(err.Error()).To(ContainSubstring("spec.channel in body should match '^[a-z0-9]+([\\.-][a-z0-9]+)*$'"))
+		}
+	})
+	It("should pass if a valid channel name is given", func() {
+		validChannels := []string{
+			"hyphenated-name",
+			"dotted.name",
+			"channel-has-version-1.0.1",
+		}
+		for _, validChannel := range validChannels {
+			op := operator(operatorsv1alpha1.OperatorSpec{
+				PackageName: "package",
+				Channel:     validChannel,
+			})
+			err := cl.Create(ctx, op)
+			Expect(err).NotTo(HaveOccurred(), "unexpected error creating valid channel '%q': %w", validChannel, err)
+			err = cl.Delete(ctx, op)
+			Expect(err).NotTo(HaveOccurred(), "unexpected error deleting valid channel '%q': %w", validChannel, err)
+		}
+	})
+	It("should fail if an invalid channel name length", func() {
+		err := cl.Create(ctx, operator(operatorsv1alpha1.OperatorSpec{
+			PackageName: "package",
+			Channel:     "longname01234567890123456789012345678901234567890",
+		}))
+		Expect(err).To(HaveOccurred(), "expected error for invalid channel length")
+		Expect(err.Error()).To(ContainSubstring("spec.channel: Too long: may not be longer than 48"))
+	})
 })

controllers/operator_controller_test.go

@@ -85,7 +85,7 @@ var _ = Describe("Operator Controller Test", func() {
 			var pkgName string
 			BeforeEach(func() {
 				By("initializing cluster state")
-				pkgName = fmt.Sprintf("exists-%s", rand.String(6))
+				pkgName = "prometheus"
 				operator = &operatorsv1alpha1.Operator{
 					ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
 					Spec: operatorsv1alpha1.OperatorSpec{
@@ -594,6 +594,205 @@ var _ = Describe("Operator Controller Test", func() {
 			})
 
 		})
+		When("the operator specifies a channel with version that exist", func() {
+			var pkgName string
+			var pkgVer string
+			var pkgChan string
+			BeforeEach(func() {
+				By("initializing cluster state")
+				pkgName = "prometheus"
+				pkgVer = "0.47.0"
+				pkgChan = "beta"
+				operator = &operatorsv1alpha1.Operator{
+					ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
+					Spec: operatorsv1alpha1.OperatorSpec{
+						PackageName: pkgName,
+						Version:     pkgVer,
+						Channel:     pkgChan,
+					},
+				}
+				err := cl.Create(ctx, operator)
+				Expect(err).NotTo(HaveOccurred())
+			})
+			It("sets resolution success status", func() {
+				By("running reconcile")
+				res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: opKey})
+				Expect(res).To(Equal(ctrl.Result{}))
+				Expect(err).NotTo(HaveOccurred())
+
+				By("fetching updated operator after reconcile")
+				Expect(cl.Get(ctx, opKey, operator)).NotTo(HaveOccurred())
+
+				By("checking the expected conditions")
+				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorsv1alpha1.TypeReady)
+				Expect(cond).NotTo(BeNil())
+				Expect(cond.Status).To(Equal(metav1.ConditionUnknown))
+				Expect(cond.Reason).To(Equal(operatorsv1alpha1.ReasonInstallationStatusUnknown))
+				Expect(cond.Message).To(ContainSubstring("waiting for BundleDeployment"))
+
+				By("fetching the bundled deployment")
+				bd := &rukpakv1alpha1.BundleDeployment{}
+				Expect(cl.Get(ctx, types.NamespacedName{Name: opKey.Name}, bd)).NotTo(HaveOccurred())
+				Expect(bd.Spec.ProvisionerClassName).To(Equal("core-rukpak-io-plain"))
+				Expect(bd.Spec.Template.Spec.ProvisionerClassName).To(Equal("core-rukpak-io-registry"))
+				Expect(bd.Spec.Template.Spec.Source.Type).To(Equal(rukpakv1alpha1.SourceTypeImage))
+				Expect(bd.Spec.Template.Spec.Source.Image).NotTo(BeNil())
+				Expect(bd.Spec.Template.Spec.Source.Image.Ref).To(Equal("quay.io/operatorhubio/prometheus@sha256:5b04c49d8d3eff6a338b56ec90bdf491d501fe301c9cdfb740e5bff6769a21ed"))
+			})
+		})
+		When("the operator specifies a package that exists within a channel but no version specified", func() {
+			var pkgName string
+			var pkgVer string
+			var pkgChan string
+			BeforeEach(func() {
+				By("initializing cluster state")
+				pkgName = "prometheus"
+				pkgChan = "beta"
+				operator = &operatorsv1alpha1.Operator{
+					ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
+					Spec: operatorsv1alpha1.OperatorSpec{
+						PackageName: pkgName,
+						Version:     pkgVer,
+						Channel:     pkgChan,
+					},
+				}
+				err := cl.Create(ctx, operator)
+				Expect(err).NotTo(HaveOccurred())
+			})
+			It("sets resolution success status", func() {
+				By("running reconcile")
+				res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: opKey})
+				Expect(res).To(Equal(ctrl.Result{}))
+				Expect(err).NotTo(HaveOccurred())
+
+				By("fetching updated operator after reconcile")
+				Expect(cl.Get(ctx, opKey, operator)).NotTo(HaveOccurred())
+
+				By("checking the expected conditions")
+				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorsv1alpha1.TypeReady)
+				Expect(cond).NotTo(BeNil())
+				Expect(cond.Status).To(Equal(metav1.ConditionUnknown))
+				Expect(cond.Reason).To(Equal(operatorsv1alpha1.ReasonInstallationStatusUnknown))
+				Expect(cond.Message).To(ContainSubstring("waiting for BundleDeployment"))
+
+				By("fetching the bundled deployment")
+				bd := &rukpakv1alpha1.BundleDeployment{}
+				Expect(cl.Get(ctx, types.NamespacedName{Name: opKey.Name}, bd)).NotTo(HaveOccurred())
+				Expect(bd.Spec.ProvisionerClassName).To(Equal("core-rukpak-io-plain"))
+				Expect(bd.Spec.Template.Spec.ProvisionerClassName).To(Equal("core-rukpak-io-registry"))
+				Expect(bd.Spec.Template.Spec.Source.Type).To(Equal(rukpakv1alpha1.SourceTypeImage))
+				Expect(bd.Spec.Template.Spec.Source.Image).NotTo(BeNil())
+				Expect(bd.Spec.Template.Spec.Source.Image.Ref).To(Equal("quay.io/operatorhubio/prometheus@sha256:5b04c49d8d3eff6a338b56ec90bdf491d501fe301c9cdfb740e5bff6769a21ed"))
+			})
+		})
+		When("the operator specifies a package version in a channel that does not exist", func() {
+			var pkgName string
+			var pkgVer string
+			var pkgChan string
+			BeforeEach(func() {
+				By("initializing cluster state")
+				pkgName = "prometheus"
+				pkgVer = "0.47.0"
+				pkgChan = "alpha"
+				operator = &operatorsv1alpha1.Operator{
+					ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
+					Spec: operatorsv1alpha1.OperatorSpec{
+						PackageName: pkgName,
+						Version:     pkgVer,
+						Channel:     pkgChan,
+					},
+				}
+				err := cl.Create(ctx, operator)
+				Expect(err).NotTo(HaveOccurred())
+			})
+			It("sets resolution failure status", func() {
+				By("running reconcile")
+				res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: opKey})
+				Expect(res).To(Equal(ctrl.Result{}))
+				Expect(err).To(MatchError(fmt.Sprintf("package '%s' at version '%s' in channel '%s' not found", pkgName, pkgVer, pkgChan)))
+
+				By("fetching updated operator after reconcile")
+				Expect(cl.Get(ctx, opKey, operator)).NotTo(HaveOccurred())
+
+				By("checking the expected conditions")
+				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorsv1alpha1.TypeReady)
+				Expect(cond).NotTo(BeNil())
+				Expect(cond.Status).To(Equal(metav1.ConditionFalse))
+				Expect(cond.Reason).To(Equal(operatorsv1alpha1.ReasonResolutionFailed))
+				Expect(cond.Message).To(Equal(fmt.Sprintf("package '%s' at version '%s' in channel '%s' not found", pkgName, pkgVer, pkgChan)))
+			})
+		})
+		When("the operator specifies a package in a channel that does not exist", func() {
+			var pkgName string
+			var pkgChan string
+			BeforeEach(func() {
+				By("initializing cluster state")
+				pkgName = "prometheus"
+				pkgChan = "alpha"
+				operator = &operatorsv1alpha1.Operator{
+					ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
+					Spec: operatorsv1alpha1.OperatorSpec{
+						PackageName: pkgName,
+						Channel:     pkgChan,
+					},
+				}
+				err := cl.Create(ctx, operator)
+				Expect(err).NotTo(HaveOccurred())
+			})
+			It("sets resolution failure status", func() {
+				By("running reconcile")
+				res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: opKey})
+				Expect(res).To(Equal(ctrl.Result{}))
+				Expect(err).To(MatchError(fmt.Sprintf("package '%s' in channel '%s' not found", pkgName, pkgChan)))
+
+				By("fetching updated operator after reconcile")
+				Expect(cl.Get(ctx, opKey, operator)).NotTo(HaveOccurred())
+
+				By("checking the expected conditions")
+				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorsv1alpha1.TypeReady)
+				Expect(cond).NotTo(BeNil())
+				Expect(cond.Status).To(Equal(metav1.ConditionFalse))
+				Expect(cond.Reason).To(Equal(operatorsv1alpha1.ReasonResolutionFailed))
+				Expect(cond.Message).To(Equal(fmt.Sprintf("package '%s' in channel '%s' not found", pkgName, pkgChan)))
+			})
+		})
+		When("the operator specifies a package version that does not exist in the channel", func() {
+			var pkgName string
+			var pkgVer string
+			var pkgChan string
+			BeforeEach(func() {
+				By("initializing cluster state")
+				pkgName = "prometheus"
+				pkgVer = "0.57.0"
+				pkgChan = "beta"
+				operator = &operatorsv1alpha1.Operator{
+					ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
+					Spec: operatorsv1alpha1.OperatorSpec{
+						PackageName: pkgName,
+						Version:     pkgVer,
+						Channel:     pkgChan,
+					},
+				}
+				err := cl.Create(ctx, operator)
+				Expect(err).NotTo(HaveOccurred())
+			})
+			It("sets resolution failure status", func() {
+				By("running reconcile")
+				res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: opKey})
+				Expect(res).To(Equal(ctrl.Result{}))
+				Expect(err).To(MatchError(fmt.Sprintf("package '%s' at version '%s' in channel '%s' not found", pkgName, pkgVer, pkgChan)))
+
+				By("fetching updated operator after reconcile")
+				Expect(cl.Get(ctx, opKey, operator)).NotTo(HaveOccurred())
+
+				By("checking the expected conditions")
+				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorsv1alpha1.TypeReady)
+				Expect(cond).NotTo(BeNil())
+				Expect(cond.Status).To(Equal(metav1.ConditionFalse))
+				Expect(cond.Reason).To(Equal(operatorsv1alpha1.ReasonResolutionFailed))
+				Expect(cond.Message).To(Equal(fmt.Sprintf("package '%s' at version '%s' in channel '%s' not found", pkgName, pkgVer, pkgChan)))
+			})
+		})
 		AfterEach(func() {
 			verifyInvariants(ctx, operator)
 

internal/resolution/variable_sources/olm/olm.go

@@ -46,5 +46,8 @@ func (o *OLMVariableSource) requiredPackageFromOperator(operator *operatorsv1alp
 	if operator.Spec.Version != "" {
 		opts = append(opts, required_package.InVersionRange(operator.Spec.Version))
 	}
+	if operator.Spec.Channel != "" {
+		opts = append(opts, required_package.InChannel(operator.Spec.Channel))
+	}
 	return required_package.NewRequiredPackage(operator.Spec.PackageName, opts...)
 }

internal/resolution/variable_sources/required_package/required_package.go

@@ -54,9 +54,20 @@ func InVersionRange(versionRange string) RequiredPackageOption {
 	}
 }
 
+func InChannel(channelName string) RequiredPackageOption {
+	return func(r *RequiredPackageVariableSource) error {
+		if channelName != "" {
+			r.channelName = channelName
+			r.predicates = append(r.predicates, predicates.InChannel(channelName))
+		}
+		return nil
+	}
+}
+
 type RequiredPackageVariableSource struct {
 	packageName  string
 	versionRange string
+	channelName  string
 	predicates   []input.Predicate
 }
 
@@ -99,8 +110,14 @@ func (r *RequiredPackageVariableSource) notFoundError() error {
 	//  context: we originally wanted to support version ranges and take the highest version that satisfies the range
 	//  during the upstream call on the 2023-04-11 we decided to pin the version instead. But, we'll keep version range
 	//  support under the covers in case we decide to pivot back.
+	if r.versionRange != "" && r.channelName != "" {
+		return fmt.Errorf("package '%s' at version '%s' in channel '%s' not found", r.packageName, r.versionRange, r.channelName)
+	}
 	if r.versionRange != "" {
 		return fmt.Errorf("package '%s' at version '%s' not found", r.packageName, r.versionRange)
 	}
+	if r.channelName != "" {
+		return fmt.Errorf("package '%s' in channel '%s' not found", r.packageName, r.channelName)
+	}
 	return fmt.Errorf("package '%s' not found", r.packageName)
 }