feat: support for multi channel licenses

cmd/kots/cli/install.go

@@ -162,6 +162,16 @@ func InstallCmd() *cobra.Command {
 			}()
 
 			upstream := pull.RewriteUpstream(args[0])
+			preferredChannelSlug, err := extractPreferredChannelSlug(upstream)
+			if err != nil {
+				return errors.Wrap(err, "failed to extract preferred channel slug")
+			}
+
+			// If we are passed a multi-channel license, verify that the requested channel is in the license
+			// so that we can warn the user immediately if it is not.
+			if license != nil && !slugInLicenseChannels(preferredChannelSlug, license) {
+				return errors.New("requested channel not found in license")
+			}
 
 			namespace := v.GetString("namespace")
 
@@ -278,6 +288,7 @@ func InstallCmd() *cobra.Command {
 				IncludeMinio:           v.GetBool("with-minio"),
 				IncludeMinioSnapshots:  v.GetBool("with-minio"),
 				StrictSecurityContext:  v.GetBool("strict-security-context"),
+				RequestedChannelSlug:   preferredChannelSlug,
 
 				RegistryConfig: *registryConfig,
 
@@ -1076,3 +1087,12 @@ func checkPreflightResults(response *handlers.GetPreflightResultResponse, skipPr
 
 	return true, nil
 }
+
+func slugInLicenseChannels(slug string, license *kotsv1beta1.License) bool {
+	for _, channel := range license.Spec.Channels {
+		if channel.ChannelSlug == slug {
+			return true
+		}
+	}
+	return false
+}

cmd/kots/cli/pull.go

@@ -11,7 +11,6 @@ import (
 	"github.com/replicatedhq/kots/pkg/pull"
 	registrytypes "github.com/replicatedhq/kots/pkg/registry/types"
 	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
-	"github.com/replicatedhq/kotskinds/client/kotsclientset/scheme"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -43,11 +42,13 @@ func PullCmd() *cobra.Command {
 				}
 			}
 
-			appSlug, err := getAppSlugForPull(args[0], v.GetString("license-file"))
+			license, err := getLicense(v)
 			if err != nil {
-				return errors.Wrap(err, "failed to determine app slug")
+				return errors.Wrap(err, "failed to get license")
 			}
 
+			appSlug := getAppSlugForPull(args[0], license)
+
 			namespace, err := getNamespaceOrDefault(v.GetString("namespace"))
 			if err != nil {
 				return errors.Wrap(err, "failed to get namespace")
@@ -98,6 +99,17 @@ func PullCmd() *cobra.Command {
 			}
 
 			upstream := pull.RewriteUpstream(args[0])
+			preferredChannelSlug, err := extractPreferredChannelSlug(upstream)
+			if err != nil {
+				return errors.Wrap(err, "failed to extract preferred channel slug")
+			}
+
+			// If we are passed a multi-channel license, verify that the requested channel is in the license
+			// so that we can warn the user immediately if it is not.
+			if license != nil && !slugInLicenseChannels(preferredChannelSlug, license) {
+				return errors.New("requested channel not found in license")
+			}
+
 			renderDir, err := pull.Pull(upstream, pullOptions)
 			if err != nil {
 				return errors.Wrap(err, "failed to pull")
@@ -146,28 +158,10 @@ func PullCmd() *cobra.Command {
 	return cmd
 }
 
-func getAppSlugForPull(uri string, licenseFile string) (string, error) {
+func getAppSlugForPull(uri string, license *kotsv1beta1.License) string {
 	appSlug := strings.Split(uri, "/")[0]
-	if licenseFile == "" {
-		return appSlug, nil
-	}
-
-	licenseData, err := os.ReadFile(licenseFile)
-	if err != nil {
-		return "", errors.Wrap(err, "failed to read license file")
-	}
-
-	decode := scheme.Codecs.UniversalDeserializer().Decode
-	decoded, gvk, err := decode(licenseData, nil, nil)
-	if err != nil {
-		return "", errors.Wrap(err, "unable to decode license file")
+	if license == nil {
+		return appSlug
 	}
-
-	if gvk.Group != "kots.io" || gvk.Version != "v1beta1" || gvk.Kind != "License" {
-		return "", errors.New("not an application license")
-	}
-
-	license := decoded.(*kotsv1beta1.License)
-
-	return license.Spec.AppSlug, nil
+	return license.Spec.AppSlug
 }

cmd/kots/cli/util.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
+	"github.com/replicatedhq/kots/pkg/replicatedapp"
 	"github.com/replicatedhq/kots/pkg/util"
 )
 
@@ -51,3 +52,20 @@ func splitEndpointAndNamespace(endpoint string) (string, string) {
 	}
 	return registryEndpoint, registryNamespace
 }
+
+func extractPreferredChannelSlug(upstreamURI string) (string, error) {
+	u, err := url.ParseRequestURI(upstreamURI)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to parse uri")
+	}
+
+	replicatedUpstream, err := replicatedapp.ParseReplicatedURL(u)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to parse replicated url")
+	}
+
+	if replicatedUpstream.Channel != nil {
+		return *replicatedUpstream.Channel, nil
+	}
+	return "stable", nil
+}

cmd/kots/cli/util_test.go

@@ -95,3 +95,52 @@ func Test_getHostFromEndpoint(t *testing.T) {
 		})
 	}
 }
+
+func Test_extractPreferredChannelSlug(t *testing.T) {
+	type args struct {
+		upstreamURI string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			"no channel",
+			args{
+				upstreamURI: "replicated://app-slug",
+			},
+			"stable", // default channel
+			false,
+		},
+		{
+			"with channel",
+			args{
+				upstreamURI: "replicated://app-slug/channel",
+			},
+			"channel",
+			false,
+		},
+		{
+			"invalid uri",
+			args{
+				upstreamURI: "junk",
+			},
+			"",
+			true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := extractPreferredChannelSlug(tt.args.upstreamURI)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("extractPreferredChannelSlug() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("extractPreferredChannelSlug() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

go.mod

@@ -49,7 +49,7 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2
 	github.com/replicatedhq/embedded-cluster-kinds v1.4.6
-	github.com/replicatedhq/kotskinds v0.0.0-20240621084729-1eb1e3eac6f2
+	github.com/replicatedhq/kotskinds v0.0.0-20240718194123-1018dd404e95
 	github.com/replicatedhq/kurlkinds v1.5.0
 	github.com/replicatedhq/troubleshoot v0.95.1
 	github.com/replicatedhq/yaml/v3 v3.0.0-beta5-replicatedhq

go.sum

@@ -1315,6 +1315,10 @@ github.com/replicatedhq/embedded-cluster-kinds v1.4.6 h1:nP2/ANhUW1omiPp3WFm6tQW
 github.com/replicatedhq/embedded-cluster-kinds v1.4.6/go.mod h1:AwopUvvGcaWO4mn9DkbPj5RnLuOy756CNLrcaAlmjMo=
 github.com/replicatedhq/kotskinds v0.0.0-20240621084729-1eb1e3eac6f2 h1:xL4u2RHhMaGDgz7Lol5MhVYLnWahV3sCJZbfebpPao0=
 github.com/replicatedhq/kotskinds v0.0.0-20240621084729-1eb1e3eac6f2/go.mod h1:QjhIUu3+OmHZ09u09j3FCoTt8F3BYtQglS+OLmftu9I=
+github.com/replicatedhq/kotskinds v0.0.0-20240717145110-8eb39e8b3a41 h1:xvvRq5EZ7wBlsrDZIAUpJ318cEMzTpt8zVAO2atFQlM=
+github.com/replicatedhq/kotskinds v0.0.0-20240717145110-8eb39e8b3a41/go.mod h1:QjhIUu3+OmHZ09u09j3FCoTt8F3BYtQglS+OLmftu9I=
+github.com/replicatedhq/kotskinds v0.0.0-20240718194123-1018dd404e95 h1:JhwPz4Bgbz5iYl3UV2EB+HnF9oW/eCRi+hASAz+J6XI=
+github.com/replicatedhq/kotskinds v0.0.0-20240718194123-1018dd404e95/go.mod h1:QjhIUu3+OmHZ09u09j3FCoTt8F3BYtQglS+OLmftu9I=
 github.com/replicatedhq/kurlkinds v1.5.0 h1:zZ0PKNeh4kXvSzVGkn62DKTo314GxhXg1TSB3azURMc=
 github.com/replicatedhq/kurlkinds v1.5.0/go.mod h1:rUpBMdC81IhmJNCWMU/uRsMETv9P0xFoMvdSP/TAr5A=
 github.com/replicatedhq/termui/v3 v3.1.1-0.20200811145416-f40076d26851 h1:eRlNDHxGfVkPCRXbA4BfQJvt5DHjFiTtWy3R/t4djyY=

migrations/tables/app.yaml

@@ -85,3 +85,5 @@ spec:
         default: 0
         constraints:
           notNull: true
+      - name: channel_id
+        type: text

pkg/app/types/app.go

@@ -30,6 +30,7 @@ type App struct {
 	InstallState          string         `json:"installState"`
 	LastLicenseSync       string         `json:"lastLicenseSync"`
 	ChannelChanged        bool           `json:"channelChanged"`
+	ChannelID             string         `json:"channel_id"`
 }
 
 func (a *App) GetID() string {
@@ -44,6 +45,10 @@ func (a *App) GetCurrentSequence() int64 {
 	return a.CurrentSequence
 }
 
+func (a *App) GetChannelID() string {
+	return a.ChannelID
+}
+
 func (a *App) GetIsAirgap() bool {
 	return a.IsAirgap
 }

pkg/automation/automation.go

@@ -244,7 +244,12 @@ func installLicenseSecret(clientset *kubernetes.Clientset, licenseSecret corev1.
 	desiredAppName := strings.Replace(appSlug, "-", " ", 0)
 	upstreamURI := fmt.Sprintf("replicated://%s", appSlug)
 
-	a, err := store.GetStore().CreateApp(desiredAppName, upstreamURI, string(license), verifiedLicense.Spec.IsAirgapSupported, instParams.SkipImagePush, instParams.RegistryIsReadOnly)
+	matchedChannelID, err := kotsutil.FindChannelIDInLicense(instParams.RequestedChannelSlug, verifiedLicense)
+	if err != nil {
+		return errors.Wrap(err, "failed to find requested channel in license")
+	}
+
+	a, err := store.GetStore().CreateApp(desiredAppName, matchedChannelID, upstreamURI, string(license), verifiedLicense.Spec.IsAirgapSupported, instParams.SkipImagePush, instParams.RegistryIsReadOnly)
 	if err != nil {
 		return errors.Wrap(err, "failed to create app record")
 	}

pkg/handlers/license.go

@@ -334,7 +334,16 @@ func (h *Handler) UploadNewLicense(w http.ResponseWriter, r *http.Request) {
 	desiredAppName := strings.Replace(verifiedLicense.Spec.AppSlug, "-", " ", 0)
 	upstreamURI := fmt.Sprintf("replicated://%s", verifiedLicense.Spec.AppSlug)
 
-	a, err := store.GetStore().CreateApp(desiredAppName, upstreamURI, licenseString, verifiedLicense.Spec.IsAirgapSupported, installationParams.SkipImagePush, installationParams.RegistryIsReadOnly)
+	// verify that requested channel slug exists in the license
+	matchedChannelID, err := kotsutil.FindChannelIDInLicense(installationParams.RequestedChannelSlug, verifiedLicense)
+	if err != nil {
+		logger.Error(err)
+		uploadLicenseResponse.Error = "Requested install channel not found in license"
+		JSON(w, http.StatusBadRequest, uploadLicenseResponse)
+		return
+	}
+
+	a, err := store.GetStore().CreateApp(desiredAppName, matchedChannelID, upstreamURI, licenseString, verifiedLicense.Spec.IsAirgapSupported, installationParams.SkipImagePush, installationParams.RegistryIsReadOnly)
 	if err != nil {
 		logger.Error(err)
 		uploadLicenseResponse.Error = err.Error()

pkg/handlers/update_checker_spec.go

@@ -11,6 +11,7 @@ import (
 	"github.com/replicatedhq/kots/pkg/logger"
 	"github.com/replicatedhq/kots/pkg/store"
 	"github.com/replicatedhq/kots/pkg/updatechecker"
+	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
 	cron "github.com/robfig/cron/v3"
 )
 
@@ -56,8 +57,27 @@ func (h *Handler) SetAutomaticUpdatesConfig(w http.ResponseWriter, r *http.Reque
 		return
 	}
 
+	var licenseChan *kotsv1beta1.Channel
+	if foundApp.ChannelID == "" {
+		backfillID := kotsutil.GetBackfillChannelIDFromLicense(license)
+		if err := store.GetStore().SetAppChannelID(foundApp.ID, backfillID); err != nil {
+			updateCheckerSpecResponse.Error = "failed to backfill app channel id from license"
+			logger.Error(errors.Wrap(err, updateCheckerSpecResponse.Error))
+			JSON(w, http.StatusInternalServerError, updateCheckerSpecResponse)
+			return
+		}
+		foundApp.ChannelID = backfillID
+	}
+
+	if licenseChan, err = kotsutil.FindChannelInLicense(foundApp.ChannelID, license); err != nil {
+		updateCheckerSpecResponse.Error = "failed to find channel in license"
+		logger.Error(errors.Wrap(err, updateCheckerSpecResponse.Error))
+		JSON(w, http.StatusInternalServerError, updateCheckerSpecResponse)
+		return
+	}
+
 	// Check if the deploy update configuration is valid based on app channel
-	if license.Spec.IsSemverRequired {
+	if licenseChan.IsSemverRequired {
 		if configureAutomaticUpdatesRequest.AutoDeploy == apptypes.AutoDeploySequence {
 			updateCheckerSpecResponse.Error = "automatic updates based on sequence type are not supported for semantic versioning apps"
 			JSON(w, http.StatusUnprocessableEntity, updateCheckerSpecResponse)

pkg/handlers/upgrade_service.go

@@ -118,7 +118,10 @@ func canStartUpgradeService(a *apptypes.App, r StartUpgradeServiceRequest) (bool
 		if err != nil {
 			return false, "", errors.Wrap(err, "failed to find airgap metadata")
 		}
-		if currLicense.Spec.ChannelID != airgap.Spec.ChannelID || r.ChannelID != airgap.Spec.ChannelID {
+		if _, err := kotsutil.FindChannelInLicense(airgap.Spec.ChannelID, currLicense); err != nil {
+			return false, "channel mismatch, channel not in license", nil
+		}
+		if r.ChannelID != airgap.Spec.ChannelID {
 			return false, "channel mismatch", nil
 		}
 		isDeployable, nonDeployableCause, err := update.IsAirgapUpdateDeployable(a, airgap)

pkg/kotsadm/objects/configmaps_objects.go

@@ -25,7 +25,9 @@ func KotsadmConfigMap(deployOptions types.DeployOptions) *corev1.ConfigMap {
 		"wait-duration":             fmt.Sprintf("%v", deployOptions.Timeout),
 		"with-minio":                fmt.Sprintf("%v", deployOptions.IncludeMinio),
 		"app-version-label":         deployOptions.AppVersionLabel,
+		"requested-channel-slug":    deployOptions.RequestedChannelSlug,
 	}
+
 	if kotsadmversion.KotsadmPullSecret(deployOptions.Namespace, deployOptions.RegistryConfig) != nil {
 		data["kotsadm-registry"] = kotsadmversion.KotsadmRegistry(deployOptions.RegistryConfig)
 	}

pkg/kotsadm/types/deployoptions.go

@@ -56,6 +56,7 @@ type DeployOptions struct {
 	IsMinimalRBAC          bool
 	AdditionalNamespaces   []string
 	IsGKEAutopilot         bool
+	RequestedChannelSlug   string
 
 	IdentityConfig kotsv1beta1.IdentityConfig
 	IngressConfig  kotsv1beta1.IngressConfig