change mirror to use new logic

Signed-off-by: Austin Abro <[email protected]>

Author: AustinAbro321

src/internal/packager2/layout/package.go

@@ -183,25 +183,37 @@ func (p *PackageLayout) GetComponentDir(destPath, componentName string, ct Compo
 // GetImage returns the image with the given reference in the package layout.
 func (p *PackageLayout) GetImage(ref transform.Image) (registryv1.Image, error) {
 	// Use the manifest within the index.json to load the specific image we want
-	layoutPath := layout.Path(filepath.Join(p.dirPath, ImagesDir))
+	imgPath := filepath.Join(p.dirPath, ImagesDir)
+	layoutPath := layout.Path(imgPath)
 	imgIdx, err := layoutPath.ImageIndex()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get image index: %w", err)
 	}
 	idxManifest, err := imgIdx.IndexManifest()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get image manifest: %w", err)
 	}
+
 	// Search through all the manifests within this package until we find the annotation that matches our ref
 	for _, manifest := range idxManifest.Manifests {
-		if manifest.Annotations[ocispec.AnnotationBaseImageName] == ref.Reference ||
+		if manifest.Annotations[ocispec.AnnotationRefName] == ref.Reference ||
 			// A backwards compatibility shim for older Zarf versions that would leave docker.io off of image annotations
-			(manifest.Annotations[ocispec.AnnotationBaseImageName] == ref.Path+ref.TagOrDigest && ref.Host == "docker.io") {
+			(manifest.Annotations[ocispec.AnnotationRefName] == ref.Path+ref.TagOrDigest && ref.Host == "docker.io") {
 			// This is the image we are looking for, load it and then return
-			return layoutPath.Image(manifest.Digest)
+			img, err := layoutPath.Image(manifest.Digest)
+			if err != nil {
+				return nil, fmt.Errorf("failed to lookup image %s: %w", ref.Reference, err)
+			}
+			return img, nil
 		}
 	}
-	return nil, fmt.Errorf("unable to find the image %s", ref.Reference)
+
+	return nil, fmt.Errorf("unable to find image (%s) at the path (%s)", ref.Reference, imgPath)
+}
+
+func (p *PackageLayout) GetImageDir() string {
+	// Use the manifest within the index.json to load the specific image we want
+	return filepath.Join(p.dirPath, ImagesDir)
 }
 
 func (p *PackageLayout) Archive(ctx context.Context, dirPath string, maxPackageSize int) error {

src/internal/packager2/mirror.go

@@ -7,20 +7,16 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"net/http"
 	"os"
 	"time"
 
 	"github.com/avast/retry-go/v4"
-	"github.com/defenseunicorns/pkg/helpers/v2"
-	"github.com/google/go-containerregistry/pkg/authn"
-	"github.com/google/go-containerregistry/pkg/crane"
-	v1 "github.com/google/go-containerregistry/pkg/v1"
 
 	"github.com/zarf-dev/zarf/src/config"
 	"github.com/zarf-dev/zarf/src/internal/dns"
 	"github.com/zarf-dev/zarf/src/internal/git"
 	"github.com/zarf-dev/zarf/src/internal/gitea"
+	"github.com/zarf-dev/zarf/src/internal/packager/images"
 	"github.com/zarf-dev/zarf/src/internal/packager2/layout"
 	"github.com/zarf-dev/zarf/src/pkg/cluster"
 	"github.com/zarf-dev/zarf/src/pkg/logger"
@@ -56,113 +52,36 @@ func Mirror(ctx context.Context, opt MirrorOptions) error {
 }
 
 func pushImagesToRegistry(ctx context.Context, c *cluster.Cluster, pkgLayout *layout.PackageLayout, filter filters.ComponentFilterStrategy, regInfo types.RegistryInfo, noImgChecksum bool, retries int) error {
-	l := logger.From(ctx)
-
 	components, err := filter.Apply(pkgLayout.Pkg)
 	if err != nil {
 		return err
 	}
 
-	images := map[transform.Image]v1.Image{}
+	refs := []transform.Image{}
 	for _, component := range components {
 		for _, img := range component.Images {
 			ref, err := transform.ParseImageRef(img)
 			if err != nil {
 				return fmt.Errorf("failed to create ref for image %s: %w", img, err)
 			}
-			if _, ok := images[ref]; ok {
-				continue
-			}
-			img, err := pkgLayout.GetImage(ref)
-			if err != nil {
-				return err
-			}
-			images[ref] = img
+			refs = append(refs, ref)
 		}
 	}
-	if len(images) == 0 {
+	if len(refs) == 0 {
 		return nil
 	}
-
-	defaultTransport := http.DefaultTransport.(*http.Transport).Clone()
-	defaultTransport.TLSClientConfig.InsecureSkipVerify = config.CommonOptions.InsecureSkipTLSVerify
-	// TODO (@WSTARR) This is set to match the TLSHandshakeTimeout to potentially mitigate effects of https://github.com/zarf-dev/zarf/issues/1444
-	defaultTransport.ResponseHeaderTimeout = 10 * time.Second
-	transport := helpers.NewTransport(defaultTransport, nil)
-
-	pushOptions := []crane.Option{
-		crane.WithPlatform(&v1.Platform{OS: "linux", Architecture: pkgLayout.Pkg.Build.Architecture}),
-		crane.WithTransport(transport),
-		crane.WithAuth(authn.FromConfig(authn.AuthConfig{
-			Username: regInfo.PushUsername,
-			Password: regInfo.PushPassword,
-		})),
-		crane.WithUserAgent("zarf"),
-		crane.WithNoClobber(true),
-		crane.WithJobs(1),
+	pushCfg := images.PushConfig{
+		// TODO set as an option
+		PlainHTTP:       config.CommonOptions.PlainHTTP,
+		SourceDirectory: pkgLayout.GetImageDir(),
+		ImageList:       refs,
+		NoChecksum:      noImgChecksum,
+		Arch:            pkgLayout.Pkg.Build.Architecture,
+		RegInfo:         regInfo,
 	}
-	if config.CommonOptions.InsecureSkipTLSVerify {
-		pushOptions = append(pushOptions, crane.Insecure)
-	}
-
-	for refInfo, img := range images {
-		err = retry.Do(func() error {
-			pushImage := func(registryUrl string) error {
-				names := []string{}
-				if !noImgChecksum {
-					offlineNameCRC, err := transform.ImageTransformHost(registryUrl, refInfo.Reference)
-					if err != nil {
-						return retry.Unrecoverable(err)
-					}
-					names = append(names, offlineNameCRC)
-				}
-				offlineName, err := transform.ImageTransformHostWithoutChecksum(registryUrl, refInfo.Reference)
-				if err != nil {
-					return retry.Unrecoverable(err)
-				}
-				names = append(names, offlineName)
-				for _, name := range names {
-					message.Infof("Pushing image %s", name)
-					l.Info("pushing image", "name", name)
-					err = crane.Push(img, name, pushOptions...)
-					if err != nil {
-						return err
-					}
-				}
-				return nil
-			}
-
-			if !dns.IsServiceURL(regInfo.Address) {
-				return pushImage(regInfo.Address)
-			}
-
-			if c == nil {
-				return retry.Unrecoverable(errors.New("cannot push to internal OCI registry when cluster is nil"))
-			}
-			namespace, name, port, err := dns.ParseServiceURL(regInfo.Address)
-			if err != nil {
-				return err
-			}
-			tunnel, err := c.NewTunnel(namespace, cluster.SvcResource, name, "", 0, port)
-			if err != nil {
-				return err
-			}
-			_, err = tunnel.Connect(ctx)
-			if err != nil {
-				return err
-			}
-			defer tunnel.Close()
-			err = tunnel.Wrap(func() error {
-				return pushImage(tunnel.Endpoint())
-			})
-			if err != nil {
-				return err
-			}
-			return nil
-		}, retry.Context(ctx), retry.Attempts(uint(retries)), retry.Delay(500*time.Millisecond))
-		if err != nil {
-			return err
-		}
+	err = images.Push(ctx, pushCfg)
+	if err != nil {
+		return fmt.Errorf("failed to mirror images: %w", err)
 	}
 	return nil
 }