make sure all spinners close on error

Author: ajp-io

cmd/installer/cli/install.go

@@ -549,7 +549,6 @@ func verifyNoInstallation(name string, cmdName string) error {
 
 func initializeInstall(ctx context.Context, flags InstallCmdFlags) error {
 	spinner := spinner.Start()
-
 	spinner.Infof("Initializing")
 
 	if err := materializeFiles(flags.airgapBundle); err != nil {
@@ -586,8 +585,7 @@ func initializeInstall(ctx context.Context, flags InstallCmdFlags) error {
 		logrus.Debugf("unable to configure firewalld: %v", err)
 	}
 
-	spinner.Infof("Initialization complete")
-	spinner.Close()
+	spinner.Closef("Initialization complete")
 	return nil
 }
 
@@ -619,37 +617,45 @@ func materializeFiles(airgapBundle string) error {
 
 func installAndStartCluster(ctx context.Context, networkInterface string, airgapBundle string, proxy *ecv1beta1.ProxySpec, cidrCfg *CIDRConfig, overrides string, mutate func(*k0sv1beta1.ClusterConfig) error) (*k0sv1beta1.ClusterConfig, error) {
 	loading := spinner.Start()
-	defer loading.Close()
 	loading.Infof("Installing node")
 	logrus.Debugf("creating k0s configuration file")
 
 	cfg, err := k0s.WriteK0sConfig(ctx, networkInterface, airgapBundle, cidrCfg.PodCIDR, cidrCfg.ServiceCIDR, overrides, mutate)
 	if err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return nil, fmt.Errorf("create config file: %w", err)
 	}
 	logrus.Debugf("creating systemd unit files")
 	if err := createSystemdUnitFiles(ctx, false, proxy); err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return nil, fmt.Errorf("create systemd unit files: %w", err)
 	}
 
 	logrus.Debugf("installing k0s")
 	if err := k0s.Install(networkInterface); err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return nil, fmt.Errorf("install cluster: %w", err)
 	}
 
-	loading.Infof("Waiting for node")
-
 	logrus.Debugf("waiting for k0s to be ready")
 	if err := waitForK0s(); err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return nil, fmt.Errorf("wait for k0s: %w", err)
 	}
 
+	loading.Infof("Waiting for node to be ready")
 	logrus.Debugf("waiting for node to be ready")
 	if err := waitForNode(ctx); err != nil {
+		loading.Errorf("Failed to wait for node")
+		loading.CloseWithError()
 		return nil, fmt.Errorf("wait for node: %w", err)
 	}
 
-	loading.Infof("Node installed")
+	loading.Closef("Node is ready")
 	return cfg, nil
 }
 

cmd/installer/cli/join.go

@@ -128,7 +128,7 @@ func runJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *kotsadm
 	// both controller and worker nodes will have 'worker' in the join command
 	isWorker := !strings.Contains(jcmd.K0sJoinCommand, "controller")
 	if !isWorker {
-		logrus.Warnf("Do not join another node until this join is complete.")
+		logrus.Warn("Do not join another node until this join is complete.")
 	}
 
 	if err := runJoinVerifyAndPrompt(name, flags, jcmd); err != nil {
@@ -149,46 +149,57 @@ func runJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *kotsadm
 	}
 
 	logrus.Debugf("installing and joining cluster")
+	loading := spinner.Start()
+	loading.Infof("Installing node")
 	if err := installAndJoinCluster(ctx, jcmd, name, flags, isWorker); err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return err
 	}
 
 	kcli, err := kubeutils.KubeClient()
 	if err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return fmt.Errorf("unable to get kube client: %w", err)
 	}
 
 	hostname, err := os.Hostname()
 	if err != nil {
+		loading.Errorf("Failed to install node")
+		loading.CloseWithError()
 		return fmt.Errorf("unable to get hostname: %w", err)
 	}
 
 	logrus.Debugf("waiting for node to join cluster")
+	loading.Infof("Waiting for node")
 	if err := waitForNodeToJoin(ctx, kcli, hostname, isWorker); err != nil {
+		loading.Errorf("Failed to wait for node")
+		loading.CloseWithError()
 		return fmt.Errorf("unable to wait for node: %w", err)
 	}
 
+	loading.Closef("Node is ready")
 	if isWorker {
 		logrus.Debugf("worker node join finished")
 		return nil
 	}
 
-	airgapChartsPath := ""
-	if flags.isAirgap {
-		airgapChartsPath = runtimeconfig.EmbeddedClusterChartsSubDir()
-	}
-
-	hcli, err := helm.NewClient(helm.HelmOptions{
-		KubeConfig: runtimeconfig.PathToKubeConfig(),
-		K0sVersion: versions.K0sVersion,
-		AirgapPath: airgapChartsPath,
-	})
-	if err != nil {
-		return fmt.Errorf("unable to create helm client: %w", err)
-	}
-	defer hcli.Close()
-
 	if flags.enableHighAvailability {
+		airgapChartsPath := ""
+		if flags.isAirgap {
+			airgapChartsPath = runtimeconfig.EmbeddedClusterChartsSubDir()
+		}
+
+		hcli, err := helm.NewClient(helm.HelmOptions{
+			KubeConfig: runtimeconfig.PathToKubeConfig(),
+			K0sVersion: versions.K0sVersion,
+			AirgapPath: airgapChartsPath,
+		})
+		if err != nil {
+			return fmt.Errorf("unable to create helm client: %w", err)
+		}
+		defer hcli.Close()
 		if err := maybeEnableHA(ctx, kcli, hcli, flags.isAirgap, cidrCfg.ServiceCIDR, jcmd.InstallationSpec.Proxy, jcmd.InstallationSpec.Config); err != nil {
 			return fmt.Errorf("unable to enable high availability: %w", err)
 		}
@@ -252,9 +263,17 @@ func runJoinVerifyAndPrompt(name string, flags JoinCmdFlags, jcmd *kotsadm.JoinC
 	return nil
 }
 
-func initializeJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *kotsadm.JoinCommandResponse) (*CIDRConfig, error) {
+func initializeJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *kotsadm.JoinCommandResponse) (cidrCfg *CIDRConfig, err error) {
 	spinner := spinner.Start()
 	spinner.Infof("Initializing")
+	defer func() {
+		if err != nil {
+			spinner.Errorf("Initialization failed")
+			spinner.CloseWithError()
+		} else {
+			spinner.Closef("Initialization complete")
+		}
+	}()
 
 	// set the umask to 022 so that we can create files/directories with 755 permissions
 	// this does not return an error - it returns the previous umask
@@ -268,8 +287,6 @@ func initializeJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *
 
 	logrus.Debugf("materializing %s binaries", name)
 	if err := materializeFiles(flags.airgapBundle); err != nil {
-		spinner.Errorf("Initialization failed")
-		spinner.CloseWithError()
 		return nil, err
 	}
 
@@ -285,15 +302,11 @@ func initializeJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *
 
 	logrus.Debugf("configuring network manager")
 	if err := configureNetworkManager(ctx); err != nil {
-		spinner.Errorf("Initialization failed")
-		spinner.CloseWithError()
 		return nil, fmt.Errorf("unable to configure network manager: %w", err)
 	}
 
-	cidrCfg, err := getJoinCIDRConfig(jcmd)
+	cidrCfg, err = getJoinCIDRConfig(jcmd)
 	if err != nil {
-		spinner.Errorf("Initialization failed")
-		spinner.CloseWithError()
 		return nil, fmt.Errorf("unable to get join CIDR config: %w", err)
 	}
 
@@ -302,9 +315,6 @@ func initializeJoin(ctx context.Context, name string, flags JoinCmdFlags, jcmd *
 		logrus.Debugf("unable to configure firewalld: %v", err)
 	}
 
-	spinner.Infof("Initialization complete")
-	spinner.Close()
-
 	return cidrCfg, nil
 }
 
@@ -431,9 +441,6 @@ func applyNetworkConfiguration(networkInterface string, jcmd *kotsadm.JoinComman
 
 // startAndWaitForK0s starts the k0s service and waits for the node to be ready.
 func startAndWaitForK0s(ctx context.Context, name string, jcmd *kotsadm.JoinCommandResponse) error {
-	loading := spinner.Start()
-	defer loading.Close()
-	loading.Infof("Installing node")
 	logrus.Debugf("starting %s service", name)
 	if _, err := helpers.RunCommand(runtimeconfig.K0sBinaryPath(), "start"); err != nil {
 		return fmt.Errorf("unable to start service: %w", err)
@@ -444,7 +451,6 @@ func startAndWaitForK0s(ctx context.Context, name string, jcmd *kotsadm.JoinComm
 		return fmt.Errorf("unable to wait for node: %w", err)
 	}
 
-	loading.Infof("Node installed")
 	return nil
 }
 
@@ -503,13 +509,9 @@ func runK0sInstallCommand(networkInterface string, fullcmd string) error {
 }
 
 func waitForNodeToJoin(ctx context.Context, kcli client.Client, hostname string, isWorker bool) error {
-	loading := spinner.Start()
-	defer loading.Close()
-	loading.Infof("Waiting for node")
 	if err := kubeutils.WaitForNode(ctx, kcli, hostname, isWorker); err != nil {
 		return fmt.Errorf("unable to wait for node: %w", err)
 	}
-	loading.Infof("Node is ready")
 	return nil
 }