Make Data Injections Happen asyc w/ Component Deployment

cli/config/config.go

@@ -111,10 +111,6 @@ func GetPackageName() string {
 	return fmt.Sprintf("%s-%s-%s.%s", prefix, metadata.Name, GetArch(), suffix)
 }
 
-func GetDataInjections() []types.ZarfData {
-	return active.Data
-}
-
 func GetMetaData() types.ZarfMetadata {
 	return active.Metadata
 }

cli/internal/packager/common.go

@@ -23,20 +23,20 @@ import (
 )
 
 type componentPaths struct {
-	base      string
-	files     string
-	charts    string
-	values    string
-	repos     string
-	manifests string
+	base           string
+	files          string
+	charts         string
+	values         string
+	repos          string
+	manifests      string
+	dataInjections string
 }
 type tempPaths struct {
 	base             string
 	injectZarfBinary string
 	injectBinary     string
 	seedImage        string
 	images           string
-	dataInjections   string
 	components       string
 }
 
@@ -49,7 +49,6 @@ func createPaths() tempPaths {
 		injectBinary:     basePath + "/zarf-injector",
 		seedImage:        basePath + "/seed-image.tar",
 		images:           basePath + "/images.tar",
-		dataInjections:   basePath + "/data",
 		components:       basePath + "/components",
 	}
 }
@@ -63,12 +62,13 @@ func createComponentPaths(basePath string, component types.ZarfComponent) compon
 	basePath = basePath + "/" + component.Name
 	_ = utils.CreateDirectory(basePath, 0700)
 	return componentPaths{
-		base:      basePath,
-		files:     basePath + "/files",
-		charts:    basePath + "/charts",
-		repos:     basePath + "/repos",
-		manifests: basePath + "/manifests",
-		values:    basePath + "/values",
+		base:           basePath,
+		files:          basePath + "/files",
+		charts:         basePath + "/charts",
+		repos:          basePath + "/repos",
+		manifests:      basePath + "/manifests",
+		dataInjections: basePath + "/data",
+		values:         basePath + "/values",
 	}
 }
 

cli/internal/packager/create.go

@@ -32,7 +32,6 @@ func Create() {
 
 	packageName := config.GetPackageName()
 	components := GetComposedComponents()
-	dataInjections := config.GetDataInjections()
 	seedImage := config.GetSeedImage()
 
 	configFile := tempPath.base + "/zarf.yaml"
@@ -71,15 +70,8 @@ func Create() {
 		// Include the injection things we need, note that zarf-registry must be created by `make build-injector` first
 		utils.CreatePathAndCopy("injector/zarf-registry", tempPath.injectZarfBinary)
 		utils.CreatePathAndCopy("injector/zarf-injector", tempPath.injectBinary)
-	} else {
-		// Init packages do not use data or utilityCluster keys
-		if len(dataInjections) > 0 {
-			for _, data := range dataInjections {
-				destinationFile := tempPath.dataInjections + "/" + filepath.Base(data.Target.Path)
-				utils.CreatePathAndCopy(data.Source, destinationFile)
-			}
-		}
 	}
+
 	_ = os.RemoveAll(packageName)
 	err := archiver.Archive([]string{tempPath.base + "/"}, packageName)
 	if err != nil {
@@ -135,6 +127,17 @@ func addComponent(tempPath tempPaths, component types.ZarfComponent) {
 		}
 	}
 
+	if len(component.DataInjections) > 0 {
+		spinner := message.NewProgressSpinner("Loading data injections")
+		defer spinner.Stop()
+		for _, data := range component.DataInjections {
+			spinner.Updatef("Copying data injection %s for %s", data.Target.Path, data.Target.Selector)
+			destinationFile := componentPath.dataInjections + "/" + filepath.Base(data.Target.Path)
+			utils.CreatePathAndCopy(data.Source, destinationFile)
+		}
+		spinner.Success()
+	}
+
 	if len(component.Manifests) > 0 {
 		spinner := message.NewProgressSpinner("Loading %d manifests", len(component.Manifests))
 		defer spinner.Stop()

cli/internal/packager/deploy.go

@@ -6,6 +6,8 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/defenseunicorns/zarf/cli/types"
 
@@ -81,41 +83,28 @@ func Deploy() {
 		deployComponents(tempPath, component)
 	}
 
-	if config.IsZarfInitConfig() {
-		// If this is the end of an initconfig, cleanup and tell the user we're ready to roll
-		_ = os.Remove(".zarf-registry")
+	if len(connectStrings) > 0 {
+		list := pterm.TableData{{"     Connect Command", "Description"}}
+		// Loop over each connecStrings and convert to pterm.TableData
+		for name, connect := range connectStrings {
+			name = fmt.Sprintf("     zarf connect %s", name)
+			list = append(list, []string{name, connect.Description})
+		}
+
+		// Create the table output with the data
+		_ = pterm.DefaultTable.WithHasHeader().WithData(list).Render()
+	}
 
-		pterm.Success.Println("Zarf deployment complete")
-		pterm.Println()
+	pterm.Success.Println("Zarf deployment complete")
+	pterm.Println()
 
+	if config.IsZarfInitConfig() {
 		_ = pterm.DefaultTable.WithHasHeader().WithData(pterm.TableData{
 			{"     Application", "Username", "Password", "Connect"},
 			{"     Logging", "zarf-admin", config.GetSecret(config.StateLogging), "zarf connect logging"},
 			{"     Git", config.ZarfGitPushUser, config.GetSecret(config.StateGitPush), "zarf connect git"},
 			{"     Registry", "zarf-push-user", config.GetSecret(config.StateRegistryPush), "zarf connect registry"},
 		}).Render()
-	} else {
-		// Otherwise, look for any datainjections to run after the components
-		dataInjectionList := config.GetDataInjections()
-		if len(dataInjectionList) > 0 {
-			message.Info("Loading data injections")
-			handleDataInjection(dataInjectionList, tempPath)
-		}
-
-		pterm.Success.Println("Zarf deployment complete")
-		pterm.Println()
-
-		if len(connectStrings) > 0 {
-			list := pterm.TableData{{"     Connect Command", "Description"}}
-			// Loop over each connecStrings and convert to pterm.TableData
-			for name, connect := range connectStrings {
-				name = fmt.Sprintf("     zarf connect %s", name)
-				list = append(list, []string{name, connect.Description})
-			}
-
-			// Create the table output with the data
-			_ = pterm.DefaultTable.WithHasHeader().WithData(list).Render()
-		}
 	}
 
 	// All done
@@ -179,6 +168,18 @@ func deployComponents(tempPath tempPaths, component types.ZarfComponent) {
 		spinner.Success()
 	}
 
+	// Start any data injection async
+	if len(component.DataInjections) > 0 {
+		var waitGroup sync.WaitGroup
+
+		message.Info("Loading data injections")
+		for _, data := range component.DataInjections {
+			waitGroup.Add(1)
+			go handleDataInjection(&waitGroup, data, componentPath)
+		}
+		defer waitGroup.Wait()
+	}
+
 	if isSeedRegistry {
 		preSeedRegistry(tempPath)
 		valueTemplate = template.Generate()
@@ -261,44 +262,73 @@ func deployComponents(tempPath tempPaths, component types.ZarfComponent) {
 	}
 }
 
-// handleDataInjection performs data-copy operations into a pod
+// Wait for the target pod(s) to come up and inject the data into them
 // todo:  this currently requires kubectl but we should have enough k8s work to make this native now
-func handleDataInjection(dataInjectionList []types.ZarfData, tempPath tempPaths) {
-	injectionCompletionMarker := tempPath.dataInjections + "/.zarf-sync-complete"
+func handleDataInjection(wg *sync.WaitGroup, data types.ZarfDataInjection, componentPath componentPaths) {
+	defer wg.Done()
+
+	injectionCompletionMarker := componentPath.dataInjections + "/.zarf-sync-complete"
 	if err := utils.WriteFile(injectionCompletionMarker, []byte("🦄")); err != nil {
 		return
 	}
-	for _, data := range dataInjectionList {
-		sourceFile := tempPath.dataInjections + "/" + filepath.Base(data.Target.Path)
-		pods := k8s.WaitForPodsAndContainers(data.Target, true)
 
-		for _, pod := range pods {
+	timeout := time.After(15 * time.Minute)
+	for {
+		// delay check 2 seconds
+		time.Sleep(2 * time.Second)
+		select {
+
+		// on timeout abort
+		case <-timeout:
+			message.Warnf("data injection into target %v timed out\n", data.Target.Namespace)
+			return
+
+		default:
+			sourceFile := componentPath.dataInjections + "/" + filepath.Base(data.Target.Path)
+
+			// Wait until the pod we are injecting data into becomes available
+			pods := k8s.WaitForPodsAndContainers(data.Target, true)
+			if len(pods) < 1 {
+				continue
+			}
+
+			// Define injection destination
 			destination := data.Target.Path
 			if destination == "/"+filepath.Base(destination) {
 				// Handle top-level directory targets
 				destination = "/"
 			}
-			cpPodExecArgs := []string{"-n", data.Target.Namespace, "cp", sourceFile, pod + ":" + destination}
 
-			if data.Target.Container != "" {
-				// Append the container args if they are specified
-				cpPodExecArgs = append(cpPodExecArgs, "-c", data.Target.Container)
-			}
+			// Inject into all the pods
+			for _, pod := range pods {
+				cpPodExecArgs := []string{"-n", data.Target.Namespace, "cp", sourceFile, pod + ":" + destination}
 
-			_, err := utils.ExecCommand(true, nil, "kubectl", cpPodExecArgs...)
-			if err != nil {
-				message.Warn("Error copying data into the pod")
-			} else {
-				// Leave a marker in the target container for pods to track the sync action
-				cpPodExecArgs[3] = injectionCompletionMarker
-				cpPodExecArgs[4] = pod + ":" + data.Target.Path
-				_, err = utils.ExecCommand(true, nil, "kubectl", cpPodExecArgs...)
+				if data.Target.Container != "" {
+					// Append the container args if they are specified
+					cpPodExecArgs = append(cpPodExecArgs, "-c", data.Target.Container)
+				}
+
+				// Do the actual data injection
+				_, err := utils.ExecCommand(true, nil, "kubectl", cpPodExecArgs...)
 				if err != nil {
-					message.Warn("Error saving the zarf sync completion file")
+					message.Warnf("Error copying data into the pod %v: %v\n", pod, err)
+					continue
+				} else {
+					// Leave a marker in the target container for pods to track the sync action
+					cpPodExecArgs[3] = injectionCompletionMarker
+					cpPodExecArgs[4] = pod + ":" + data.Target.Path
+					_, err = utils.ExecCommand(true, nil, "kubectl", cpPodExecArgs...)
+					if err != nil {
+						message.Warnf("Error saving the zarf sync completion file after injection into pod %v\n", pod)
+					}
 				}
 			}
+
+			// Cleanup now to reduce disk pressure
+			_ = os.RemoveAll(sourceFile)
+
+			// Return to stop the loop
+			return
 		}
-		// Cleanup now to reduce disk pressure
-		_ = os.RemoveAll(sourceFile)
 	}
 }

cli/types/types.go

@@ -51,6 +51,9 @@ type ZarfComponent struct {
 	// Repos are any git repos that need to be pushed into the gitea server
 	Repos []string `yaml:"repos,omitempty"`
 
+	// Data pacakges to push into a running cluster
+	DataInjections []ZarfDataInjection `yaml:"dataInjections,omitempty"`
+
 	// Scripts are custom commands that run before or after package deployment
 	Scripts ZarfComponentScripts `yaml:"scripts,omitempty"`
 
@@ -92,8 +95,8 @@ type ZarfContainerTarget struct {
 	Path      string `yaml:"path"`
 }
 
-// ZarfData is a data-injection definition
-type ZarfData struct {
+// ZarfDataInjection is a data-injection definition
+type ZarfDataInjection struct {
 	Source string              `yaml:"source"`
 	Target ZarfContainerTarget `yaml:"target"`
 }
@@ -112,7 +115,6 @@ type ZarfPackage struct {
 	Kind       string          `yaml:"kind,omitempty"`
 	Metadata   ZarfMetadata    `yaml:"metadata,omitempty"`
 	Build      ZarfBuildData   `yaml:"build,omitempty"`
-	Data       []ZarfData      `yaml:"data,omitempty"`
 	Components []ZarfComponent `yaml:"components,omitempty"`
 	Seed       string          `yaml:"seed,omitempty"`
 }