Some OCI Optimizations

src/config/config.go

@@ -57,6 +57,8 @@ const (
 	ZarfSBOMTar       = "sboms.tar"
 	ZarfPackagePrefix = "zarf-package-"
 
+	ZarfComponentsDir = "components"
+
 	ZarfInClusterContainerRegistryNodePort = 31999
 
 	ZarfInClusterGitServiceURL      = "http://zarf-gitea-http.zarf.svc.cluster.local:3000"

src/pkg/packager/common.go

@@ -224,7 +224,7 @@ func createPaths() (paths types.TempPaths, err error) {
 		InjectBinary: filepath.Join(basePath, "zarf-injector"),
 		SeedImages:   filepath.Join(basePath, "seed-images"),
 		Images:       filepath.Join(basePath, "images"),
-		Components:   filepath.Join(basePath, "components"),
+		Components:   filepath.Join(basePath, config.ZarfComponentsDir),
 		SbomTar:      filepath.Join(basePath, config.ZarfSBOMTar),
 		Sboms:        filepath.Join(basePath, "sboms"),
 		Checksums:    filepath.Join(basePath, config.ZarfChecksumsTxt),
@@ -272,7 +272,7 @@ func (p *Packager) loadZarfPkg() error {
 	}
 
 	// Load the config from the extracted archive zarf.yaml
-	spinner.Updatef("Loading the zarf package config")
+	spinner.Updatef("Loading the Zarf package config")
 	configPath := p.tmp.ZarfYaml
 	if err := p.readYaml(configPath); err != nil {
 		return fmt.Errorf("unable to read the zarf.yaml in %s: %w", p.tmp.Base, err)
@@ -474,7 +474,13 @@ func (p *Packager) validatePackageChecksums() error {
 		itemPath := strs[1]
 		expectedShasum := strs[0]
 
-		actualShasum, err := utils.GetSHA256OfFile(filepath.Join(p.tmp.Base, itemPath))
+		path := filepath.Join(p.tmp.Base, itemPath)
+		if utils.InvalidPath(path) {
+			message.Debugf("skipping checksum of %s as it does not exist", path)
+			continue
+		}
+
+		actualShasum, err := utils.GetSHA256OfFile(path)
 		if err != nil {
 			return err
 		}
@@ -483,7 +489,7 @@ func (p *Packager) validatePackageChecksums() error {
 			return fmt.Errorf("mismatch on the checksum of the %s file (expected: %s, actual: %s)", itemPath, expectedShasum, actualShasum)
 		}
 
-		filepathMap[filepath.Join(p.tmp.Base, itemPath)] = true
+		filepathMap[path] = true
 	}
 
 	for path, processed := range filepathMap {

src/pkg/packager/compose.go

@@ -98,7 +98,7 @@ func (p *Packager) getChildComponent(parent types.ZarfComponent, pathAncestry st
 			return child, fmt.Errorf("unable to create cache path %s: %w", cachePath, err)
 		}
 
-		componentLayer := filepath.Join("components", fmt.Sprintf("%s.tar", childComponentName))
+		componentLayer := filepath.Join(config.ZarfComponentsDir, fmt.Sprintf("%s.tar", childComponentName))
 		err = p.handleOciPackage(skelURL, cachePath, 3, componentLayer)
 		if err != nil {
 			return child, fmt.Errorf("unable to pull skeleton from %s: %w", skelURL, err)
@@ -145,15 +145,15 @@ func (p *Packager) getChildComponent(parent types.ZarfComponent, pathAncestry st
 
 	// If it's OCI, we need to unpack the component tarball
 	if parent.Import.URL != "" {
-		dir := filepath.Join(cachePath, "components", child.Name)
-		parent.Import.Path = filepath.Join(parent.Import.Path, "components", child.Name)
+		dir := filepath.Join(cachePath, config.ZarfComponentsDir, child.Name)
+		parent.Import.Path = filepath.Join(parent.Import.Path, config.ZarfComponentsDir, child.Name)
 		if !utils.InvalidPath(dir) {
 			err = os.RemoveAll(dir)
 			if err != nil {
 				return child, fmt.Errorf("unable to remove composed component cache path %s: %w", cachePath, err)
 			}
 		}
-		err = archiver.Unarchive(fmt.Sprintf("%s.tar", dir), filepath.Join(cachePath, "components"))
+		err = archiver.Unarchive(fmt.Sprintf("%s.tar", dir), filepath.Join(cachePath, config.ZarfComponentsDir))
 		if err != nil {
 			return child, fmt.Errorf("unable to unpack composed component tarball: %w", err)
 		}

src/pkg/packager/network.go

@@ -17,13 +17,21 @@ import (
 	"github.com/defenseunicorns/zarf/src/config"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/types"
+	goyaml "github.com/goccy/go-yaml"
 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 	"oras.land/oras-go/v2"
 	"oras.land/oras-go/v2/content"
 	"oras.land/oras-go/v2/content/file"
 	"oras.land/oras-go/v2/registry"
 )
 
+var (
+	indexPath    = filepath.Join("images", "index.json")
+	ociLayoutPat = filepath.Join("images", "oci-layout")
+	blobsDir     = filepath.Join("images", "blobs", "sha256")
+)
+
 // handlePackagePath If provided package is a URL download it to a temp directory.
 func (p *Packager) handlePackagePath() error {
 	message.Debug("packager.handlePackagePath()")
@@ -41,7 +49,22 @@ func (p *Packager) handlePackagePath() error {
 	if utils.IsOCIURL(opts.PackagePath) {
 		ociURL := opts.PackagePath
 		p.cfg.DeployOpts.PackagePath = p.tmp.Base
-		return p.handleOciPackage(ociURL, p.tmp.Base, p.cfg.PublishOpts.CopyOptions.Concurrency)
+		requestedComponents := getRequestedComponentList(p.cfg.DeployOpts.Components)
+		layersToPull := []string{}
+		for _, c := range requestedComponents {
+			layersToPull = append(layersToPull, filepath.Join(config.ZarfComponentsDir, fmt.Sprintf("%s.tar", c)))
+		}
+		if len(requestedComponents) > 0 {
+			layersToPull = append(layersToPull, config.ZarfSBOMTar)
+			layersToPull = append(layersToPull, ociLayoutPat)
+			layersToPull = append(layersToPull, indexPath)
+			layers, err := getLayersToPullFromRequestedComponents(ociURL, requestedComponents)
+			if err != nil {
+				return fmt.Errorf("unable to get published component image layers: %s", err.Error())
+			}
+			layersToPull = append(layersToPull, layers...)
+		}
+		return p.handleOciPackage(ociURL, p.tmp.Base, p.cfg.PublishOpts.CopyOptions.Concurrency, layersToPull...)
 	}
 
 	// Handle case where deploying remote package validated via sget
@@ -159,18 +182,8 @@ func (p *Packager) handleOciPackage(url string, out string, concurrency int, lay
 
 	copyOpts := oras.DefaultCopyOptions
 	copyOpts.Concurrency = concurrency
-	copyOpts.OnCopySkipped = func(ctx context.Context, desc ocispec.Descriptor) error {
-		title := desc.Annotations[ocispec.AnnotationTitle]
-		var format string
-		if title != "" {
-			format = fmt.Sprintf("%s %s", desc.Digest.Encoded()[:12], utils.First30last30(title))
-		} else {
-			format = fmt.Sprintf("%s [%s]", desc.Digest.Encoded()[:12], desc.MediaType)
-		}
-		message.Successf(format)
-		return nil
-	}
-	copyOpts.PostCopy = copyOpts.OnCopySkipped
+	copyOpts.OnCopySkipped = utils.PrintLayerExists
+	copyOpts.PostCopy = utils.PrintLayerExists
 	isPartialPull := len(layers) > 0
 	if isPartialPull {
 		alwaysPull := []string{config.ZarfYAML, config.ZarfChecksumsTxt, config.ZarfYAMLSignature}
@@ -272,3 +285,87 @@ func pullLayer(dst *utils.OrasRemote, desc ocispec.Descriptor, out string) error
 	err = utils.WriteFile(out, bytes)
 	return err
 }
+
+// getLayersToPullFromRequestedComponents returns a list of layers to pull from a Zarf OCI package given a list of components
+func getLayersToPullFromRequestedComponents(url string, requestedComponents []string) (layers []string, err error) {
+	ref, err := registry.ParseReference(strings.TrimPrefix(url, utils.OCIURLPrefix))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse OCI reference: %w", err)
+	}
+	src, err := utils.NewOrasRemote(ref)
+	if err != nil {
+		return nil, err
+	}
+	manifest, err := getManifest(src)
+	if err != nil {
+		return nil, err
+	}
+	zarfYamlDescriptor := utils.Find(manifest.Layers, func(layer ocispec.Descriptor) bool {
+		return layer.Annotations[ocispec.AnnotationTitle] == config.ZarfYAML
+	})
+	zarfYamlBytes, err := content.FetchAll(src.Context, src, zarfYamlDescriptor)
+	if err != nil {
+		return nil, err
+	}
+	pkg := types.ZarfPackage{}
+	err = goyaml.Unmarshal(zarfYamlBytes, &pkg)
+	if err != nil {
+		return nil, err
+	}
+	images := []string{}
+	for _, name := range requestedComponents {
+		component := utils.Find(pkg.Components, func(component types.ZarfComponent) bool {
+			return component.Name == name
+		})
+		if component.Name == "" {
+			return nil, fmt.Errorf("component %s does not exist in this package", name)
+		}
+	}
+	for _, component := range pkg.Components {
+		// If we requested this component, or it is required, we need to pull its images
+		if utils.SliceContains(requestedComponents, component.Name) || component.Required {
+			images = append(images, component.Images...)
+		}
+		// If we did not request this component, but it is required, we need to pull it
+		if !utils.SliceContains(requestedComponents, component.Name) && component.Required {
+			layers = append(layers, filepath.Join(config.ZarfComponentsDir, component.Name))
+		}
+	}
+
+	if len(images) > 0 {
+		indexDescriptor := utils.Find(manifest.Layers, func(layer ocispec.Descriptor) bool {
+			return layer.Annotations[ocispec.AnnotationTitle] == indexPath
+		})
+		indexBytes, err := content.FetchAll(src.Context, src, indexDescriptor)
+		if err != nil {
+			return nil, err
+		}
+		index := ocispec.Index{}
+		err = json.Unmarshal(indexBytes, &index)
+		if err != nil {
+			return nil, err
+		}
+		for _, image := range images {
+			manifestDescriptor := utils.Find(index.Manifests, func(layer ocispec.Descriptor) bool {
+				return layer.Annotations[ocispec.AnnotationBaseImageName] == image
+			})
+			manifestBytes, err := content.FetchAll(src.Context, src, manifestDescriptor)
+			if err != nil {
+				return nil, err
+			}
+			manifest := ocispec.Manifest{}
+			err = json.Unmarshal(manifestBytes, &manifest)
+			if err != nil {
+				return nil, err
+			}
+			layers = append(layers, filepath.Join(blobsDir, strings.TrimPrefix(manifestDescriptor.Digest.String(), "sha256:")))
+			layers = append(layers, filepath.Join(blobsDir, strings.TrimPrefix(manifest.Config.Digest.String(), "sha256:")))
+			for _, layer := range manifest.Layers {
+				pathInPkg := filepath.Join(blobsDir, strings.TrimPrefix(layer.Digest.String(), "sha256:"))
+				layers = append(layers, pathInPkg)
+			}
+		}
+	}
+
+	return layers, nil
+}