f

Author: emosbaugh

cmd/installer/cli/install.go

@@ -397,7 +397,7 @@ func preRunInstallCommon(cmd *cobra.Command, flags *InstallCmdFlags, rc runtimec
 		flags.licenseBytes = b
 
 		// validate the the license is indeed a license file
-		l, err := helpers.ParseLicense(flags.licenseFile)
+		l, err := helpers.ParseLicenseFromBytes(b)
 		if err != nil {
 			var notALicenseFileErr helpers.ErrNotALicenseFile
 			if errors.As(err, &notALicenseFileErr) {
@@ -425,6 +425,22 @@ func preRunInstallCommon(cmd *cobra.Command, flags *InstallCmdFlags, rc runtimec
 		flags.airgapMetadata = metadata
 	}
 
+	// sync the license if we are in the manager experience and a license is provided and we are
+	// not in airgap mode
+	if flags.enableManagerExperience && flags.license != nil && !flags.isAirgap {
+		replicatedAPI, err := newReplicatedAPIClient(flags.license, flags.clusterID)
+		if err != nil {
+			return fmt.Errorf("failed to create replicated API client: %w", err)
+		}
+
+		updatedLicense, licenseBytes, err := syncLicense(cmd.Context(), replicatedAPI, flags.license)
+		if err != nil {
+			return fmt.Errorf("failed to sync license: %w", err)
+		}
+		flags.license = updatedLicense
+		flags.licenseBytes = licenseBytes
+	}
+
 	var err error
 	flags.embeddedAssetsSize, err = goods.SizeOfEmbeddedAssets()
 	if err != nil {
@@ -627,22 +643,6 @@ func runManagerExperienceInstall(
 		return fmt.Errorf("get kotsadm namespace: %w", err)
 	}
 
-	replicatedAPI, err := newReplicatedAPIClient(flags.license, flags.clusterID)
-	if err != nil {
-		return fmt.Errorf("failed to create replicated API client: %w", err)
-	}
-
-	// Sync license before starting the manager experience (online only)
-	isAirgap := flags.airgapBundle != ""
-	if !isAirgap {
-		updatedLicense, licenseBytes, err := syncLicense(ctx, replicatedAPI, flags.license)
-		if err != nil {
-			return fmt.Errorf("failed to sync license: %w", err)
-		}
-		flags.license = updatedLicense
-		flags.licenseBytes = licenseBytes
-	}
-
 	// this is necessary because the api listens on all interfaces,
 	// and we only know the interface to use when the user selects it in the ui
 	ipAddresses, err := netutils.ListAllValidIPAddresses()
@@ -913,7 +913,7 @@ func verifyAndPrompt(ctx context.Context, cmd *cobra.Command, appSlug string, fl
 	}
 
 	logrus.Debugf("checking license matches")
-	license, err := getLicenseFromFilepath(flags.licenseFile)
+	license, err := verifyLicense(flags.license)
 	if err != nil {
 		return err
 	}
@@ -985,29 +985,24 @@ func ensureAdminConsolePassword(flags *InstallCmdFlags) error {
 	return nil
 }
 
-func getLicenseFromFilepath(licenseFile string) (*kotsv1beta1.License, error) {
+func verifyLicense(license *kotsv1beta1.License) (*kotsv1beta1.License, error) {
 	rel := release.GetChannelRelease()
 
 	// handle the three cases that do not require parsing the license file
 	// 1. no release and no license, which is OK
 	// 2. no license and a release, which is not OK
 	// 3. a license and no release, which is not OK
-	if rel == nil && licenseFile == "" {
+	if rel == nil && license == nil {
 		// no license and no release, this is OK
 		return nil, nil
-	} else if rel == nil && licenseFile != "" {
+	} else if rel == nil && license != nil {
 		// license is present but no release, this means we would install without vendor charts and k0s overrides
 		return nil, fmt.Errorf("a license was provided but no release was found in binary, please rerun without the license flag")
-	} else if rel != nil && licenseFile == "" {
+	} else if rel != nil && license == nil {
 		// release is present but no license, this is not OK
 		return nil, fmt.Errorf("no license was provided for %s and one is required, please rerun with '--license <path to license file>'", rel.AppSlug)
 	}
 
-	license, err := helpers.ParseLicense(licenseFile)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse the license file at %q, please ensure it is not corrupt: %w", licenseFile, err)
-	}
-
 	// Check if the license matches the application version data
 	if rel.AppSlug != license.Spec.AppSlug {
 		// if the app is different, we will not be able to provide the correct vendor supplied charts and k0s overrides

cmd/installer/cli/upgrade.go

@@ -236,18 +236,39 @@ func preRunUpgrade(ctx context.Context, flags UpgradeCmdFlags, upgradeConfig *up
 		return fmt.Errorf("failed to stat data directory: %w", err)
 	}
 
-	// Validate the license is indeed a license file
-	license, err := getLicenseFromFilepath(flags.licenseFile)
-	if err != nil {
-		return err
-	}
-	upgradeConfig.license = license
 	data, err := os.ReadFile(flags.licenseFile)
 	if err != nil {
 		return fmt.Errorf("failed to read license file: %w", err)
 	}
 	upgradeConfig.licenseBytes = data
 
+	// validate the the license is indeed a license file
+	l, err := helpers.ParseLicenseFromBytes(data)
+	if err != nil {
+		var notALicenseFileErr helpers.ErrNotALicenseFile
+		if errors.As(err, &notALicenseFileErr) {
+			return fmt.Errorf("failed to parse the license file at %q, please ensure it is not corrupt: %w", flags.licenseFile, err)
+		}
+
+		return fmt.Errorf("failed to parse license file: %w", err)
+	}
+	upgradeConfig.license = l
+
+	// sync the license if a license is provided and we are not in airgap mode
+	if upgradeConfig.license != nil && flags.airgapBundle == "" {
+		replicatedAPI, err := newReplicatedAPIClient(upgradeConfig.license, upgradeConfig.clusterID)
+		if err != nil {
+			return fmt.Errorf("failed to create replicated API client: %w", err)
+		}
+
+		updatedLicense, licenseBytes, err := syncLicense(ctx, replicatedAPI, upgradeConfig.license)
+		if err != nil {
+			return fmt.Errorf("failed to sync license: %w", err)
+		}
+		upgradeConfig.license = updatedLicense
+		upgradeConfig.licenseBytes = licenseBytes
+	}
+
 	// Continue using "kotsadm" namespace if it exists for backwards compatibility, otherwise use the appSlug
 	ns, err := runtimeconfig.KotsadmNamespace(ctx, kcli)
 	if err != nil {
@@ -444,22 +465,6 @@ func runManagerExperienceUpgrade(
 	ctx context.Context, flags UpgradeCmdFlags, upgradeConfig upgradeConfig, rc runtimeconfig.RuntimeConfig,
 	metricsReporter metrics.ReporterInterface, appTitle string, targetVersion string, initialVersion string,
 ) (finalErr error) {
-	replicatedAPI, err := newReplicatedAPIClient(upgradeConfig.license, upgradeConfig.clusterID)
-	if err != nil {
-		return fmt.Errorf("failed to create replicated API client: %w", err)
-	}
-
-	// Sync license before starting the manager experience (online only)
-	isAirgap := flags.airgapBundle != ""
-	if !isAirgap {
-		updatedLicense, licenseBytes, err := syncLicense(ctx, replicatedAPI, upgradeConfig.license)
-		if err != nil {
-			return fmt.Errorf("failed to sync license: %w", err)
-		}
-		upgradeConfig.license = updatedLicense
-		upgradeConfig.licenseBytes = licenseBytes
-	}
-
 	apiConfig := apiOptions{
 		APIConfig: apitypes.APIConfig{
 			InstallTarget:        apitypes.InstallTarget(flags.target),

pkg/helpers/parse.go

@@ -39,13 +39,13 @@ func ParseLicense(fpath string) (*kotsv1beta1.License, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to read license file: %w", err)
 	}
-	return ParseLicenseFromString(string(data))
+	return ParseLicenseFromBytes(data)
 }
 
-// ParseLicenseFromString parses the license from a YAML string
-func ParseLicenseFromString(yamlContent string) (*kotsv1beta1.License, error) {
+// ParseLicenseFromBytes parses the license from a byte slice
+func ParseLicenseFromBytes(data []byte) (*kotsv1beta1.License, error) {
 	var license kotsv1beta1.License
-	if err := kyaml.Unmarshal([]byte(yamlContent), &license); err != nil {
+	if err := kyaml.Unmarshal(data, &license); err != nil {
 		return nil, ErrNotALicenseFile{Err: err}
 	}
 	if license.Spec.LicenseID == "" {