Merge branch 'zarf-dev:main' into main

Author: AustinAbro321

main.go

@@ -12,13 +12,16 @@ import (
 	"syscall"
 
 	"github.com/zarf-dev/zarf/src/cmd"
+	"github.com/zarf-dev/zarf/src/config"
 	"github.com/zarf-dev/zarf/src/pkg/lint"
 )
 
 //go:embed zarf.schema.json
 var zarfSchema embed.FS
 
 func main() {
+	// This ensures `./zarf` actions call the current Zarf binary over the system Zarf binary
+	config.ActionsUseSystemZarf = false
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	signalCh := make(chan os.Signal, 1)

src/cmd/package.go

@@ -1237,7 +1237,8 @@ func (o *packagePublishOptions) run(cmd *cobra.Command, args []string) error {
 			RemoteOptions:      defaultRemoteOptions(),
 			CachePath:          cachePath,
 		}
-		return packager.PublishSkeleton(ctx, packageSource, dstRef, skeletonOpts)
+		_, err = packager.PublishSkeleton(ctx, packageSource, dstRef, skeletonOpts)
+		return err
 	}
 
 	if helpers.IsOCIURL(packageSource) && pkgConfig.PublishOpts.SigningKeyPath == "" {
@@ -1313,7 +1314,8 @@ func (o *packagePublishOptions) run(cmd *cobra.Command, args []string) error {
 		RemoteOptions:      defaultRemoteOptions(),
 	}
 
-	return packager.PublishPackage(ctx, pkgLayout, dstRef, publishPackageOpts)
+	_, err = packager.PublishPackage(ctx, pkgLayout, dstRef, publishPackageOpts)
+	return err
 }
 
 type packagePullOptions struct{}

src/config/config.go

@@ -42,7 +42,7 @@ var (
 	CLIVersion = UnsetCLIVersion
 
 	// ActionsUseSystemZarf sets whether to use Zarf from the system path if Zarf is being used as a library
-	ActionsUseSystemZarf = false
+	ActionsUseSystemZarf = true
 
 	// ActionsCommandZarfPrefix sets a sub command prefix that Zarf commands are under in the current binary if Zarf is being used as a library (and use system Zarf is not specified)
 	ActionsCommandZarfPrefix = ""

src/pkg/packager/create.go

@@ -75,7 +75,7 @@ func Create(ctx context.Context, packagePath string, output string, opts CreateO
 		if err != nil {
 			return "", err
 		}
-		remote, err := zoci.NewRemote(ctx, ref, oci.PlatformForArch(pkgLayout.Pkg.Build.Architecture),
+		remote, err := zoci.NewRemote(ctx, ref.String(), oci.PlatformForArch(pkgLayout.Pkg.Build.Architecture),
 			oci.WithPlainHTTP(opts.PlainHTTP), oci.WithInsecureSkipVerify(opts.InsecureSkipTLSVerify))
 		if err != nil {
 			return "", err
@@ -84,7 +84,7 @@ func Create(ctx context.Context, packagePath string, output string, opts CreateO
 		if err != nil {
 			return "", err
 		}
-		packageLocation = ref
+		packageLocation = ref.String()
 	} else {
 		packageLocation, err = pkgLayout.Archive(ctx, output, opts.MaxPackageSizeMB)
 		if err != nil {

src/pkg/packager/publish.go

@@ -33,6 +33,7 @@ type PublishFromOCIOptions struct {
 }
 
 // PublishFromOCI takes a source and destination registry reference and a PublishFromOCIOpts and copies the package from the source to the destination.
+// src and dst are references to the full package ref, e.g. my-registry.com/my-namespace/my-package:0.0.1
 func PublishFromOCI(ctx context.Context, src registry.Reference, dst registry.Reference, opts PublishFromOCIOptions) (err error) {
 	l := logger.From(ctx)
 	start := time.Now()
@@ -89,24 +90,35 @@ type PublishPackageOptions struct {
 	RemoteOptions
 }
 
-// PublishPackage takes a Path to the location of the built package, a ref to a registry, and a PublishOpts and uploads to the target OCI registry.
-func PublishPackage(ctx context.Context, pkgLayout *layout.PackageLayout, dst registry.Reference, opts PublishPackageOptions) error {
+// PublishPackage takes a package layout and pushes the package to the given registry.
+// dst is the path to the registry namespace, e.g. my-registry.com/my-namespace. The full package ref is created using the package name and returned
+func PublishPackage(ctx context.Context, pkgLayout *layout.PackageLayout, dst registry.Reference, opts PublishPackageOptions) (registry.Reference, error) {
 	l := logger.From(ctx)
 
 	// Validate inputs
 	l.Debug("validating PublishOpts")
 	if err := dst.ValidateRegistry(); err != nil {
-		return fmt.Errorf("invalid registry: %w", err)
+		return registry.Reference{}, fmt.Errorf("invalid registry: %w", err)
 	}
 	if pkgLayout == nil {
-		return fmt.Errorf("package layout must be specified")
+		return registry.Reference{}, fmt.Errorf("package layout must be specified")
 	}
 
 	if err := pkgLayout.SignPackage(opts.SigningKeyPath, opts.SigningKeyPassword); err != nil {
-		return fmt.Errorf("unable to sign package: %w", err)
+		return registry.Reference{}, fmt.Errorf("unable to sign package: %w", err)
 	}
 
-	return pushToRemote(ctx, pkgLayout, dst, opts.OCIConcurrency, opts.RemoteOptions)
+	// Build Reference for remote from registry location and pkg
+	pkgRef, err := zoci.ReferenceFromMetadata(dst.String(), pkgLayout.Pkg)
+	if err != nil {
+		return registry.Reference{}, err
+	}
+
+	if err := pushToRemote(ctx, pkgLayout, pkgRef, opts.OCIConcurrency, opts.RemoteOptions); err != nil {
+		return registry.Reference{}, err
+	}
+
+	return pkgRef, nil
 }
 
 // PublishSkeletonOptions declares the parameters to publish a skeleton package.
@@ -122,17 +134,18 @@ type PublishSkeletonOptions struct {
 	RemoteOptions
 }
 
-// PublishSkeleton takes a Path to the location of the build package, a ref to a registry, and a PublishOpts and uploads the skeleton package to the target OCI registry.
-func PublishSkeleton(ctx context.Context, path string, ref registry.Reference, opts PublishSkeletonOptions) error {
+// PublishSkeleton takes a Path to the package definition and uploads a skeleton package to the given a registry.
+// dst is the path to the registry namespace, e.g. my-registry.com/my-namespace. The full package ref is created using the package name and returned
+func PublishSkeleton(ctx context.Context, path string, ref registry.Reference, opts PublishSkeletonOptions) (registry.Reference, error) {
 	l := logger.From(ctx)
 
 	// Validate inputs
 	l.Debug("validating PublishOpts")
 	if err := ref.ValidateRegistry(); err != nil {
-		return fmt.Errorf("invalid registry: %w", err)
+		return registry.Reference{}, fmt.Errorf("invalid registry: %w", err)
 	}
 	if path == "" {
-		return fmt.Errorf("path must be specified")
+		return registry.Reference{}, fmt.Errorf("path must be specified")
 	}
 
 	// Load package layout
@@ -141,7 +154,7 @@ func PublishSkeleton(ctx context.Context, path string, ref registry.Reference, o
 		CachePath: opts.CachePath,
 	})
 	if err != nil {
-		return err
+		return registry.Reference{}, err
 	}
 	// Create skeleton buildpath
 	createOpts := layout.AssembleSkeletonOptions{
@@ -150,16 +163,16 @@ func PublishSkeleton(ctx context.Context, path string, ref registry.Reference, o
 	}
 	pkgLayout, err := layout.AssembleSkeleton(ctx, pkg, path, createOpts)
 	if err != nil {
-		return fmt.Errorf("unable to create skeleton: %w", err)
+		return registry.Reference{}, fmt.Errorf("unable to create skeleton: %w", err)
 	}
-
-	err = pushToRemote(ctx, pkgLayout, ref, opts.OCIConcurrency, opts.RemoteOptions)
+	// Build Reference for remote from registry location and pkg
+	pkgRef, err := zoci.ReferenceFromMetadata(ref.String(), pkgLayout.Pkg)
 	if err != nil {
-		return err
+		return registry.Reference{}, err
 	}
-	packageRef, err := zoci.ReferenceFromMetadata(ref.String(), pkgLayout.Pkg)
+	err = pushToRemote(ctx, pkgLayout, pkgRef, opts.OCIConcurrency, opts.RemoteOptions)
 	if err != nil {
-		return err
+		return registry.Reference{}, err
 	}
 	l.Info("skeleton packages contain metadata and local resources to allow for remote component imports")
 	ex := []v1alpha1.ZarfComponent{}
@@ -168,31 +181,25 @@ func PublishSkeleton(ctx context.Context, path string, ref registry.Reference, o
 			Name: fmt.Sprintf("import-%s", c.Name),
 			Import: v1alpha1.ZarfComponentImport{
 				Name: c.Name,
-				URL:  helpers.OCIURLPrefix + packageRef,
+				URL:  helpers.OCIURLPrefix + pkgRef.String(),
 			},
 		})
 	}
-	err = utils.ColorPrintYAML(ex, nil, true)
+	err = utils.ColorPrintYAML(ex, nil, false)
 	if err != nil {
-		return err
+		return registry.Reference{}, err
 	}
 	l.Info("find more info on skeleton packages at https://docs.zarf.dev/faq/#what-is-a-skeleton-zarf-package")
-	return nil
+	return pkgRef, nil
 }
 
-// pushToRemote pushes a package to a remote at ref.
+// pushToRemote pushes a package to the given reference
 func pushToRemote(ctx context.Context, layout *layout.PackageLayout, ref registry.Reference, concurrency int, remoteOpts RemoteOptions) error {
-	// Build Reference for remote from registry location and pkg
-	r, err := zoci.ReferenceFromMetadata(ref.String(), layout.Pkg)
-	if err != nil {
-		return err
-	}
-
 	arch := layout.Pkg.Metadata.Architecture
 	// Set platform
-	p := oci.PlatformForArch(arch)
+	platform := oci.PlatformForArch(arch)
 
-	remote, err := zoci.NewRemote(ctx, r, p, oci.WithPlainHTTP(remoteOpts.PlainHTTP), oci.WithInsecureSkipVerify(remoteOpts.InsecureSkipTLSVerify))
+	remote, err := zoci.NewRemote(ctx, ref.String(), platform, oci.WithPlainHTTP(remoteOpts.PlainHTTP), oci.WithInsecureSkipVerify(remoteOpts.InsecureSkipTLSVerify))
 	if err != nil {
 		return fmt.Errorf("could not instantiate remote: %w", err)
 	}

src/pkg/packager/publish_test.go

@@ -104,7 +104,7 @@ func TestPublishError(t *testing.T) {
 
 	for _, tc := range tt {
 		t.Run(tc.name, func(t *testing.T) {
-			err := PublishPackage(context.Background(), tc.packageLayout, tc.ref, tc.opts)
+			_, err := PublishPackage(context.Background(), tc.packageLayout, tc.ref, tc.opts)
 			require.ErrorContains(t, err, tc.expectErr.Error())
 		})
 	}
@@ -191,7 +191,7 @@ func TestPublishSkeleton(t *testing.T) {
 			registryRef := createRegistry(ctx, t)
 
 			// Publish test package
-			err := PublishSkeleton(ctx, tc.path, registryRef, tc.opts)
+			ref, err := PublishSkeleton(ctx, tc.path, registryRef, tc.opts)
 			require.NoError(t, err)
 
 			// Read and unmarshall expected
@@ -203,10 +203,7 @@ func TestPublishSkeleton(t *testing.T) {
 			// This verifies that publish deletes the manifest that is auto created by oras
 			require.NoFileExists(t, expectedPkg.Metadata.Name)
 
-			// Format url and instantiate remote
-			ref, err := zoci.ReferenceFromMetadata(registryRef.String(), expectedPkg)
-			require.NoError(t, err)
-			rmt, err := zoci.NewRemote(ctx, ref, zoci.PlatformForSkeleton(), oci.WithPlainHTTP(true))
+			rmt, err := zoci.NewRemote(ctx, ref.String(), zoci.PlatformForSkeleton(), oci.WithPlainHTTP(true))
 			require.NoError(t, err)
 
 			// Fetch from remote and compare
@@ -261,14 +258,10 @@ func TestPublishPackage(t *testing.T) {
 			require.NoError(t, err)
 
 			// Publish test package
-			err = PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
-			require.NoError(t, err)
-
-			// Format url and instantiate remote
-			packageRef, err := zoci.ReferenceFromMetadata(registryRef.String(), layoutExpected.Pkg)
+			packageRef, err := PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
 			require.NoError(t, err)
 
-			layoutActual := pullFromRemote(ctx, t, packageRef, "amd64", tc.publicKeyPath, t.TempDir())
+			layoutActual := pullFromRemote(ctx, t, packageRef.String(), "amd64", tc.publicKeyPath, t.TempDir())
 			require.Equal(t, layoutExpected.Pkg, layoutActual.Pkg, "Uploaded package is not identical to downloaded package")
 			if tc.opts.SigningKeyPath != "" {
 				require.FileExists(t, filepath.Join(layoutActual.DirPath(), layout.Signature))
@@ -302,23 +295,19 @@ func TestPublishPackageDeterministic(t *testing.T) {
 			require.NoError(t, err)
 
 			// Publish test package
-			err = PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
-			require.NoError(t, err)
-
-			// Format url and instantiate remote
-			packageRef, err := zoci.ReferenceFromMetadata(registryRef.String(), layoutExpected.Pkg)
+			packageRef, err := PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
 			require.NoError(t, err)
 
 			// Attempt to get the digest
 			platform := oci.PlatformForArch(layoutExpected.Pkg.Build.Architecture)
-			remote, err := zoci.NewRemote(ctx, packageRef, platform, oci.WithPlainHTTP(tc.opts.PlainHTTP))
+			remote, err := zoci.NewRemote(ctx, packageRef.String(), platform, oci.WithPlainHTTP(tc.opts.PlainHTTP))
 			require.NoError(t, err)
 			desc, err := remote.ResolveRoot(ctx)
 			require.NoError(t, err)
 			expectedDigest := desc.Digest.String()
 
 			// Re-publish the package to ensure the digest does not change
-			err = PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
+			_, err = PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
 			require.NoError(t, err)
 			// Publish creates a local oci manifest file using the package name, which gets deleted
 			require.NoFileExists(t, layoutExpected.Pkg.Metadata.Name)
@@ -357,21 +346,19 @@ func TestPublishCopySHA(t *testing.T) {
 			require.NoError(t, err)
 
 			// Publish test package
-			err = PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
+			srcRef, err := PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
 			require.NoError(t, err)
 
 			// Setup destination registry
 			dstRegistryRef := createRegistry(ctx, t)
 
 			// This gets the test package digest from the first package publish
 			localRepo := &remote.Repository{PlainHTTP: true}
-			ociSrc := fmt.Sprintf("%s/%s", registryRef.String(), "test:0.0.1")
-			localRepo.Reference, err = registry.ParseReference(ociSrc)
+			localRepo.Reference = srcRef
+			indexDesc, err := oras.Resolve(ctx, localRepo, srcRef.String(), oras.ResolveOptions{})
 			require.NoError(t, err)
-			indexDesc, err := oras.Resolve(ctx, localRepo, ociSrc, oras.ResolveOptions{})
-			require.NoError(t, err)
-			src := fmt.Sprintf("%s/%s@%s", registryRef.String(), "test:0.0.1", indexDesc.Digest)
-			srcRef, err := registry.ParseReference(src)
+			src := fmt.Sprintf("%s@%s", srcRef, indexDesc.Digest)
+			srcRefWithDigest, err := registry.ParseReference(src)
 			require.NoError(t, err)
 
 			dst := fmt.Sprintf("%s/%s", dstRegistryRef.String(), "test:0.0.1")
@@ -385,18 +372,15 @@ func TestPublishCopySHA(t *testing.T) {
 			}
 
 			// Publish test package to the destination registry
-			err = PublishFromOCI(ctx, srcRef, dstRef, opts)
+			err = PublishFromOCI(ctx, srcRefWithDigest, dstRef, opts)
 			require.NoError(t, err)
 
 			// This verifies that publish deletes the manifest that is auto created by oras
 			require.NoFileExists(t, layoutExpected.Pkg.Metadata.Name)
-			// Format url and instantiate remote
-			packageRef, err := zoci.ReferenceFromMetadata(dstRegistryRef.String(), layoutExpected.Pkg)
-			require.NoError(t, err)
 
-			pkgRefsha := fmt.Sprintf("%s@%s", packageRef, indexDesc.Digest)
+			pkgRefSha := fmt.Sprintf("%s@%s", dstRef.String(), indexDesc.Digest)
 
-			layoutActual := pullFromRemote(ctx, t, pkgRefsha, layoutExpected.Pkg.Build.Architecture, "", t.TempDir())
+			layoutActual := pullFromRemote(ctx, t, pkgRefSha, layoutExpected.Pkg.Build.Architecture, "", t.TempDir())
 			require.Equal(t, layoutExpected.Pkg, layoutActual.Pkg, "Uploaded package is not identical to downloaded package")
 		})
 	}
@@ -428,14 +412,11 @@ func TestPublishCopyTag(t *testing.T) {
 			require.NoError(t, err)
 
 			// Publish test package
-			err = PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
+			srcRef, err := PublishPackage(ctx, layoutExpected, registryRef, tc.opts)
 			require.NoError(t, err)
 
 			dstRegistryRef := createRegistry(ctx, t)
 
-			src := fmt.Sprintf("%s/%s", registryRef.String(), "test:0.0.1")
-			srcRegistry, err := registry.ParseReference(src)
-			require.NoError(t, err)
 			dst := fmt.Sprintf("%s/%s", dstRegistryRef.String(), "test:0.0.1")
 			dstRegistry, err := registry.ParseReference(dst)
 			require.NoError(t, err)
@@ -447,16 +428,13 @@ func TestPublishCopyTag(t *testing.T) {
 			}
 
 			// Publish test package
-			err = PublishFromOCI(ctx, srcRegistry, dstRegistry, opts)
+			err = PublishFromOCI(ctx, srcRef, dstRegistry, opts)
 			require.NoError(t, err)
 
 			// This verifies that publish deletes the manifest that is auto created by oras
 			require.NoFileExists(t, layoutExpected.Pkg.Metadata.Name)
-			// Format url and instantiate remote
-			packageRef, err := zoci.ReferenceFromMetadata(dstRegistryRef.String(), layoutExpected.Pkg)
-			require.NoError(t, err)
 
-			layoutActual := pullFromRemote(ctx, t, packageRef, layoutExpected.Pkg.Build.Architecture, "", t.TempDir())
+			layoutActual := pullFromRemote(ctx, t, dstRegistry.String(), layoutExpected.Pkg.Build.Architecture, "", t.TempDir())
 
 			require.Equal(t, layoutExpected.Pkg, layoutActual.Pkg, "Uploaded package is not identical to downloaded package")
 		})

src/pkg/utils/io.go

@@ -49,19 +49,20 @@ func GetFinalExecutablePath() (string, error) {
 // GetFinalExecutableCommand returns the final path to the Zarf executable including and library prefixes and overrides.
 func GetFinalExecutableCommand() (string, error) {
 	// In case the binary is symlinked somewhere else, get the final destination
-	zarfCommand, err := GetFinalExecutablePath()
+	executablePath, err := GetFinalExecutablePath()
 	if err != nil {
 		return "", err
 	}
 
+	// If ActionCommandZarfPrefix is set it takes priority
 	if config.ActionsCommandZarfPrefix != "" {
-		zarfCommand = fmt.Sprintf("%s %s", zarfCommand, config.ActionsCommandZarfPrefix)
+		return fmt.Sprintf("%s %s", executablePath, config.ActionsCommandZarfPrefix), nil
 	}
 
-	// If a library user has chosen to override config to use system Zarf instead, reset the binary path.
+	// If a library user is calling Zarf we default to using system Zarf otherwise main sets this to false for CLI users
 	if config.ActionsUseSystemZarf {
-		zarfCommand = "zarf"
+		return "zarf", nil
 	}
 
-	return zarfCommand, nil
+	return executablePath, nil
 }