feat(upgrade): add verification release is deployable

Author: JGAntunes

cmd/installer/cli/upgrade.go

@@ -16,6 +16,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/cmd/installer/goods"
 	"github.com/replicatedhq/embedded-cluster/cmd/installer/kotscli"
 	ecv1beta1 "github.com/replicatedhq/embedded-cluster/kinds/apis/v1beta1"
+	"github.com/replicatedhq/embedded-cluster/pkg-new/replicatedapi"
 	"github.com/replicatedhq/embedded-cluster/pkg/airgap"
 	"github.com/replicatedhq/embedded-cluster/pkg/helpers"
 	"github.com/replicatedhq/embedded-cluster/pkg/kubeutils"
@@ -24,6 +25,7 @@ import (
 	"github.com/replicatedhq/embedded-cluster/pkg/release"
 	"github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig"
 	rcutil "github.com/replicatedhq/embedded-cluster/pkg/runtimeconfig/util"
+	"github.com/replicatedhq/embedded-cluster/pkg/validation"
 	"github.com/replicatedhq/embedded-cluster/pkg/versions"
 	"github.com/replicatedhq/embedded-cluster/web"
 	kotsv1beta1 "github.com/replicatedhq/kotskinds/apis/kots/v1beta1"
@@ -59,6 +61,8 @@ type upgradeConfig struct {
 	managerPort          int
 	requiresInfraUpgrade bool
 	kotsadmNamespace     string
+	currentAppVersion    *kotscli.AppVersionInfo
+	replicatedAPIClient  replicatedapi.Client
 }
 
 // UpgradeCmd returns a cobra command for upgrading the embedded cluster application.
@@ -110,7 +114,7 @@ func UpgradeCmd(ctx context.Context, appSlug, appTitle string) *cobra.Command {
 			if err := preRunUpgrade(ctx, flags, &upgradeConfig, existingRC, kcli, appSlug); err != nil {
 				return err
 			}
-			if err := verifyAndPromptUpgrade(ctx, flags, upgradeConfig, prompts.New()); err != nil {
+			if err := verifyAndPromptUpgrade(ctx, flags, upgradeConfig, prompts.New(), kcli, appSlug); err != nil {
 				return err
 			}
 
@@ -267,6 +271,7 @@ func preRunUpgrade(ctx context.Context, flags UpgradeCmdFlags, upgradeConfig *up
 		}
 		upgradeConfig.license = updatedLicense
 		upgradeConfig.licenseBytes = licenseBytes
+		upgradeConfig.replicatedAPIClient = replicatedAPI
 	}
 
 	// Continue using "kotsadm" namespace if it exists for backwards compatibility, otherwise use the appSlug
@@ -337,10 +342,17 @@ func preRunUpgrade(ctx context.Context, flags UpgradeCmdFlags, upgradeConfig *up
 	}
 	upgradeConfig.requiresInfraUpgrade = requiresInfraUpgrade
 
+	// Get current app version for deployability validation
+	currentAppVersion, err := kotscli.GetCurrentAppVersion(appSlug, upgradeConfig.kotsadmNamespace)
+	if err != nil {
+		return fmt.Errorf("failed to get current app version: %w", err)
+	}
+	upgradeConfig.currentAppVersion = currentAppVersion
+
 	return nil
 }
 
-func verifyAndPromptUpgrade(ctx context.Context, flags UpgradeCmdFlags, upgradeConfig upgradeConfig, prompt prompts.Prompt) error {
+func verifyAndPromptUpgrade(ctx context.Context, flags UpgradeCmdFlags, upgradeConfig upgradeConfig, prompt prompts.Prompt, kcli client.Client, appSlug string) error {
 	isAirgap := flags.airgapBundle != ""
 
 	err := verifyChannelRelease("upgrade", isAirgap, flags.assumeYes)
@@ -355,6 +367,11 @@ func verifyAndPromptUpgrade(ctx context.Context, flags UpgradeCmdFlags, upgradeC
 		}
 	}
 
+	// Validate release deployability
+	if err := validateReleaseDeployability(ctx, upgradeConfig, kcli, appSlug, isAirgap); err != nil {
+		return fmt.Errorf("upgrade validation failed: %w", err)
+	}
+
 	if !isAirgap {
 		if err := maybePromptForAppUpdate(ctx, prompt, upgradeConfig.license, flags.assumeYes); err != nil {
 			if errors.As(err, &ErrorNothingElseToAdd{}) {
@@ -554,3 +571,64 @@ func checkRequiresInfraUpgrade(ctx context.Context) (bool, error) {
 
 	return !bytes.Equal(currentJSON, targetJSON), nil
 }
+
+// validateReleaseDeployability validates that the target release can be safely deployed
+func validateReleaseDeployability(ctx context.Context, upgradeConfig upgradeConfig, kcli client.Client, appSlug string, isAirgap bool) error {
+	// Get current installation for version information
+	currentInstallation, err := kubeutils.GetLatestInstallation(ctx, kcli)
+	if err != nil {
+		return fmt.Errorf("get current installation: %w", err)
+	}
+
+	// Get target release data
+	releaseData := release.GetReleaseData()
+	if releaseData == nil {
+		return fmt.Errorf("release data not found")
+	}
+
+	// Get channel release info
+	channelRelease := releaseData.ChannelRelease
+	if channelRelease == nil {
+		return fmt.Errorf("channel release not found in release data")
+	}
+
+	// Get current and target EC/K8s versions
+	var currentECVersion string
+	if currentInstallation.Spec.Config != nil {
+		currentECVersion = currentInstallation.Spec.Config.Version
+	}
+
+	targetECVersion := versions.Version
+
+	// Build validation options
+	opts := validation.UpgradableOptions{
+		IsAirgap:         isAirgap,
+		CurrentECVersion: currentECVersion,
+		TargetECVersion:  targetECVersion,
+		License:          upgradeConfig.license,
+		AirgapMetadata:   upgradeConfig.airgapMetadata,
+	}
+
+	// Add current app version info if available
+	if upgradeConfig.currentAppVersion != nil {
+		opts.CurrentAppVersion = upgradeConfig.currentAppVersion.VersionLabel
+		opts.CurrentAppSequence = upgradeConfig.currentAppVersion.ChannelSequence
+	}
+
+	// Add target app version info
+	opts.TargetAppVersion = channelRelease.VersionLabel
+	opts.TargetAppSequence = channelRelease.ChannelSequence
+
+	// For online upgrades, add the replicated API client and channel ID
+	if !isAirgap && upgradeConfig.replicatedAPIClient != nil {
+		opts.ReplicatedAPI = upgradeConfig.replicatedAPIClient
+		opts.ChannelID = channelRelease.ChannelID
+	}
+
+	// Perform validation
+	if err := validation.ValidateIsReleaseUpgradable(ctx, opts); err != nil {
+		return err
+	}
+
+	return nil
+}

cmd/installer/kotscli/kotscli.go

@@ -3,6 +3,7 @@ package kotscli
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -437,6 +438,56 @@ func createLicenseFile(license []byte) (string, error) {
 	return licenseFile.Name(), nil
 }
 
+// AppVersionInfo holds information about a deployed app version
+type AppVersionInfo struct {
+	VersionLabel    string `json:"versionLabel"`
+	ChannelSequence int64  `json:"channelSequence"`
+	Sequence        int64  `json:"sequence"`
+	Status          string `json:"status"`
+}
+
+// GetCurrentAppVersion retrieves the currently deployed app version and sequence
+func GetCurrentAppVersion(appSlug string, namespace string) (*AppVersionInfo, error) {
+	kotsBinPath, err := goods.InternalBinary("kubectl-kots")
+	if err != nil {
+		return nil, fmt.Errorf("materialize kubectl-kots binary: %w", err)
+	}
+	defer os.Remove(kotsBinPath)
+
+	// Build command arguments: kots get versions <appSlug> -n <namespace> -o json
+	args := []string{
+		"get", "versions",
+		appSlug,
+		"-n", namespace,
+		"-o", "json",
+	}
+
+	// Execute the command and capture output
+	var outputBuffer bytes.Buffer
+	runCommandOpts := helpers.RunCommandOptions{
+		Stdout: &outputBuffer,
+	}
+
+	if err := helpers.RunCommandWithOptions(runCommandOpts, kotsBinPath, args...); err != nil {
+		return nil, fmt.Errorf("get versions from kots: %w", err)
+	}
+
+	// Parse JSON output
+	var versions []AppVersionInfo
+	if err := json.Unmarshal(outputBuffer.Bytes(), &versions); err != nil {
+		return nil, fmt.Errorf("unmarshal versions output: %w", err)
+	}
+
+	// Find the deployed version
+	for _, v := range versions {
+		if v.Status == "deployed" {
+			return &v, nil
+		}
+	}
+
+	return nil, fmt.Errorf("no deployed version found for app %s", appSlug)
+}
+
 // GetConfigValuesOptions holds options for getting config values
 type GetConfigValuesOptions struct {
 	AppSlug               string

pkg-new/replicatedapi/client.go

@@ -15,6 +15,8 @@ import (
 	kyaml "sigs.k8s.io/yaml"
 )
 
+var _ Client = (*client)(nil)
+
 var defaultHTTPClient = newRetryableHTTPClient()
 
 // ClientFactory is a function type for creating replicatedapi clients
@@ -29,6 +31,7 @@ func SetClientFactory(factory ClientFactory) {
 
 type Client interface {
 	SyncLicense(ctx context.Context) (*kotsv1beta1.License, []byte, error)
+	GetPendingReleases(ctx context.Context, channelID string, currentSequence int64, opts *PendingReleasesOptions) (*PendingReleasesResponse, error)
 }
 
 type client struct {
@@ -172,3 +175,47 @@ func basicAuth(username, password string) string {
 	auth := username + ":" + password
 	return base64.StdEncoding.EncodeToString([]byte(auth))
 }
+
+// GetPendingReleases fetches pending releases from the Replicated API
+func (c *client) GetPendingReleases(ctx context.Context, channelID string, currentSequence int64, opts *PendingReleasesOptions) (*PendingReleasesResponse, error) {
+	u := fmt.Sprintf("%s/release/%s/pending", c.replicatedAppURL, c.license.Spec.AppSlug)
+
+	params := url.Values{}
+	params.Set("selectedChannelId", channelID)
+	params.Set("currentSequence", fmt.Sprintf("%d", currentSequence))
+	params.Set("isSemverSupported", fmt.Sprintf("%t", opts.IsSemverSupported))
+	if opts.SortOrder != "" {
+		params.Set("sortOrder", string(opts.SortOrder))
+	}
+	u = fmt.Sprintf("%s?%s", u, params.Encode())
+
+	req, err := c.newRetryableRequest(ctx, http.MethodGet, u, nil)
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("execute request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, string(body))
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("read response body: %w", err)
+	}
+
+	var pendingReleases PendingReleasesResponse
+	if err := kyaml.Unmarshal(body, &pendingReleases); err != nil {
+		return nil, fmt.Errorf("unmarshal pending releases response: %w", err)
+	}
+
+	return &pendingReleases, nil
+}

pkg-new/replicatedapi/types.go

@@ -0,0 +1,30 @@
+package replicatedapi
+
+import "time"
+
+// PendingReleasesResponse represents the response from the /release/{appSlug}/pending API endpoint
+type PendingReleasesResponse struct {
+	ChannelReleases []ChannelRelease `json:"channelReleases"`
+}
+
+// SortOrder represents the order in which to sort releases
+type SortOrder string
+
+const SortOrderAscending SortOrder = "asc"
+const SortOrderDescending SortOrder = "desc"
+
+// PendingReleasesOptions represents options for fetching pending releases
+type PendingReleasesOptions struct {
+	IsSemverSupported bool
+	SortOrder         SortOrder
+}
+
+// ChannelRelease represents a single release in a channel
+type ChannelRelease struct {
+	ChannelID       string    `json:"channelId"`
+	ChannelSequence int64     `json:"channelSequence"`
+	ReleaseSequence int64     `json:"releaseSequence"`
+	VersionLabel    string    `json:"versionLabel"`
+	IsRequired      bool      `json:"isRequired"`
+	CreatedAt       time.Time `json:"createdAt"`
+}