Support v1beta2 licenses

api/controllers/app/controller.go

@@ -15,12 +15,12 @@ import (
 	"github.com/replicatedhq/embedded-cluster/api/pkg/logger"
 	"github.com/replicatedhq/embedded-cluster/api/types"
 	"github.com/replicatedhq/embedded-cluster/pkg/helm"
+	"github.com/replicatedhq/embedded-cluster/pkg/helpers"
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
-	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	"github.com/sirupsen/logrus"
 	helmcli "helm.sh/helm/v3/pkg/cli"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	kyaml "sigs.k8s.io/yaml"
 )
 
 type Controller interface {
@@ -176,10 +176,11 @@ func NewAppController(opts ...AppControllerOption) (*AppController, error) {
 		return nil, err
 	}
 
-	var license *kotsv1beta1.License
+	var license licensewrapper.LicenseWrapper
 	if len(controller.license) > 0 {
-		license = &kotsv1beta1.License{}
-		if err := kyaml.Unmarshal(controller.license, license); err != nil {
+		var err error
+		license, err = helpers.ParseLicenseFromBytes(controller.license)
+		if err != nil {
 			return nil, fmt.Errorf("parse license: %w", err)
 		}
 	}

api/controllers/linux/install/controller_test.go

@@ -1169,7 +1169,7 @@ func TestSetupInfra(t *testing.T) {
 				appcontroller.WithStateMachine(sm),
 				appcontroller.WithStore(mockStore),
 				appcontroller.WithReleaseData(getTestReleaseData(&appConfig)),
-				appcontroller.WithLicense([]byte("spec:\n  licenseID: test-license\n")),
+				appcontroller.WithLicense([]byte("apiVersion: kots.io/v1beta1\nkind: License\nspec:\n  licenseID: test-license\n")),
 				appcontroller.WithAppConfigManager(mockAppConfigManager),
 				appcontroller.WithAppPreflightManager(mockAppPreflightManager),
 				appcontroller.WithAppReleaseManager(mockAppReleaseManager),
@@ -1187,7 +1187,7 @@ func TestSetupInfra(t *testing.T) {
 				WithAllowIgnoreHostPreflights(tt.serverAllowIgnoreHostPreflights),
 				WithMetricsReporter(mockMetricsReporter),
 				WithReleaseData(getTestReleaseData(&appConfig)),
-				WithLicense([]byte("spec:\n  licenseID: test-license\n")),
+				WithLicense([]byte("apiVersion: kots.io/v1beta1\nkind: License\nspec:\n  licenseID: test-license\n")),
 				WithStore(mockStore),
 				WithHelmClient(&helm.MockClient{}),
 			)

api/integration/app/install/config_test.go

@@ -1051,7 +1051,7 @@ func TestAppInstallSuite(t *testing.T) {
 					linuxinstall.WithStateMachine(linuxinstall.NewStateMachine(linuxinstall.WithCurrentState(initialState))),
 					linuxinstall.WithReleaseData(rd),
 					linuxinstall.WithHelmClient(&helm.MockClient{}),
-					linuxinstall.WithLicense([]byte("spec:\n  licenseID: test-license\n")),
+					linuxinstall.WithLicense([]byte("apiVersion: kots.io/v1beta1\nkind: License\nspec:\n  licenseID: test-license\n")),
 					linuxinstall.WithConfigValues(configValues),
 				)
 				require.NoError(t, err)
@@ -1072,7 +1072,7 @@ func TestAppInstallSuite(t *testing.T) {
 					kubernetesinstall.WithStateMachine(kubernetesinstall.NewStateMachine(kubernetesinstall.WithCurrentState(initialState))),
 					kubernetesinstall.WithReleaseData(rd),
 					kubernetesinstall.WithHelmClient(&helm.MockClient{}),
-					kubernetesinstall.WithLicense([]byte("spec:\n  licenseID: test-license\n")),
+					kubernetesinstall.WithLicense([]byte("apiVersion: kots.io/v1beta1\nkind: License\nspec:\n  licenseID: test-license\n")),
 					kubernetesinstall.WithConfigValues(configValues),
 					kubernetesinstall.WithKubernetesEnvSettings(helmcli.New()),
 				)

api/internal/managers/app/config/manager.go

@@ -7,6 +7,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/api/types"
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	"github.com/sirupsen/logrus"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -33,7 +34,7 @@ type appConfigManager struct {
 	rawConfig                  kotsv1beta1.Config
 	appConfigStore             configstore.Store
 	releaseData                *release.ReleaseData
-	license                    *kotsv1beta1.License
+	license                    licensewrapper.LicenseWrapper
 	isAirgap                   bool
 	privateCACertConfigMapName string
 	kcli                       client.Client
@@ -62,7 +63,7 @@ func WithReleaseData(releaseData *release.ReleaseData) AppConfigManagerOption {
 	}
 }
 
-func WithLicense(license *kotsv1beta1.License) AppConfigManagerOption {
+func WithLicense(license licensewrapper.LicenseWrapper) AppConfigManagerOption {
 	return func(c *appConfigManager) {
 		c.license = license
 	}

api/internal/managers/app/install/install.go

@@ -12,6 +12,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/netutils"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
 	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	kyaml "sigs.k8s.io/yaml"
 )
 
@@ -44,8 +45,8 @@ func (m *appInstallManager) Install(ctx context.Context, configValues kotsv1beta
 }
 
 func (m *appInstallManager) install(ctx context.Context, configValues kotsv1beta1.ConfigValues) error {
-	license := &kotsv1beta1.License{}
-	if err := kyaml.Unmarshal(m.license, license); err != nil {
+	licenseWrapper, err := licensewrapper.LoadLicenseFromBytes(m.license)
+	if err != nil {
 		return fmt.Errorf("parse license: %w", err)
 	}
 
@@ -61,7 +62,7 @@ func (m *appInstallManager) install(ctx context.Context, configValues kotsv1beta
 	ecDomains := utils.GetDomains(m.releaseData)
 
 	installOpts := kotscli.InstallOptions{
-		AppSlug:      license.Spec.AppSlug,
+		AppSlug:      licenseWrapper.GetAppSlug(),
 		License:      m.license,
 		Namespace:    kotsadmNamespace,
 		ClusterID:    m.clusterID,

api/internal/managers/app/install/install_test.go

@@ -26,14 +26,13 @@ func TestAppInstallManager_Install(t *testing.T) {
 	// Setup environment variable for V3
 	t.Setenv("ENABLE_V3", "1")
 
-	// Create test license
-	license := &kotsv1beta1.License{
-		Spec: kotsv1beta1.LicenseSpec{
-			AppSlug: "test-app",
-		},
-	}
-	licenseBytes, err := kyaml.Marshal(license)
-	require.NoError(t, err)
+	// Create test license with proper Kubernetes resource format
+	licenseYAML := `apiVersion: kots.io/v1beta1
+kind: License
+spec:
+  appSlug: test-app
+`
+	licenseBytes := []byte(licenseYAML)
 
 	// Create test release data
 	releaseData := &release.ReleaseData{
@@ -45,7 +44,7 @@ func TestAppInstallManager_Install(t *testing.T) {
 	}
 
 	// Set up release data globally so AppSlug() returns the correct value for v3
-	err = release.SetReleaseDataForTests(map[string][]byte{
+	err := release.SetReleaseDataForTests(map[string][]byte{
 		"channelrelease.yaml": []byte("# channel release object\nappSlug: test-app"),
 	})
 	require.NoError(t, err)

api/internal/managers/app/release/manager.go

@@ -11,6 +11,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/helm"
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
 	"github.com/sirupsen/logrus"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -24,7 +25,7 @@ type AppReleaseManager interface {
 type appReleaseManager struct {
 	rawConfig                  kotsv1beta1.Config
 	releaseData                *release.ReleaseData
-	license                    *kotsv1beta1.License
+	license                    licensewrapper.LicenseWrapper
 	isAirgap                   bool
 	privateCACertConfigMapName string
 	kcli                       client.Client
@@ -60,7 +61,7 @@ func WithHelmClient(hcli helm.Client) AppReleaseManagerOption {
 	}
 }
 
-func WithLicense(license *kotsv1beta1.License) AppReleaseManagerOption {
+func WithLicense(license licensewrapper.LicenseWrapper) AppReleaseManagerOption {
 	return func(m *appReleaseManager) {
 		m.license = license
 	}

api/internal/managers/kubernetes/infra/install.go

@@ -12,13 +12,13 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/addons"
 	addontypes "github.com/replicatedhq/embedded-cluster/pkg/addons/types"
 	"github.com/replicatedhq/embedded-cluster/pkg/helm"
+	"github.com/replicatedhq/embedded-cluster/pkg/helpers"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
 	"github.com/replicatedhq/embedded-cluster/pkg/support"
-	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	"github.com/sirupsen/logrus"
 	"k8s.io/client-go/metadata"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	kyaml "sigs.k8s.io/yaml"
 )
 
 func (m *infraManager) Install(ctx context.Context, ki kubernetesinstallation.Installation) (finalErr error) {
@@ -67,16 +67,16 @@ func (m *infraManager) initInstallComponentsList() error {
 }
 
 func (m *infraManager) install(ctx context.Context, ki kubernetesinstallation.Installation) error {
-	license := &kotsv1beta1.License{}
-	if err := kyaml.Unmarshal(m.license, license); err != nil {
+	license, err := helpers.ParseLicenseFromBytes(m.license)
+	if err != nil {
 		return fmt.Errorf("parse license: %w", err)
 	}
 
 	if err := m.initInstallComponentsList(); err != nil {
 		return fmt.Errorf("init components: %w", err)
 	}
 
-	_, err := m.recordInstallation(ctx, m.kcli, license, ki)
+	_, err = m.recordInstallation(ctx, m.kcli, license, ki)
 	if err != nil {
 		return fmt.Errorf("record installation: %w", err)
 	}
@@ -97,13 +97,13 @@ func (m *infraManager) install(ctx context.Context, ki kubernetesinstallation.In
 	return nil
 }
 
-func (m *infraManager) recordInstallation(ctx context.Context, kcli client.Client, license *kotsv1beta1.License, ki kubernetesinstallation.Installation) (*ecv1beta1.Installation, error) {
+func (m *infraManager) recordInstallation(ctx context.Context, kcli client.Client, license licensewrapper.LicenseWrapper, ki kubernetesinstallation.Installation) (*ecv1beta1.Installation, error) {
 	// TODO: we may need this later
 
 	return nil, nil
 }
 
-func (m *infraManager) installAddOns(ctx context.Context, kcli client.Client, mcli metadata.Interface, hcli helm.Client, license *kotsv1beta1.License, ki kubernetesinstallation.Installation) error {
+func (m *infraManager) installAddOns(ctx context.Context, kcli client.Client, mcli metadata.Interface, hcli helm.Client, license licensewrapper.LicenseWrapper, ki kubernetesinstallation.Installation) error {
 	progressChan := make(chan addontypes.AddOnProgress)
 	defer close(progressChan)
 
@@ -148,7 +148,7 @@ func (m *infraManager) installAddOns(ctx context.Context, kcli client.Client, mc
 	return nil
 }
 
-func (m *infraManager) getAddonInstallOpts(ctx context.Context, license *kotsv1beta1.License, ki kubernetesinstallation.Installation) (addons.KubernetesInstallOptions, error) {
+func (m *infraManager) getAddonInstallOpts(ctx context.Context, license licensewrapper.LicenseWrapper, ki kubernetesinstallation.Installation) (addons.KubernetesInstallOptions, error) {
 	// TODO: We should not use the runtimeconfig package for kubernetes target installs. Since runtimeconfig.KotsadmNamespace is
 	// target agnostic, we should move it to a package that can be used by both linux/kubernetes targets.
 	kotsadmNamespace, err := runtimeconfig.KotsadmNamespace(ctx, m.kcli)
@@ -163,7 +163,7 @@ func (m *infraManager) getAddonInstallOpts(ctx context.Context, license *kotsv1b
 		TLSCertBytes:       m.tlsConfig.CertBytes,
 		TLSKeyBytes:        m.tlsConfig.KeyBytes,
 		Hostname:           m.tlsConfig.Hostname,
-		IsMultiNodeEnabled: license.Spec.IsEmbeddedClusterMultiNodeEnabled,
+		IsMultiNodeEnabled: license.IsEmbeddedClusterMultiNodeEnabled(),
 		EmbeddedConfigSpec: m.getECConfigSpec(),
 		EndUserConfigSpec:  m.getEndUserConfigSpec(),
 		KotsadmNamespace:   kotsadmNamespace,

api/internal/managers/linux/infra/install.go

@@ -15,16 +15,16 @@ import (
 	addontypes "github.com/replicatedhq/embedded-cluster/pkg/addons/types"
 	"github.com/replicatedhq/embedded-cluster/pkg/extensions"
 	"github.com/replicatedhq/embedded-cluster/pkg/helm"
+	"github.com/replicatedhq/embedded-cluster/pkg/helpers"
 	"github.com/replicatedhq/embedded-cluster/pkg/kubeutils"
 	"github.com/replicatedhq/embedded-cluster/pkg/netutils"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
 	"github.com/replicatedhq/embedded-cluster/pkg/support"
-	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	"github.com/sirupsen/logrus"
 	"k8s.io/client-go/metadata"
 	nodeutil "k8s.io/component-helpers/node/util"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	kyaml "sigs.k8s.io/yaml"
 )
 
 const K0sComponentName = "Runtime"
@@ -72,10 +72,10 @@ func (m *infraManager) Install(ctx context.Context, rc runtimeconfig.RuntimeConf
 	return nil
 }
 
-func (m *infraManager) initInstallComponentsList(license *kotsv1beta1.License) error {
+func (m *infraManager) initInstallComponentsList(license licensewrapper.LicenseWrapper) error {
 	components := []types.InfraComponent{{Name: K0sComponentName}}
 
-	addOnsNames := addons.GetAddOnsNamesForInstall(m.airgapBundle != "", license.Spec.IsDisasterRecoverySupported)
+	addOnsNames := addons.GetAddOnsNamesForInstall(m.airgapBundle != "", license.IsDisasterRecoverySupported())
 	for _, addOnName := range addOnsNames {
 		components = append(components, types.InfraComponent{Name: addOnName})
 	}
@@ -91,16 +91,16 @@ func (m *infraManager) initInstallComponentsList(license *kotsv1beta1.License) e
 }
 
 func (m *infraManager) install(ctx context.Context, rc runtimeconfig.RuntimeConfig) error {
-	license := &kotsv1beta1.License{}
-	if err := kyaml.Unmarshal(m.license, license); err != nil {
+	license, err := helpers.ParseLicenseFromBytes(m.license)
+	if err != nil {
 		return fmt.Errorf("parse license: %w", err)
 	}
 
 	if err := m.initInstallComponentsList(license); err != nil {
 		return fmt.Errorf("init components: %w", err)
 	}
 
-	_, err := m.installK0s(ctx, rc)
+	_, err = m.installK0s(ctx, rc)
 	if err != nil {
 		return fmt.Errorf("install k0s: %w", err)
 	}
@@ -210,7 +210,7 @@ func (m *infraManager) installK0s(ctx context.Context, rc runtimeconfig.RuntimeC
 	return k0sCfg, nil
 }
 
-func (m *infraManager) recordInstallation(ctx context.Context, kcli client.Client, license *kotsv1beta1.License, rc runtimeconfig.RuntimeConfig) (*ecv1beta1.Installation, error) {
+func (m *infraManager) recordInstallation(ctx context.Context, kcli client.Client, license licensewrapper.LicenseWrapper, rc runtimeconfig.RuntimeConfig) (*ecv1beta1.Installation, error) {
 	logFn := m.logFn("metadata")
 
 	// get the configured custom domains
@@ -246,7 +246,7 @@ func (m *infraManager) recordInstallation(ctx context.Context, kcli client.Clien
 	return in, nil
 }
 
-func (m *infraManager) installAddOns(ctx context.Context, kcli client.Client, mcli metadata.Interface, hcli helm.Client, license *kotsv1beta1.License, rc runtimeconfig.RuntimeConfig) error {
+func (m *infraManager) installAddOns(ctx context.Context, kcli client.Client, mcli metadata.Interface, hcli helm.Client, license licensewrapper.LicenseWrapper, rc runtimeconfig.RuntimeConfig) error {
 	progressChan := make(chan addontypes.AddOnProgress)
 	defer close(progressChan)
 
@@ -291,7 +291,7 @@ func (m *infraManager) installAddOns(ctx context.Context, kcli client.Client, mc
 	return nil
 }
 
-func (m *infraManager) getAddonInstallOpts(ctx context.Context, license *kotsv1beta1.License, rc runtimeconfig.RuntimeConfig) (addons.InstallOptions, error) {
+func (m *infraManager) getAddonInstallOpts(ctx context.Context, license licensewrapper.LicenseWrapper, rc runtimeconfig.RuntimeConfig) (addons.InstallOptions, error) {
 	kotsadmNamespace, err := runtimeconfig.KotsadmNamespace(ctx, m.kcli)
 	if err != nil {
 		return addons.InstallOptions{}, fmt.Errorf("get kotsadm namespace: %w", err)
@@ -305,8 +305,8 @@ func (m *infraManager) getAddonInstallOpts(ctx context.Context, license *kotsv1b
 		TLSCertBytes:            m.tlsConfig.CertBytes,
 		TLSKeyBytes:             m.tlsConfig.KeyBytes,
 		Hostname:                m.tlsConfig.Hostname,
-		DisasterRecoveryEnabled: license.Spec.IsDisasterRecoverySupported,
-		IsMultiNodeEnabled:      license.Spec.IsEmbeddedClusterMultiNodeEnabled,
+		DisasterRecoveryEnabled: license.IsDisasterRecoverySupported(),
+		IsMultiNodeEnabled:      license.IsEmbeddedClusterMultiNodeEnabled(),
 		EmbeddedConfigSpec:      m.getECConfigSpec(),
 		EndUserConfigSpec:       m.getEndUserConfigSpec(),
 		ProxySpec:               rc.ProxySpec(),

api/internal/managers/linux/infra/install_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/addons"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
 	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
+	"github.com/replicatedhq/kotskinds/pkg/licensewrapper"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -63,14 +64,19 @@ func TestInfraManager_getAddonInstallOpts(t *testing.T) {
 				},
 			}
 
+			// Wrap the license
+			wrappedLicense := licensewrapper.LicenseWrapper{
+				V1: license,
+			}
+
 			// Create infra manager
 			manager := NewInfraManager(
 				WithClusterID("test-cluster"),
 				WithLicense([]byte("spec:\n  licenseID: test-license\n")),
 			)
 
 			// Test the getAddonInstallOpts method with configValues passed as parameter
-			opts, err := manager.getAddonInstallOpts(t.Context(), license, rc)
+			opts, err := manager.getAddonInstallOpts(t.Context(), wrappedLicense, rc)
 			assert.NoError(t, err)
 
 			// Verify the install options