feat: preflight storage needed to perform airgap install

api/api.go

@@ -19,6 +19,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/metrics"
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
+	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
 	"github.com/sirupsen/logrus"
 	httpSwagger "github.com/swaggo/http-swagger/v2"
 )
@@ -50,6 +51,7 @@ type API struct {
 	tlsConfig                 types.TLSConfig
 	license                   []byte
 	airgapBundle              string
+	airgapInfo                *kotsv1beta1.Airgap
 	configValues              string
 	endUserConfig             *ecv1beta1.Config
 	allowIgnoreHostPreflights bool
@@ -126,6 +128,12 @@ func WithAirgapBundle(airgapBundle string) APIOption {
 	}
 }
 
+func WithAirgapInfo(airgapInfo *kotsv1beta1.Airgap) APIOption {
+	return func(a *API) {
+		a.airgapInfo = airgapInfo
+	}
+}
+
 func WithConfigValues(configValues string) APIOption {
 	return func(a *API) {
 		a.configValues = configValues
@@ -197,6 +205,7 @@ func New(password string, opts ...APIOption) (*API, error) {
 			install.WithTLSConfig(api.tlsConfig),
 			install.WithLicense(api.license),
 			install.WithAirgapBundle(api.airgapBundle),
+			install.WithAirgapInfo(api.airgapInfo),
 			install.WithConfigValues(api.configValues),
 			install.WithEndUserConfig(api.endUserConfig),
 			install.WithAllowIgnoreHostPreflights(api.allowIgnoreHostPreflights),

api/controllers/install/controller.go

@@ -17,6 +17,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/metrics"
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
+	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
 	"github.com/sirupsen/logrus"
 )
 
@@ -52,6 +53,7 @@ type InstallController struct {
 	tlsConfig            types.TLSConfig
 	license              []byte
 	airgapBundle         string
+	airgapInfo           *kotsv1beta1.Airgap
 	configValues         string
 	endUserConfig        *ecv1beta1.Config
 
@@ -126,6 +128,12 @@ func WithAirgapBundle(airgapBundle string) InstallControllerOption {
 	}
 }
 
+func WithAirgapInfo(airgapInfo *kotsv1beta1.Airgap) InstallControllerOption {
+	return func(c *InstallController) {
+		c.airgapInfo = airgapInfo
+	}
+}
+
 func WithConfigValues(configValues string) InstallControllerOption {
 	return func(c *InstallController) {
 		c.configValues = configValues

api/controllers/install/hostpreflight.go

@@ -8,6 +8,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/api/internal/managers/preflight"
 	"github.com/replicatedhq/embedded-cluster/api/pkg/utils"
 	"github.com/replicatedhq/embedded-cluster/api/types"
+	"github.com/replicatedhq/embedded-cluster/pkg-new/preflights"
 	"github.com/replicatedhq/embedded-cluster/pkg/netutils"
 )
 
@@ -33,14 +34,21 @@ func (c *InstallController) RunHostPreflights(ctx context.Context, opts RunHostP
 	// Get the configured custom domains
 	ecDomains := utils.GetDomains(c.releaseData)
 
+	// Calculate airgap storage space requirement (2x uncompressed size for controller nodes)
+	var controllerAirgapStorageSpace string
+	if c.airgapInfo != nil {
+		controllerAirgapStorageSpace = preflights.CalculateAirgapStorageSpace(c.airgapInfo.Spec.UncompressedSize, true)
+	}
+
 	// Prepare host preflights
 	hpf, err := c.hostPreflightManager.PrepareHostPreflights(ctx, c.rc, preflight.PrepareHostPreflightOptions{
-		ReplicatedAppURL:      netutils.MaybeAddHTTPS(ecDomains.ReplicatedAppDomain),
-		ProxyRegistryURL:      netutils.MaybeAddHTTPS(ecDomains.ProxyRegistryDomain),
-		HostPreflightSpec:     c.releaseData.HostPreflights,
-		EmbeddedClusterConfig: c.releaseData.EmbeddedClusterConfig,
-		IsAirgap:              c.airgapBundle != "",
-		IsUI:                  opts.IsUI,
+		ReplicatedAppURL:             netutils.MaybeAddHTTPS(ecDomains.ReplicatedAppDomain),
+		ProxyRegistryURL:             netutils.MaybeAddHTTPS(ecDomains.ProxyRegistryDomain),
+		HostPreflightSpec:            c.releaseData.HostPreflights,
+		EmbeddedClusterConfig:        c.releaseData.EmbeddedClusterConfig,
+		IsAirgap:                     c.airgapBundle != "",
+		IsUI:                         opts.IsUI,
+		ControllerAirgapStorageSpace: controllerAirgapStorageSpace,
 	})
 	if err != nil {
 		return fmt.Errorf("failed to prepare host preflights: %w", err)

api/internal/managers/infra/install.go

@@ -14,6 +14,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/addons"
 	"github.com/replicatedhq/embedded-cluster/pkg/addons/registry"
 	addontypes "github.com/replicatedhq/embedded-cluster/pkg/addons/types"
+	"github.com/replicatedhq/embedded-cluster/pkg/airgap"
 	"github.com/replicatedhq/embedded-cluster/pkg/extensions"
 	"github.com/replicatedhq/embedded-cluster/pkg/helm"
 	"github.com/replicatedhq/embedded-cluster/pkg/kubeutils"
@@ -98,6 +99,14 @@ func (m *infraManager) install(ctx context.Context, rc runtimeconfig.RuntimeConf
 		return fmt.Errorf("parse license: %w", err)
 	}
 
+	if m.airgapBundle != "" {
+		var err error
+		m.airgapInfo, err = airgap.AirgapInfoFromPath(m.airgapBundle)
+		if err != nil {
+			return fmt.Errorf("failed to get airgap info: %w", err)
+		}
+	}
+
 	if err := m.initComponentsList(license, rc); err != nil {
 		return fmt.Errorf("init components: %w", err)
 	}
@@ -224,15 +233,22 @@ func (m *infraManager) recordInstallation(ctx context.Context, kcli client.Clien
 	// get the configured custom domains
 	ecDomains := utils.GetDomains(m.releaseData)
 
+	// extract airgap uncompressed size if airgap info is provided
+	var airgapUncompressedSize int64
+	if m.airgapInfo != nil {
+		airgapUncompressedSize = m.airgapInfo.Spec.UncompressedSize
+	}
+
 	// record the installation
 	logFn("recording installation")
 	in, err := kubeutils.RecordInstallation(ctx, kcli, kubeutils.RecordInstallationOptions{
-		IsAirgap:       m.airgapBundle != "",
-		License:        license,
-		ConfigSpec:     m.getECConfigSpec(),
-		MetricsBaseURL: netutils.MaybeAddHTTPS(ecDomains.ReplicatedAppDomain),
-		RuntimeConfig:  rc.Get(),
-		EndUserConfig:  m.endUserConfig,
+		IsAirgap:               m.airgapBundle != "",
+		License:                license,
+		ConfigSpec:             m.getECConfigSpec(),
+		MetricsBaseURL:         netutils.MaybeAddHTTPS(ecDomains.ReplicatedAppDomain),
+		RuntimeConfig:          rc.Get(),
+		EndUserConfig:          m.endUserConfig,
+		AirgapUncompressedSize: airgapUncompressedSize,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("record installation: %w", err)

api/internal/managers/infra/manager.go

@@ -13,6 +13,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/helm"
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
+	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
 	"github.com/sirupsen/logrus"
 	"k8s.io/client-go/metadata"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -33,6 +34,7 @@ type infraManager struct {
 	tlsConfig     types.TLSConfig
 	license       []byte
 	airgapBundle  string
+	airgapInfo    *kotsv1beta1.Airgap
 	configValues  string
 	releaseData   *release.ReleaseData
 	endUserConfig *ecv1beta1.Config

api/internal/managers/preflight/hostpreflight.go

@@ -15,14 +15,16 @@ import (
 )
 
 type PrepareHostPreflightOptions struct {
-	ReplicatedAppURL       string
-	ProxyRegistryURL       string
-	HostPreflightSpec      *troubleshootv1beta2.HostPreflightSpec
-	EmbeddedClusterConfig  *ecv1beta1.Config
-	TCPConnectionsRequired []string
-	IsAirgap               bool
-	IsJoin                 bool
-	IsUI                   bool
+	ReplicatedAppURL             string
+	ProxyRegistryURL             string
+	HostPreflightSpec            *troubleshootv1beta2.HostPreflightSpec
+	EmbeddedClusterConfig        *ecv1beta1.Config
+	TCPConnectionsRequired       []string
+	IsAirgap                     bool
+	IsJoin                       bool
+	IsUI                         bool
+	ControllerAirgapStorageSpace string
+	WorkerAirgapStorageSpace     string
 }
 
 type RunHostPreflightOptions struct {
@@ -38,22 +40,24 @@ func (m *hostPreflightManager) PrepareHostPreflights(ctx context.Context, rc run
 
 	// Use the shared Prepare function to prepare host preflights
 	prepareOpts := preflights.PrepareOptions{
-		HostPreflightSpec:       opts.HostPreflightSpec,
-		ReplicatedAppURL:        opts.ReplicatedAppURL,
-		ProxyRegistryURL:        opts.ProxyRegistryURL,
-		AdminConsolePort:        rc.AdminConsolePort(),
-		LocalArtifactMirrorPort: rc.LocalArtifactMirrorPort(),
-		DataDir:                 rc.EmbeddedClusterHomeDirectory(),
-		K0sDataDir:              rc.EmbeddedClusterK0sSubDir(),
-		OpenEBSDataDir:          rc.EmbeddedClusterOpenEBSLocalSubDir(),
-		Proxy:                   rc.ProxySpec(),
-		PodCIDR:                 rc.PodCIDR(),
-		ServiceCIDR:             rc.ServiceCIDR(),
-		NodeIP:                  nodeIP,
-		IsAirgap:                opts.IsAirgap,
-		TCPConnectionsRequired:  opts.TCPConnectionsRequired,
-		IsJoin:                  opts.IsJoin,
-		IsUI:                    opts.IsUI,
+		HostPreflightSpec:            opts.HostPreflightSpec,
+		ReplicatedAppURL:             opts.ReplicatedAppURL,
+		ProxyRegistryURL:             opts.ProxyRegistryURL,
+		AdminConsolePort:             rc.AdminConsolePort(),
+		LocalArtifactMirrorPort:      rc.LocalArtifactMirrorPort(),
+		DataDir:                      rc.EmbeddedClusterHomeDirectory(),
+		K0sDataDir:                   rc.EmbeddedClusterK0sSubDir(),
+		OpenEBSDataDir:               rc.EmbeddedClusterOpenEBSLocalSubDir(),
+		Proxy:                        rc.ProxySpec(),
+		PodCIDR:                      rc.PodCIDR(),
+		ServiceCIDR:                  rc.ServiceCIDR(),
+		NodeIP:                       nodeIP,
+		IsAirgap:                     opts.IsAirgap,
+		TCPConnectionsRequired:       opts.TCPConnectionsRequired,
+		IsJoin:                       opts.IsJoin,
+		IsUI:                         opts.IsUI,
+		ControllerAirgapStorageSpace: opts.ControllerAirgapStorageSpace,
+		WorkerAirgapStorageSpace:     opts.WorkerAirgapStorageSpace,
 	}
 	if cidr := rc.GlobalCIDR(); cidr != "" {
 		prepareOpts.GlobalCIDR = &cidr

cmd/installer/cli/api.go

@@ -24,6 +24,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
 	"github.com/replicatedhq/embedded-cluster/web"
+	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
 	"github.com/sirupsen/logrus"
 )
 
@@ -37,6 +38,7 @@ type apiConfig struct {
 	ManagerPort               int
 	License                   []byte
 	AirgapBundle              string
+	AirgapInfo                *kotsv1beta1.Airgap
 	ConfigValues              string
 	ReleaseData               *release.ReleaseData
 	EndUserConfig             *ecv1beta1.Config
@@ -90,6 +92,7 @@ func serveAPI(ctx context.Context, listener net.Listener, cert tls.Certificate,
 		api.WithTLSConfig(config.TLSConfig),
 		api.WithLicense(config.License),
 		api.WithAirgapBundle(config.AirgapBundle),
+		api.WithAirgapInfo(config.AirgapInfo),
 		api.WithConfigValues(config.ConfigValues),
 		api.WithEndUserConfig(config.EndUserConfig),
 		api.WithAllowIgnoreHostPreflights(config.AllowIgnoreHostPreflights),

cmd/installer/cli/install.go

@@ -53,6 +53,7 @@ type InstallCmdFlags struct {
 	adminConsolePort        int
 	airgapBundle            string
 	isAirgap                bool
+	airgapInfo              *kotsv1beta1.Airgap
 	dataDir                 string
 	licenseFile             string
 	localArtifactMirrorPort int
@@ -266,6 +267,13 @@ func preRunInstall(cmd *cobra.Command, flags *InstallCmdFlags, rc runtimeconfig.
 	}
 
 	flags.isAirgap = flags.airgapBundle != ""
+	if flags.airgapBundle != "" {
+		var err error
+		flags.airgapInfo, err = airgap.AirgapInfoFromPath(flags.airgapBundle)
+		if err != nil {
+			return fmt.Errorf("failed to get airgap info: %w", err)
+		}
+	}
 
 	hostCABundlePath, err := findHostCABundle()
 	if err != nil {
@@ -426,6 +434,7 @@ func runManagerExperienceInstall(ctx context.Context, flags InstallCmdFlags, rc
 		ManagerPort:               flags.managerPort,
 		License:                   flags.licenseBytes,
 		AirgapBundle:              flags.airgapBundle,
+		AirgapInfo:                flags.airgapInfo,
 		ConfigValues:              flags.configValues,
 		ReleaseData:               release.GetReleaseData(),
 		EndUserConfig:             eucfg,
@@ -596,9 +605,9 @@ func verifyAndPrompt(ctx context.Context, name string, flags InstallCmdFlags, pr
 	if err != nil {
 		return err
 	}
-	if flags.isAirgap {
+	if flags.airgapInfo != nil {
 		logrus.Debugf("checking airgap bundle matches binary")
-		if err := checkAirgapMatches(flags.airgapBundle); err != nil {
+		if err := checkAirgapMatches(flags.airgapInfo); err != nil {
 			return err // we want the user to see the error message without a prefix
 		}
 	}
@@ -898,23 +907,15 @@ func installExtensions(ctx context.Context, hcli helm.Client) error {
 	return nil
 }
 
-func checkAirgapMatches(airgapBundle string) error {
+func checkAirgapMatches(airgapInfo *kotsv1beta1.Airgap) error {
 	rel := release.GetChannelRelease()
 	if rel == nil {
 		return fmt.Errorf("airgap bundle provided but no release was found in binary, please rerun without the airgap-bundle flag")
 	}
 
-	// read file from path
-	rawfile, err := os.Open(airgapBundle)
-	if err != nil {
-		return fmt.Errorf("failed to open airgap file: %w", err)
-	}
-	defer rawfile.Close()
-
-	appSlug, channelID, airgapVersion, err := airgap.ChannelReleaseMetadata(rawfile)
-	if err != nil {
-		return fmt.Errorf("failed to get airgap bundle versions: %w", err)
-	}
+	appSlug := airgapInfo.Spec.AppSlug
+	channelID := airgapInfo.Spec.ChannelID
+	airgapVersion := airgapInfo.Spec.VersionLabel
 
 	// Check if the airgap bundle matches the application version data
 	if rel.AppSlug != appSlug {
@@ -1075,14 +1076,21 @@ func recordInstallation(
 		return nil, fmt.Errorf("process overrides file: %w", err)
 	}
 
+	// extract airgap uncompressed size if airgap info is provided
+	var airgapUncompressedSize int64
+	if flags.airgapInfo != nil {
+		airgapUncompressedSize = flags.airgapInfo.Spec.UncompressedSize
+	}
+
 	// record the installation
 	installation, err := kubeutils.RecordInstallation(ctx, kcli, kubeutils.RecordInstallationOptions{
-		IsAirgap:       flags.isAirgap,
-		License:        license,
-		ConfigSpec:     cfgspec,
-		MetricsBaseURL: replicatedAppURL(),
-		RuntimeConfig:  rc.Get(),
-		EndUserConfig:  eucfg,
+		IsAirgap:               flags.isAirgap,
+		License:                license,
+		ConfigSpec:             cfgspec,
+		MetricsBaseURL:         replicatedAppURL(),
+		RuntimeConfig:          rc.Get(),
+		EndUserConfig:          eucfg,
+		AirgapUncompressedSize: airgapUncompressedSize,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("record installation: %w", err)

cmd/installer/cli/install_runpreflights.go

@@ -100,20 +100,27 @@ func runInstallPreflights(ctx context.Context, flags InstallCmdFlags, rc runtime
 		return fmt.Errorf("unable to find first valid address: %w", err)
 	}
 
+	// Calculate airgap storage space requirement (2x uncompressed size for controller nodes)
+	var controllerAirgapStorageSpace string
+	if flags.airgapInfo != nil {
+		controllerAirgapStorageSpace = preflights.CalculateAirgapStorageSpace(flags.airgapInfo.Spec.UncompressedSize, true)
+	}
+
 	opts := preflights.PrepareOptions{
-		HostPreflightSpec:       release.GetHostPreflights(),
-		ReplicatedAppURL:        replicatedAppURL,
-		ProxyRegistryURL:        proxyRegistryURL,
-		AdminConsolePort:        rc.AdminConsolePort(),
-		LocalArtifactMirrorPort: rc.LocalArtifactMirrorPort(),
-		DataDir:                 rc.EmbeddedClusterHomeDirectory(),
-		K0sDataDir:              rc.EmbeddedClusterK0sSubDir(),
-		OpenEBSDataDir:          rc.EmbeddedClusterOpenEBSLocalSubDir(),
-		Proxy:                   rc.ProxySpec(),
-		PodCIDR:                 rc.PodCIDR(),
-		ServiceCIDR:             rc.ServiceCIDR(),
-		NodeIP:                  nodeIP,
-		IsAirgap:                flags.isAirgap,
+		HostPreflightSpec:            release.GetHostPreflights(),
+		ReplicatedAppURL:             replicatedAppURL,
+		ProxyRegistryURL:             proxyRegistryURL,
+		AdminConsolePort:             rc.AdminConsolePort(),
+		LocalArtifactMirrorPort:      rc.LocalArtifactMirrorPort(),
+		DataDir:                      rc.EmbeddedClusterHomeDirectory(),
+		K0sDataDir:                   rc.EmbeddedClusterK0sSubDir(),
+		OpenEBSDataDir:               rc.EmbeddedClusterOpenEBSLocalSubDir(),
+		Proxy:                        rc.ProxySpec(),
+		PodCIDR:                      rc.PodCIDR(),
+		ServiceCIDR:                  rc.ServiceCIDR(),
+		NodeIP:                       nodeIP,
+		IsAirgap:                     flags.isAirgap,
+		ControllerAirgapStorageSpace: controllerAirgapStorageSpace,
 	}
 	if globalCIDR := rc.GlobalCIDR(); globalCIDR != "" {
 		opts.GlobalCIDR = &globalCIDR