Switch to per-image tunnels, CRC on tags, and progressbar for image pushes

packages/distros/k3s/common/zarf.yaml

@@ -12,8 +12,8 @@ components:
     only:
       localOS: linux
     description: >
-      *** REQUIRES ROOT ***
-      Install K3s, certified Kubernetes distribution built for IoT & Edge computing.
+      *** REQUIRES ROOT (not sudo) ***
+      Install K3s, a certified Kubernetes distribution built for IoT & Edge computing.
       K3s provides the cluster need for Zarf running in Appliance Mode as well as can
       host a low-resource Gitops Service if not using an existing Kubernetes platform.
     actions:

packages/zarf-registry/chart/templates/hpa.yaml

@@ -26,14 +26,18 @@ spec:
     scaleDown:
       # Use 60 second stabilization window becuase zarf will freeze scale down during deploys
       stabilizationWindowSeconds: 60
+      # Initially disable scale down - this gets set to Min later by Zarf (src/test/e2e/20_zarf_init_test.go)
+      selectPolicy: Disabled
       # Scale down one pod per minute
       policies:
         - type: Pods
           value: 1
-          periodSeconds: 60      
+          periodSeconds: 60
     scaleUp:
       # Delay initial checks by 30 seconds
       stabilizationWindowSeconds: 30
+      # Scale up as much as is needed
+      selectPolicy: Max
       # Scale up one pod per minute
       policies:
         - type: Pods

src/cmd/connect.go

@@ -29,6 +29,7 @@ var (
 			if len(args) > 0 {
 				target = args[0]
 			}
+			spinner := message.NewProgressSpinner("Preparing a tunnel to connect to %s", target)
 
 			tunnel, err := cluster.NewTunnel(connectNamespace, connectResourceType, connectResourceName, connectLocalPort, connectRemotePort)
 			if err != nil {
@@ -38,7 +39,10 @@ var (
 			if !cliOnly {
 				tunnel.EnableAutoOpen()
 			}
+
+			tunnel.AddSpinner(spinner)
 			tunnel.Connect(target, true)
+			spinner.Success()
 		},
 	}
 

src/cmd/destroy.go

@@ -30,7 +30,7 @@ var destroyCmd = &cobra.Command{
 	Short:   lang.CmdDestroyShort,
 	Long:    lang.CmdDestroyLong,
 	Run: func(cmd *cobra.Command, args []string) {
-		c, err := cluster.NewClusterWithWait(30 * time.Second)
+		c, err := cluster.NewClusterWithWait(30*time.Second, true)
 		if err != nil {
 			message.Fatalf(err, lang.ErrNoClusterConnection)
 		}

src/cmd/package.go

@@ -89,6 +89,8 @@ var packageDeployCmd = &cobra.Command{
 		pkgClient := packager.NewOrDie(&pkgConfig)
 		defer pkgClient.ClearTempPaths()
 
+		pterm.Println()
+
 		// Deploy the package
 		if err := pkgClient.Deploy(); err != nil {
 			message.Fatalf(err, "Failed to deploy package: %s", err.Error())

src/config/config.go

@@ -134,6 +134,7 @@ func GetCraneOptions(insecure bool, archs ...string) []crane.Option {
 			OS:           "linux",
 			Architecture: GetArch(archs...),
 		}),
+		crane.WithUserAgent("zarf"),
 	)
 
 	return options

src/internal/api/cluster/cluster.go

@@ -23,7 +23,7 @@ func Summary(w http.ResponseWriter, _ *http.Request) {
 	var distro string
 	var hasZarf bool
 
-	c, err := cluster.NewClusterWithWait(5 * time.Second)
+	c, err := cluster.NewClusterWithWait(5*time.Second, false)
 	reachable = err == nil
 
 	if reachable {

src/internal/cluster/common.go

@@ -28,7 +28,7 @@ var labels = k8s.Labels{
 
 // NewClusterOrDie creates a new cluster instance and waits up to 30 seconds for the cluster to be ready or throws a fatal error.
 func NewClusterOrDie() *Cluster {
-	c, err := NewClusterWithWait(defaultTimeout)
+	c, err := NewClusterWithWait(defaultTimeout, true)
 	if err != nil {
 		message.Fatalf(err, "Failed to connect to cluster")
 	}
@@ -37,19 +37,37 @@ func NewClusterOrDie() *Cluster {
 }
 
 // NewClusterWithWait creates a new cluster instance and waits for the given timeout for the cluster to be ready.
-func NewClusterWithWait(timeout time.Duration) (*Cluster, error) {
+func NewClusterWithWait(timeout time.Duration, withSpinner bool) (*Cluster, error) {
+	var spinner *message.Spinner
+	if withSpinner {
+		spinner = message.NewProgressSpinner("Waiting for cluster connection (%s timeout)", timeout.String())
+		defer spinner.Stop()
+	}
+
 	c := &Cluster{}
 	var err error
+
 	c.Kube, err = k8s.New(message.Debugf, labels)
 	if err != nil {
 		return c, err
 	}
-	return c, c.Kube.WaitForHealthyCluster(timeout)
+
+	err = c.Kube.WaitForHealthyCluster(timeout)
+	if err != nil {
+		return c, err
+	}
+
+	if spinner != nil {
+		spinner.Success()
+	}
+
+	return c, nil
 }
 
 // NewCluster creates a new cluster instance without waiting for the cluster to be ready.
 func NewCluster() (*Cluster, error) {
+	var err error
 	c := &Cluster{}
-	c.Kube, _ = k8s.New(message.Debugf, labels)
-	return c, nil
+	c.Kube, err = k8s.New(message.Debugf, labels)
+	return c, err
 }

src/internal/cluster/state.go

@@ -22,10 +22,11 @@ import (
 
 // Zarf Cluster Constants.
 const (
-	ZarfNamespace        = "zarf"
-	ZarfStateSecretName  = "zarf-state"
-	ZarfStateDataKey     = "state"
-	ZarfPackageInfoLabel = "package-deploy-info"
+	ZarfNamespace           = "zarf"
+	ZarfStateSecretName     = "zarf-state"
+	ZarfStateDataKey        = "state"
+	ZarfPackageInfoLabel    = "package-deploy-info"
+	ZarfInitPackageInfoName = "zarf-package-init"
 )
 
 // InitZarfState initializes the Zarf state with the given temporary directory and init configs.

src/internal/cluster/tunnel.go

@@ -368,7 +368,6 @@ func (tunnel *Tunnel) establish() (string, error) {
 	message.Debug("tunnel.Establish()")
 
 	var err error
-	var spinner *message.Spinner
 
 	// Track this locally as we may need to retry if the tunnel fails.
 	localPort := tunnel.localPort
@@ -390,6 +389,7 @@ func (tunnel *Tunnel) establish() (string, error) {
 		defer globalMutex.Unlock()
 	}
 
+	var spinner *message.Spinner
 	spinnerMessage := fmt.Sprintf("Opening tunnel %d -> %d for %s/%s in namespace %s",
 		localPort,
 		tunnel.remotePort,
@@ -402,8 +402,7 @@ func (tunnel *Tunnel) establish() (string, error) {
 		spinner = tunnel.spinner
 		spinner.Updatef(spinnerMessage)
 	} else {
-		spinner = message.NewProgressSpinner(spinnerMessage)
-		defer spinner.Stop()
+		message.Debug(spinnerMessage)
 	}
 
 	kube, err := k8s.NewWithWait(message.Debugf, labels, defaultTimeout)
@@ -455,19 +454,16 @@ func (tunnel *Tunnel) establish() (string, error) {
 	// Wait for an error or the tunnel to be ready.
 	select {
 	case err = <-errChan:
-		if tunnel.spinner == nil {
-			spinner.Stop()
-		}
 		return "", fmt.Errorf("unable to start the tunnel: %w", err)
 	case <-portforwarder.Ready:
 		// Store for endpoint output
 		tunnel.localPort = localPort
 		url := fmt.Sprintf("http://%s:%d%s", config.IPV4Localhost, localPort, tunnel.urlSuffix)
 		msg := fmt.Sprintf("Creating port forwarding tunnel at %s", url)
-		if tunnel.spinner == nil {
-			spinner.Successf(msg)
+		if tunnel.spinner != nil {
+			spinner.Updatef("%s", msg)
 		} else {
-			spinner.Updatef(msg)
+			message.Debug(msg)
 		}
 		return url, nil
 	}

src/internal/cluster/zarf.go

@@ -43,6 +43,21 @@ func (c *Cluster) GetDeployedZarfPackages() ([]types.DeployedPackage, error) {
 	return deployedPackages, nil
 }
 
+// GetDeployedZarfInitPackage gets the metadata information about the currently deployed init package in the cluster.
+// We determine what packages have been deployed to the cluster by looking for specific secrets in the Zarf namespace.
+func (c *Cluster) GetDeployedZarfInitPackage() (types.DeployedPackage, error) {
+	var deployedInitPackage = types.DeployedPackage{}
+
+	// Get the secret that describes the deployed init package
+	secret, err := c.Kube.GetSecret(ZarfNamespace, ZarfInitPackageInfoName)
+	if err != nil {
+		return deployedInitPackage, err
+	}
+
+	err = json.Unmarshal(secret.Data["data"], &deployedInitPackage)
+	return deployedInitPackage, err
+}
+
 // StripZarfLabelsAndSecretsFromNamespaces removes metadata and secrets from existing namespaces no longer manged by Zarf.
 func (c *Cluster) StripZarfLabelsAndSecretsFromNamespaces() {
 	spinner := message.NewProgressSpinner("Removing zarf metadata & secrets from existing namespaces not managed by Zarf")

src/internal/packager/images/pull.go

@@ -48,11 +48,8 @@ func (i *ImgConfig) PullAll() error {
 	spinner := message.NewProgressSpinner("Loading metadata for %d images. %s", imgCount, longer)
 	defer spinner.Stop()
 
-	if message.GetLogLevel() >= message.DebugLevel {
-		spinner.EnablePreserveWrites()
-		logs.Warn.SetOutput(spinner)
-		logs.Progress.SetOutput(spinner)
-	}
+	logs.Warn.SetOutput(&message.DebugWriter{})
+	logs.Progress.SetOutput(&message.DebugWriter{})
 
 	for idx, src := range i.ImgList {
 		spinner.Updatef("Fetching image metadata (%d of %d): %s", idx+1, imgCount, src)