feat: dev deploy --ref and --flavor flags

README.md

@@ -288,7 +288,9 @@ The `dev deploy` command performs the following operations
 
 - If local bundle: Creates Zarf packages for all local packages in a bundle
   - Creates the Zarf tarball in the same directory as the `zarf.yaml`
-  - Will only create the Zarf tarball if one does not already exist
+      - Can use `--flavor` flag to specify what flavor of package you want to create
+  - Will only create the Zarf tarball if one does not already exist or can use `--force-create` to force the creation of a new zarf package even if one currently exists
   - Ignores any `kind: ZarfInitConfig` packages in the bundle
   - Creates a bundle from the newly created Zarf packages
 - Deploys the bundle in [YOLO](https://docs.zarf.dev/faq/#what-is-yolo-mode-and-why-would-i-use-it) mode, eliminating the need to do a `zarf init`
+- For remote packages you can specify what package ref you want to deploy by using the `--ref` flag and specifying the package name and desired ref. (example: `--ref podinfo=0.2.0`)

src/cmd/dev.go

@@ -5,6 +5,9 @@
 package cmd
 
 import (
+	"fmt"
+	"strings"
+
 	"github.com/defenseunicorns/pkg/helpers/v2"
 	"github.com/defenseunicorns/uds-cli/src/config"
 	"github.com/defenseunicorns/uds-cli/src/config/lang"
@@ -34,13 +37,24 @@ var devDeployCmd = &cobra.Command{
 		}
 
 		// Check if source is a local bundle
-		localBundle := helpers.IsDir(src)
+		isLocalBundle := isLocalBundle(src)
+
+		// Validate flags
+		err := validateDevDeployFlags(isLocalBundle)
+		if err != nil {
+			message.Fatalf(err, "Failed to validate flags: %s", err.Error())
+		}
+
+		if isLocalBundle {
+			// Populate flavor map
+			err = populateFlavorMap()
+			if err != nil {
+				message.Fatalf(err, "Failed to populate flavor map: %s", err.Error())
+			}
 
-		if localBundle {
 			// Create Bundle
 			setBundleFile(args)
 
-			config.CommonOptions.Confirm = true
 			bundleCfg.CreateOpts.SourceDirectory = src
 		}
 
@@ -58,17 +72,13 @@ var devDeployCmd = &cobra.Command{
 		defer bndlClient.ClearPaths()
 
 		// Create dev bundle
-		if localBundle {
+		if isLocalBundle {
 			// Check if local zarf packages need to be created
 			bndlClient.CreateZarfPkgs()
 
 			if err := bndlClient.Create(); err != nil {
 				message.Fatalf(err, "Failed to create bundle: %s", err.Error())
 			}
-		}
-
-		// Set dev source
-		if localBundle {
 			bndlClient.SetDeploySource(src)
 		} else {
 			bundleCfg.DeployOpts.Source = src
@@ -79,11 +89,52 @@ var devDeployCmd = &cobra.Command{
 	},
 }
 
+// isLocalBundle checks if the bundle source is a local bundle
+func isLocalBundle(src string) bool {
+	return helpers.IsDir(src) || strings.Contains(src, ".tar.zst")
+}
+
+// validateDevDeployFlags validates the flags for dev deploy
+func validateDevDeployFlags(isLocalBundle bool) error {
+	if !isLocalBundle {
+		//Throw error if trying to run with --flavor or --force-create flag with remote bundle
+		if len(bundleCfg.DevDeployOpts.Flavor) > 0 || bundleCfg.DevDeployOpts.ForceCreate {
+			return fmt.Errorf("Cannot use --flavor or --force-create flags with remote bundle")
+		}
+	}
+	return nil
+}
+
+// populateFlavorMap populates the flavor map based on the string input to the --flavor flag
+func populateFlavorMap() error {
+	if bundleCfg.DevDeployOpts.FlavorInput != "" {
+		bundleCfg.DevDeployOpts.Flavor = make(map[string]string)
+		flavorEntries := strings.Split(bundleCfg.DevDeployOpts.FlavorInput, ",")
+		for i, entry := range flavorEntries {
+			entrySplit := strings.Split(entry, "=")
+			if len(entrySplit) != 2 {
+				// check i==0 to check for invalid input (ex. key=value1,value2)
+				if len(entrySplit) == 1 && i == 0 {
+					bundleCfg.DevDeployOpts.Flavor = map[string]string{"": bundleCfg.DevDeployOpts.FlavorInput}
+				} else {
+					return fmt.Errorf("Invalid flavor entry: %s", entry)
+				}
+			} else {
+				bundleCfg.DevDeployOpts.Flavor[entrySplit[0]] = entrySplit[1]
+			}
+		}
+	}
+	return nil
+}
+
 func init() {
 	initViper()
 	rootCmd.AddCommand(devCmd)
 	devCmd.AddCommand(devDeployCmd)
 	devDeployCmd.Flags().StringArrayVarP(&bundleCfg.DeployOpts.Packages, "packages", "p", []string{}, lang.CmdBundleDeployFlagPackages)
+	devDeployCmd.Flags().StringToStringVarP(&bundleCfg.DevDeployOpts.Ref, "ref", "r", map[string]string{}, lang.CmdBundleDeployFlagRef)
+	devDeployCmd.Flags().StringVarP(&bundleCfg.DevDeployOpts.FlavorInput, "flavor", "f", "", lang.CmdBundleCreateFlagFlavor)
+	devDeployCmd.Flags().BoolVar(&bundleCfg.DevDeployOpts.ForceCreate, "force-create", false, lang.CmdBundleCreateForceCreate)
 	devDeployCmd.Flags().BoolVarP(&config.CommonOptions.Confirm, "confirm", "c", false, lang.CmdBundleDeployFlagConfirm)
 	devDeployCmd.Flags().StringToStringVar(&bundleCfg.DeployOpts.SetVariables, "set", nil, lang.CmdBundleDeployFlagSet)
 }

src/cmd/dev_test.go

@@ -0,0 +1,142 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/defenseunicorns/uds-cli/src/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestValidateDevDeployFlags(t *testing.T) {
+	testCases := []struct {
+		name          string
+		localBundle   bool
+		DevDeployOpts types.BundleDevDeployOptions
+		expectError   bool
+	}{
+		{
+			name:        "Local bundle with --ref flag",
+			localBundle: true,
+			DevDeployOpts: types.BundleDevDeployOptions{
+				Ref: map[string]string{"some-key": "some-ref"},
+			},
+			expectError: true,
+		},
+		{
+			name:        "Remote bundle with --ref flag",
+			localBundle: false,
+			DevDeployOpts: types.BundleDevDeployOptions{
+				Ref: map[string]string{"some-key": "some-ref"},
+			},
+			expectError: false,
+		},
+		{
+			name:        "Local bundle with --flavor flag",
+			localBundle: true,
+			DevDeployOpts: types.BundleDevDeployOptions{
+				Flavor: map[string]string{"some-key": "some-flavor"},
+			},
+			expectError: false,
+		},
+		{
+			name:        "Remote bundle with --flavor flag",
+			localBundle: false,
+			DevDeployOpts: types.BundleDevDeployOptions{
+				Flavor: map[string]string{"some-key": "some-flavor"},
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			bundleCfg.DevDeployOpts = tc.DevDeployOpts
+
+			err := validateDevDeployFlags(tc.localBundle)
+			if tc.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestIsLocalBundle(t *testing.T) {
+	testCases := []struct {
+		name string
+		src  string
+		want bool
+	}{
+		{
+			name: "Test with directory",
+			src:  "../cmd/",
+			want: true,
+		},
+		{
+			name: "Test with .tar.zst file",
+			src:  "/path/to/file.tar.zst",
+			want: true,
+		},
+		{
+			name: "Test with other file",
+			src:  "/path/to/file.txt",
+			want: false,
+		},
+		{
+			name: "Test with registry",
+			src:  "ghcr.io/defenseunicorns/uds-cli/nginx",
+			want: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := isLocalBundle(tc.src)
+			require.Equal(t, tc.want, got)
+		})
+	}
+}
+
+func TestPopulateFlavorMap(t *testing.T) {
+	testCases := []struct {
+		name        string
+		FlavorInput string
+		expect      map[string]string
+		expectError bool
+	}{
+		{
+			name:        "Test with valid flavor input",
+			FlavorInput: "key1=value1,key2=value2",
+			expect:      map[string]string{"key1": "value1", "key2": "value2"},
+		},
+		{
+			name:        "Test with single value",
+			FlavorInput: "value1",
+			expect:      map[string]string{"": "value1"},
+		},
+		{
+			name:        "Test with invalid flavor input",
+			FlavorInput: "key1=value1,key2",
+			expectError: true,
+		},
+		{
+			name:        "Test with empty flavor input",
+			FlavorInput: "",
+			expect:      nil,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			bundleCfg.DevDeployOpts.FlavorInput = tc.FlavorInput
+			bundleCfg.DevDeployOpts.Flavor = nil
+			err := populateFlavorMap()
+			if tc.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expect, bundleCfg.DevDeployOpts.Flavor)
+			}
+		})
+	}
+}

src/config/lang/lang.go

@@ -29,6 +29,7 @@ const (
 	CmdBundleCreateFlagOutput             = "Specify the output (an oci:// URL) for the created bundle"
 	CmdBundleCreateFlagSigningKey         = "Path to private key file for signing bundles"
 	CmdBundleCreateFlagSigningKeyPassword = "Password to the private key file used for signing bundles"
+	CmdBundleCreateFlagFlavor             = "Specify which zarf package flavor you want to use."
 
 	// bundle deploy
 	CmdBundleDeployShort        = "Deploy a bundle from a local tarball or oci:// URL"
@@ -37,6 +38,7 @@ const (
 	CmdBundleDeployFlagResume   = "Only deploys packages from the bundle which haven't already been deployed"
 	CmdBundleDeployFlagSet      = "Specify deployment variables to set on the command line (KEY=value)"
 	CmdBundleDeployFlagRetries  = "Specify the number of retries for package deployments (applies to all pkgs in a bundle)"
+	CmdBundleDeployFlagRef      = "Specify which zarf package ref you want to deploy. By default the ref set in the bundle yaml is used."
 
 	// bundle inspect
 	CmdBundleInspectShort            = "Display the metadata of a bundle"
@@ -81,7 +83,8 @@ const (
 	CmdZarfShort = "Run a zarf command"
 
 	// uds dev
-	CmdDevShort       = "Commands useful for developing bundles"
-	CmdDevDeployShort = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode"
-	CmdDevDeployLong  = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode, setting package options like YOLO mode for faster iteration."
+	CmdDevShort                = "Commands useful for developing bundles"
+	CmdDevDeployShort          = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode"
+	CmdDevDeployLong           = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode, setting package options like YOLO mode for faster iteration."
+	CmdBundleCreateForceCreate = "For local bundles with local packages, specify whether to create a zarf package even if it already exists."
 )

src/pkg/bundle/common.go

@@ -344,3 +344,32 @@ func validateBundleVars(packages []types.Package) error {
 	}
 	return nil
 }
+
+// setPackageRef sets the package reference
+func (b *Bundle) setPackageRef(pkg types.Package) types.Package {
+	if ref, ok := b.cfg.DevDeployOpts.Ref[pkg.Name]; ok {
+		errMsg := fmt.Sprintf("Unable to access %s:%s", pkg.Repository, ref)
+
+		// Get SHA from registry
+		url := fmt.Sprintf("%s:%s", pkg.Repository, ref)
+
+		platform := ocispec.Platform{
+			Architecture: config.GetArch(),
+			OS:           oci.MultiOS,
+		}
+		remote, err := zoci.NewRemote(url, platform)
+		if err != nil {
+			message.Fatalf(err, errMsg)
+		}
+		if err := remote.Repo().Reference.ValidateReferenceAsDigest(); err != nil {
+			manifestDesc, err := remote.ResolveRoot(context.TODO())
+			if err != nil {
+				message.Fatalf(err, errMsg)
+			}
+			pkg.Ref = ref + "@sha256:" + manifestDesc.Digest.Encoded()
+		} else {
+			message.Fatalf(err, errMsg)
+		}
+	}
+	return pkg
+}

src/pkg/bundle/create.go

@@ -34,11 +34,6 @@ func (b *Bundle) Create() error {
 		return err
 	}
 
-	// Populate values from valuesFiles if provided
-	if err := b.processValuesFiles(); err != nil {
-		return err
-	}
-
 	// confirm creation
 	if ok := b.confirmBundleCreation(); !ok {
 		return fmt.Errorf("bundle creation cancelled")
@@ -86,13 +81,22 @@ func (b *Bundle) Create() error {
 		}
 	}
 
+	// for dev mode update package ref for local bundles, refs for remote bundles updated on deploy
+	if config.Dev && len(b.cfg.DevDeployOpts.Ref) != 0 {
+		for i, pkg := range b.bundle.Packages {
+			pkg = b.setPackageRef(pkg)
+			b.bundle.Packages[i] = pkg
+		}
+	}
+
 	opts := bundler.Options{
 		Bundle:    &b.bundle,
 		Output:    b.cfg.CreateOpts.Output,
 		TmpDstDir: b.tmp,
 		SourceDir: b.cfg.CreateOpts.SourceDirectory,
 	}
 	bundlerClient := bundler.NewBundler(&opts)
+
 	return bundlerClient.Create()
 }
 

src/pkg/bundle/deploy.go

@@ -54,10 +54,10 @@ func (b *Bundle) Deploy() error {
 		if len(userSpecifiedPackages) != len(packagesToDeploy) {
 			return fmt.Errorf("invalid zarf packages specified by --packages")
 		}
-		return deployPackages(packagesToDeploy, resume, b)
+	} else {
+		packagesToDeploy = b.bundle.Packages
 	}
-
-	return deployPackages(b.bundle.Packages, resume, b)
+	return deployPackages(packagesToDeploy, resume, b)
 }
 
 func deployPackages(packages []types.Package, resume bool, b *Bundle) error {
@@ -78,7 +78,12 @@ func deployPackages(packages []types.Package, resume bool, b *Bundle) error {
 	}
 
 	// deploy each package
-	for _, pkg := range packagesToDeploy {
+	for i, pkg := range packagesToDeploy {
+		// for dev mode update package ref for remote bundles, refs for local bundles updated on create
+		if config.Dev && !strings.Contains(b.cfg.DeployOpts.Source, "tar.zst") {
+			pkg = b.setPackageRef(pkg)
+			b.bundle.Packages[i] = pkg
+		}
 		sha := strings.Split(pkg.Ref, "@sha256:")[1] // using appended SHA from create!
 		pkgTmp, err := utils.MakeTempDir(config.CommonOptions.TempDirectory)
 		if err != nil {
@@ -125,7 +130,7 @@ func deployPackages(packages []types.Package, resume bool, b *Bundle) error {
 		// Automatically confirm the package deployment
 		zarfConfig.CommonOptions.Confirm = true
 
-		source, err := sources.New(b.cfg.DeployOpts.Source, pkg, opts, sha, nsOverrides)
+		source, err := sources.New(*b.cfg, pkg, opts, sha, nsOverrides)
 		if err != nil {
 			return err
 		}