wip: don't overwrite installation after copying images

Craig O'Donnell · Craig O'Donnell · commit 3c98dc6940ef · 2024-04-15T17:57:07.000Z
diff --git a/cmd/kots/cli/admin-console-push-images.go b/cmd/kots/cli/admin-console-push-images.go
@@ -54,7 +54,7 @@ func AdminPushImagesCmd() *cobra.Command {
 			}
 
 			if _, err := os.Stat(imageSource); err == nil {
-				_, err = image.TagAndPushImagesFromBundle(imageSource, *options)
+				err = image.TagAndPushImagesFromBundle(imageSource, *options)
 				if err != nil {
 					return errors.Wrap(err, "failed to push images")
 				}
diff --git a/pkg/airgap/update.go b/pkg/airgap/update.go
@@ -69,6 +69,8 @@ func UpdateAppFromPath(a *apptypes.App, airgapRoot string, airgapBundlePath stri
 		return errors.Wrap(err, "failed to find airgap meta")
 	}
 
+	fmt.Printf("***** UpdateAppFromPath found airgap metadata: %+v\n", airgap)
+
 	missingPrereqs, err := GetMissingRequiredVersions(a, airgap)
 	if err != nil {
 		return errors.Wrapf(err, "failed to check required versions")
diff --git a/pkg/image/airgap.go b/pkg/image/airgap.go
@@ -108,9 +108,9 @@ func WriteProgressLine(progressWriter io.Writer, line string) {
 }
 
 // CopyAirgapImages pushes images found in the airgap bundle/airgap root to the configured registry.
-func CopyAirgapImages(opts imagetypes.ProcessImageOptions, log *logger.CLILogger) (*imagetypes.CopyAirgapImagesResult, error) {
+func CopyAirgapImages(opts imagetypes.ProcessImageOptions, log *logger.CLILogger) error {
 	if opts.AirgapBundle == "" {
-		return &imagetypes.CopyAirgapImagesResult{}, nil
+		return nil
 	}
 
 	pushOpts := imagetypes.PushImagesOptions{
@@ -125,27 +125,25 @@ func CopyAirgapImages(opts imagetypes.ProcessImageOptions, log *logger.CLILogger
 		LogForUI:       true,
 	}
 
-	copyResult, err := TagAndPushImagesFromBundle(opts.AirgapBundle, pushOpts)
+	err := TagAndPushImagesFromBundle(opts.AirgapBundle, pushOpts)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to push images from bundle")
+		return errors.Wrap(err, "failed to push images from bundle")
 	}
 
-	return &imagetypes.CopyAirgapImagesResult{
-		EmbeddedClusterArtifacts: copyResult.EmbeddedClusterArtifacts,
-	}, nil
+	return nil
 }
 
-func TagAndPushImagesFromBundle(airgapBundle string, options imagetypes.PushImagesOptions) (*imagetypes.CopyAirgapImagesResult, error) {
+func TagAndPushImagesFromBundle(airgapBundle string, options imagetypes.PushImagesOptions) error {
 	airgap, err := kotsutil.FindAirgapMetaInBundle(airgapBundle)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to find airgap meta")
+		return errors.Wrap(err, "failed to find airgap meta")
 	}
 
 	switch airgap.Spec.Format {
 	case dockertypes.FormatDockerRegistry:
 		extractedBundle, err := os.MkdirTemp("", "extracted-airgap-kots")
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to create temp dir for unarchived airgap bundle")
+			return errors.Wrap(err, "failed to create temp dir for unarchived airgap bundle")
 		}
 		defer os.RemoveAll(extractedBundle)
 
@@ -155,34 +153,30 @@ func TagAndPushImagesFromBundle(airgapBundle string, options imagetypes.PushImag
 			},
 		}
 		if err := tarGz.Unarchive(airgapBundle, extractedBundle); err != nil {
-			return nil, errors.Wrap(err, "falied to unarchive airgap bundle")
+			return errors.Wrap(err, "falied to unarchive airgap bundle")
 		}
 		if err := PushImagesFromTempRegistry(extractedBundle, airgap.Spec.SavedImages, options); err != nil {
-			return nil, errors.Wrap(err, "failed to push images from docker registry bundle")
+			return errors.Wrap(err, "failed to push images from docker registry bundle")
 		}
 	case dockertypes.FormatDockerArchive, "":
 		if err := PushImagesFromDockerArchiveBundle(airgapBundle, options); err != nil {
-			return nil, errors.Wrap(err, "failed to push images from docker archive bundle")
+			return errors.Wrap(err, "failed to push images from docker archive bundle")
 		}
 	default:
-		return nil, errors.Errorf("Airgap bundle format '%s' is not supported", airgap.Spec.Format)
+		return errors.Errorf("Airgap bundle format '%s' is not supported", airgap.Spec.Format)
 	}
 
 	pushEmbeddedArtifactsOpts := imagetypes.PushEmbeddedClusterArtifactsOptions{
 		Registry:   options.Registry,
 		Tag:        imageutil.SanitizeTag(fmt.Sprintf("%s-%s-%s", airgap.Spec.ChannelID, airgap.Spec.UpdateCursor, airgap.Spec.VersionLabel)),
 		HTTPClient: orasretry.DefaultClient,
 	}
-	pushedArtifacts, err := PushEmbeddedClusterArtifacts(airgapBundle, pushEmbeddedArtifactsOpts)
+	_, err = PushEmbeddedClusterArtifacts(airgapBundle, pushEmbeddedArtifactsOpts)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to push embedded cluster artifacts")
+		return errors.Wrap(err, "failed to push embedded cluster artifacts")
 	}
 
-	result := &imagetypes.CopyAirgapImagesResult{
-		EmbeddedClusterArtifacts: pushedArtifacts,
-	}
-
-	return result, nil
+	return nil
 }
 
 func PushImagesFromTempRegistry(airgapRootDir string, imageList []string, options imagetypes.PushImagesOptions) error {
diff --git a/pkg/kotsadm/main.go b/pkg/kotsadm/main.go
@@ -164,7 +164,7 @@ func Deploy(deployOptions types.DeployOptions, log *logger.CLILogger) error {
 		}
 
 		if !deployOptions.DisableImagePush {
-			_, err := image.TagAndPushImagesFromBundle(deployOptions.AirgapBundle, pushOptions)
+			err := image.TagAndPushImagesFromBundle(deployOptions.AirgapBundle, pushOptions)
 			if err != nil {
 				return errors.Wrap(err, "failed to tag and push app images from path")
 			}
diff --git a/pkg/midstream/write.go b/pkg/midstream/write.go
@@ -112,18 +112,10 @@ func WriteMidstream(opts WriteOptions) (*Midstream, error) {
 			io.WriteString(opts.ProcessImageOptions.ReportWriter, "Copying images\n")
 
 			if opts.ProcessImageOptions.IsAirgap {
-				copyResult, err := image.CopyAirgapImages(opts.ProcessImageOptions, opts.Log)
+				err := image.CopyAirgapImages(opts.ProcessImageOptions, opts.Log)
 				if err != nil {
 					return nil, errors.Wrap(err, "failed to copy airgap images")
 				}
-
-				if err := image.UpdateInstallationEmbeddedClusterArtifacts(image.UpdateInstallationEmbeddedClusterArtifactsOptions{
-					Artifacts:   copyResult.EmbeddedClusterArtifacts,
-					KotsKinds:   opts.KotsKinds,
-					UpstreamDir: opts.UpstreamDir,
-				}); err != nil {
-					return nil, errors.Wrap(err, "failed to update installation airgap artifacts")
-				}
 			} else {
 				err := image.CopyOnlineImages(opts.ProcessImageOptions, allImages, opts.KotsKinds, opts.License, dockerHubRegistryCreds, opts.Log)
 				if err != nil {
diff --git a/pkg/pull/pull.go b/pkg/pull/pull.go
@@ -231,6 +231,8 @@ func Pull(upstreamURI string, pullOptions PullOptions) (string, error) {
 			return "", errors.Wrap(err, "failed to find airgap meta")
 		}
 
+		fmt.Printf("****** Pull airgap metadata: %+v\n", airgap)
+
 		if fetchOptions.AppVersionLabel != "" && fetchOptions.AppVersionLabel != airgap.Spec.VersionLabel {
 			logger.Infof("Expecting to install version %s but airgap bundle version is %s.", fetchOptions.AppVersionLabel, airgap.Spec.VersionLabel)
 		}
@@ -365,7 +367,7 @@ func Pull(upstreamURI string, pullOptions PullOptions) (string, error) {
 		}
 		if processImageOptions.RewriteImages && processImageOptions.IsAirgap {
 			// if this is an airgap install, we still need to process the images
-			if _, err := image.CopyAirgapImages(processImageOptions, log); err != nil {
+			if err := image.CopyAirgapImages(processImageOptions, log); err != nil {
 				return "", errors.Wrap(err, "failed to copy airgap images")
 			}
 		}
diff --git a/pkg/upstream/fetch.go b/pkg/upstream/fetch.go
@@ -1,6 +1,7 @@
 package upstream
 
 import (
+	"fmt"
 	"net/url"
 
 	"github.com/pkg/errors"
@@ -122,6 +123,7 @@ func pickReplicatedChartNames(fetchOptions *types.FetchOptions) []string {
 }
 
 func pickEmbeddedClusterArtifacts(fetchOptions *types.FetchOptions) []string {
+	fmt.Printf("*** fetchOptions.Airgap: %+v\n", fetchOptions.Airgap)
 	if fetchOptions.Airgap != nil {
 		if fetchOptions.Airgap.Spec.EmbeddedClusterArtifacts == nil {
 			return nil
diff --git a/pkg/upstream/replicated.go b/pkg/upstream/replicated.go
@@ -186,6 +186,7 @@ func downloadReplicated(
 
 		release = downloadedRelease
 	}
+	fmt.Printf("**** Release: %+v\n", release)
 
 	application := findAppInRelease(release) // this function never returns nil
 
@@ -301,8 +302,9 @@ func downloadReplicated(
 		ReplicatedRegistryDomain: release.ReplicatedRegistryDomain,
 		ReplicatedProxyDomain:    release.ReplicatedProxyDomain,
 		ReplicatedChartNames:     release.ReplicatedChartNames,
-		EmbeddedClusterArtifacts: embeddedClusterArtifacts,
+		EmbeddedClusterArtifacts: release.EmbeddedClusterArtifacts,
 	}
+	fmt.Printf("**** Upstream: %+v\n", upstream)
 
 	return upstream, nil
 }
diff --git a/pkg/upstream/upgrade.go b/pkg/upstream/upgrade.go
@@ -69,7 +69,7 @@ func Upgrade(appSlug string, options UpgradeOptions) (*UpgradeResponse, error) {
 		}
 
 		if !options.DisableImagePush {
-			_, err := image.TagAndPushImagesFromBundle(options.AirgapBundle, pushOptions)
+			err := image.TagAndPushImagesFromBundle(options.AirgapBundle, pushOptions)
 			if err != nil {
 				return nil, errors.Wrap(err, "failed to tag and push app images from path")
 			}
diff --git a/pkg/upstream/write.go b/pkg/upstream/write.go
@@ -3,6 +3,7 @@ package upstream
 import (
 	"bytes"
 	"encoding/base64"
+	"fmt"
 	"os"
 	"path"
 
@@ -158,6 +159,7 @@ func WriteUpstream(u *types.Upstream, options types.WriteOptions) error {
 	}
 
 	installationBytes := kotsutil.MustMarshalInstallation(&installation)
+	fmt.Printf("** WriteUpstream installation: %s\n", installationBytes)
 
 	u.Files = append(u.Files, types.UpstreamFile{
 		Path:    "userdata/installation.yaml",

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ func AdminPushImagesCmd() *cobra.Command {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`if _, err := os.Stat(imageSource); err == nil {`
`57`		`- _, err = image.TagAndPushImagesFromBundle(imageSource, *options)`
	`57`	`+ err = image.TagAndPushImagesFromBundle(imageSource, *options)`
`58`	`58`	`if err != nil {`
`59`	`59`	`return errors.Wrap(err, "failed to push images")`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,8 @@ func UpdateAppFromPath(a *apptypes.App, airgapRoot string, airgapBundlePath stri`
`69`	`69`	`return errors.Wrap(err, "failed to find airgap meta")`
`70`	`70`	`}`
`71`	`71`
	`72`	`+ fmt.Printf("***** UpdateAppFromPath found airgap metadata: %+v\n", airgap)`
	`73`	`+`
`72`	`74`	`missingPrereqs, err := GetMissingRequiredVersions(a, airgap)`
`73`	`75`	`if err != nil {`
`74`	`76`	`return errors.Wrapf(err, "failed to check required versions")`
Original file line number	Diff line number	Diff line change
`@@ -108,9 +108,9 @@ func WriteProgressLine(progressWriter io.Writer, line string) {`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`// CopyAirgapImages pushes images found in the airgap bundle/airgap root to the configured registry.`
`111`		`-func CopyAirgapImages(opts imagetypes.ProcessImageOptions, log logger.CLILogger) (imagetypes.CopyAirgapImagesResult, error) {`
	`111`	`+func CopyAirgapImages(opts imagetypes.ProcessImageOptions, log *logger.CLILogger) error {`
`112`	`112`	`if opts.AirgapBundle == "" {`
`113`		`- return &imagetypes.CopyAirgapImagesResult{}, nil`
	`113`	`+ return nil`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`pushOpts := imagetypes.PushImagesOptions{`
`@@ -125,27 +125,25 @@ func CopyAirgapImages(opts imagetypes.ProcessImageOptions, log *logger.CLILogger`
`125`	`125`	`LogForUI: true,`
`126`	`126`	`}`
`127`	`127`
`128`		`- copyResult, err := TagAndPushImagesFromBundle(opts.AirgapBundle, pushOpts)`
	`128`	`+ err := TagAndPushImagesFromBundle(opts.AirgapBundle, pushOpts)`
`129`	`129`	`if err != nil {`
`130`		`- return nil, errors.Wrap(err, "failed to push images from bundle")`
	`130`	`+ return errors.Wrap(err, "failed to push images from bundle")`
`131`	`131`	`}`
`132`	`132`
`133`		`- return &imagetypes.CopyAirgapImagesResult{`
`134`		`- EmbeddedClusterArtifacts: copyResult.EmbeddedClusterArtifacts,`
`135`		`- }, nil`
	`133`	`+ return nil`
`136`	`134`	`}`
`137`	`135`
`138`		`-func TagAndPushImagesFromBundle(airgapBundle string, options imagetypes.PushImagesOptions) (*imagetypes.CopyAirgapImagesResult, error) {`
	`136`	`+func TagAndPushImagesFromBundle(airgapBundle string, options imagetypes.PushImagesOptions) error {`
`139`	`137`	`airgap, err := kotsutil.FindAirgapMetaInBundle(airgapBundle)`
`140`	`138`	`if err != nil {`
`141`		`- return nil, errors.Wrap(err, "failed to find airgap meta")`
	`139`	`+ return errors.Wrap(err, "failed to find airgap meta")`
`142`	`140`	`}`
`143`	`141`
`144`	`142`	`switch airgap.Spec.Format {`
`145`	`143`	`case dockertypes.FormatDockerRegistry:`
`146`	`144`	`extractedBundle, err := os.MkdirTemp("", "extracted-airgap-kots")`
`147`	`145`	`if err != nil {`
`148`		`- return nil, errors.Wrap(err, "failed to create temp dir for unarchived airgap bundle")`
	`146`	`+ return errors.Wrap(err, "failed to create temp dir for unarchived airgap bundle")`
`149`	`147`	`}`
`150`	`148`	`defer os.RemoveAll(extractedBundle)`
`151`	`149`
`@@ -155,34 +153,30 @@ func TagAndPushImagesFromBundle(airgapBundle string, options imagetypes.PushImag`
`155`	`153`	`},`
`156`	`154`	`}`
`157`	`155`	`if err := tarGz.Unarchive(airgapBundle, extractedBundle); err != nil {`
`158`		`- return nil, errors.Wrap(err, "falied to unarchive airgap bundle")`
	`156`	`+ return errors.Wrap(err, "falied to unarchive airgap bundle")`
`159`	`157`	`}`
`160`	`158`	`if err := PushImagesFromTempRegistry(extractedBundle, airgap.Spec.SavedImages, options); err != nil {`
`161`		`- return nil, errors.Wrap(err, "failed to push images from docker registry bundle")`
	`159`	`+ return errors.Wrap(err, "failed to push images from docker registry bundle")`
`162`	`160`	`}`
`163`	`161`	`case dockertypes.FormatDockerArchive, "":`
`164`	`162`	`if err := PushImagesFromDockerArchiveBundle(airgapBundle, options); err != nil {`
`165`		`- return nil, errors.Wrap(err, "failed to push images from docker archive bundle")`
	`163`	`+ return errors.Wrap(err, "failed to push images from docker archive bundle")`
`166`	`164`	`}`
`167`	`165`	`default:`
`168`		`- return nil, errors.Errorf("Airgap bundle format '%s' is not supported", airgap.Spec.Format)`
	`166`	`+ return errors.Errorf("Airgap bundle format '%s' is not supported", airgap.Spec.Format)`
`169`	`167`	`}`
`170`	`168`
`171`	`169`	`pushEmbeddedArtifactsOpts := imagetypes.PushEmbeddedClusterArtifactsOptions{`
`172`	`170`	`Registry: options.Registry,`
`173`	`171`	`Tag: imageutil.SanitizeTag(fmt.Sprintf("%s-%s-%s", airgap.Spec.ChannelID, airgap.Spec.UpdateCursor, airgap.Spec.VersionLabel)),`
`174`	`172`	`HTTPClient: orasretry.DefaultClient,`
`175`	`173`	`}`
`176`		`- pushedArtifacts, err := PushEmbeddedClusterArtifacts(airgapBundle, pushEmbeddedArtifactsOpts)`
	`174`	`+ _, err = PushEmbeddedClusterArtifacts(airgapBundle, pushEmbeddedArtifactsOpts)`
`177`	`175`	`if err != nil {`
`178`		`- return nil, errors.Wrap(err, "failed to push embedded cluster artifacts")`
	`176`	`+ return errors.Wrap(err, "failed to push embedded cluster artifacts")`
`179`	`177`	`}`
`180`	`178`
`181`		`- result := &imagetypes.CopyAirgapImagesResult{`
`182`		`- EmbeddedClusterArtifacts: pushedArtifacts,`
`183`		`- }`
`184`		`-`
`185`		`- return result, nil`
	`179`	`+ return nil`
`186`	`180`	`}`
`187`	`181`
`188`	`182`	`func PushImagesFromTempRegistry(airgapRootDir string, imageList []string, options imagetypes.PushImagesOptions) error {`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ func Deploy(deployOptions types.DeployOptions, log *logger.CLILogger) error {`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`if !deployOptions.DisableImagePush {`
`167`		`- _, err := image.TagAndPushImagesFromBundle(deployOptions.AirgapBundle, pushOptions)`
	`167`	`+ err := image.TagAndPushImagesFromBundle(deployOptions.AirgapBundle, pushOptions)`
`168`	`168`	`if err != nil {`
`169`	`169`	`return errors.Wrap(err, "failed to tag and push app images from path")`
`170`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -231,6 +231,8 @@ func Pull(upstreamURI string, pullOptions PullOptions) (string, error) {`
`231`	`231`	`return "", errors.Wrap(err, "failed to find airgap meta")`
`232`	`232`	`}`
`233`	`233`
	`234`	`+ fmt.Printf("****** Pull airgap metadata: %+v\n", airgap)`
	`235`	`+`
`234`	`236`	`if fetchOptions.AppVersionLabel != "" && fetchOptions.AppVersionLabel != airgap.Spec.VersionLabel {`
`235`	`237`	`logger.Infof("Expecting to install version %s but airgap bundle version is %s.", fetchOptions.AppVersionLabel, airgap.Spec.VersionLabel)`
`236`	`238`	`}`
`@@ -365,7 +367,7 @@ func Pull(upstreamURI string, pullOptions PullOptions) (string, error) {`
`365`	`367`	`}`
`366`	`368`	`if processImageOptions.RewriteImages && processImageOptions.IsAirgap {`
`367`	`369`	`// if this is an airgap install, we still need to process the images`
`368`		`- if _, err := image.CopyAirgapImages(processImageOptions, log); err != nil {`
	`370`	`+ if err := image.CopyAirgapImages(processImageOptions, log); err != nil {`
`369`	`371`	`return "", errors.Wrap(err, "failed to copy airgap images")`
`370`	`372`	`}`
`371`	`373`	`}`
Original file line number	Diff line number	Diff line change
`@@ -186,6 +186,7 @@ func downloadReplicated(`
`186`	`186`
`187`	`187`	`release = downloadedRelease`
`188`	`188`	`}`
	`189`	`+ fmt.Printf("**** Release: %+v\n", release)`
`189`	`190`
`190`	`191`	`application := findAppInRelease(release) // this function never returns nil`
`191`	`192`
`@@ -301,8 +302,9 @@ func downloadReplicated(`
`301`	`302`	`ReplicatedRegistryDomain: release.ReplicatedRegistryDomain,`
`302`	`303`	`ReplicatedProxyDomain: release.ReplicatedProxyDomain,`
`303`	`304`	`ReplicatedChartNames: release.ReplicatedChartNames,`
`304`		`- EmbeddedClusterArtifacts: embeddedClusterArtifacts,`
	`305`	`+ EmbeddedClusterArtifacts: release.EmbeddedClusterArtifacts,`
`305`	`306`	`}`
	`307`	`+ fmt.Printf("**** Upstream: %+v\n", upstream)`
`306`	`308`
`307`	`309`	`return upstream, nil`
`308`	`310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ func Upgrade(appSlug string, options UpgradeOptions) (*UpgradeResponse, error) {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`if !options.DisableImagePush {`
`72`		`- _, err := image.TagAndPushImagesFromBundle(options.AirgapBundle, pushOptions)`
	`72`	`+ err := image.TagAndPushImagesFromBundle(options.AirgapBundle, pushOptions)`
`73`	`73`	`if err != nil {`
`74`	`74`	`return nil, errors.Wrap(err, "failed to tag and push app images from path")`
`75`	`75`	`}`