refactor

Author: Andrea Falzetti

components/gitpod-cli/cmd/rebuild.go

@@ -16,7 +16,6 @@ import (
 	"github.com/gitpod-io/gitpod/gitpod-cli/pkg/supervisor"
 	"github.com/gitpod-io/gitpod/gitpod-cli/pkg/utils"
 	"github.com/gitpod-io/gitpod/supervisor/api"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
 
@@ -48,184 +47,189 @@ func TerminateExistingContainer() error {
 	return nil
 }
 
-var buildCmd = &cobra.Command{
-	Use:    "rebuild",
-	Short:  "Re-builds the workspace image (useful to debug a workspace custom image)",
-	Hidden: false,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx := context.Background()
+func runRebuild(ctx context.Context, supervisorClient *supervisor.SupervisorClient, event *utils.EventTracker) error {
+	wsInfo, err := supervisorClient.Info.WorkspaceInfo(ctx, &api.WorkspaceInfoRequest{})
+	if err != nil {
+		return err
+	}
 
-		client, err := supervisor.New(ctx)
-		if err != nil {
-			utils.LogError(ctx, err, "Could not get workspace info required to build", client)
-			return
-		}
-		defer client.Close()
+	tmpDir, err := os.MkdirTemp("", "gp-rebuild-*")
+	if err != nil {
+		event.Set("ErrorCode", utils.SystemErrorCode_TmpDirCannotWrite)
+		return err
+	}
+	defer os.RemoveAll(tmpDir)
 
-		wsInfo, err := client.Info.WorkspaceInfo(ctx, &api.WorkspaceInfoRequest{})
-		if err != nil {
-			utils.LogError(ctx, err, "Could not fetch the workspace info", client)
-			return
-		}
+	gitpodConfig, err := utils.ParseGitpodConfig(wsInfo.CheckoutLocation)
+	if err != nil {
+		fmt.Println("The .gitpod.yml file cannot be parsed: please check the file and try again")
+		fmt.Println("")
+		fmt.Println("For help check out the reference page:")
+		fmt.Println("https://www.gitpod.io/docs/references/gitpod-yml#gitpodyml")
+		event.Set("ErrorCode", utils.RebuildErrorCode_MalformedGitpodYaml)
+		return err
+	}
 
-		event := utils.TrackEvent(ctx, client, &utils.TrackCommandUsageParams{
-			Command: cmd.Name(),
-		})
-		defer event.Send(ctx)
+	if gitpodConfig == nil {
+		fmt.Println("To test the image build, you need to configure your project with a .gitpod.yml file")
+		fmt.Println("")
+		fmt.Println("For a quick start, try running:\n$ gp init -i")
+		fmt.Println("")
+		fmt.Println("Alternatively, check out the following docs for getting started configuring your project")
+		fmt.Println("https://www.gitpod.io/docs/configure#configure-gitpod")
+		event.Set("ErrorCode", utils.RebuildErrorCode_MissingGitpodYaml)
+		return err
+	}
 
-		tmpDir, err := os.MkdirTemp("", "gp-rebuild-*")
-		if err != nil {
-			event.Set("ErrorCode", utils.SystemErrorCode_TmpDirCannotWrite)
-			log.WithError(err).Error("Could not create temporary directory")
-			return
+	var baseimage string
+	switch img := gitpodConfig.Image.(type) {
+	case nil:
+		baseimage = ""
+	case string:
+		baseimage = "FROM " + img
+	case map[interface{}]interface{}:
+		dockerfilePath := filepath.Join(wsInfo.CheckoutLocation, img["file"].(string))
+
+		if _, err := os.Stat(dockerfilePath); os.IsNotExist(err) {
+			fmt.Println("Your .gitpod.yml points to a Dockerfile that doesn't exist: " + dockerfilePath)
+			event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileNotFound).Send(ctx)
+			return err
 		}
-		defer os.RemoveAll(tmpDir)
-
-		gitpodConfig, err := utils.ParseGitpodConfig(wsInfo.CheckoutLocation)
+		dockerfile, err := os.ReadFile(dockerfilePath)
 		if err != nil {
-			fmt.Println("The .gitpod.yml file cannot be parsed: please check the file and try again")
-			fmt.Println("")
-			fmt.Println("For help check out the reference page:")
-			fmt.Println("https://www.gitpod.io/docs/references/gitpod-yml#gitpodyml")
-			event.Set("ErrorCode", utils.RebuildErrorCode_MalformedGitpodYaml)
-			return
+			event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileCannotRead)
+			return err
 		}
-
-		if gitpodConfig == nil {
-			fmt.Println("To test the image build, you need to configure your project with a .gitpod.yml file")
+		if string(dockerfile) == "" {
+			fmt.Println("Your Gitpod's Dockerfile is empty")
 			fmt.Println("")
-			fmt.Println("For a quick start, try running:\n$ gp init -i")
+			fmt.Println("To learn how to customize your workspace, check out the following docs:")
+			fmt.Println("https://www.gitpod.io/docs/configure/workspaces/workspace-image#use-a-custom-dockerfile")
 			fmt.Println("")
-			fmt.Println("Alternatively, check out the following docs for getting started configuring your project")
-			fmt.Println("https://www.gitpod.io/docs/configure#configure-gitpod")
-			event.Set("ErrorCode", utils.RebuildErrorCode_MissingGitpodYaml)
-			return
+			fmt.Println("Once you configure your Dockerfile, re-run this command to validate your changes")
+			event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileEmpty)
+			return err
 		}
+		baseimage = "\n" + string(dockerfile) + "\n"
+	default:
+		fmt.Println("Check your .gitpod.yml and make sure the image property is configured correctly")
+		event.Set("ErrorCode", utils.RebuildErrorCode_MalformedGitpodYaml)
+		return err
+	}
 
-		var baseimage string
-		switch img := gitpodConfig.Image.(type) {
-		case nil:
-			baseimage = ""
-		case string:
-			baseimage = "FROM " + img
-		case map[interface{}]interface{}:
-			dockerfilePath := filepath.Join(wsInfo.CheckoutLocation, img["file"].(string))
-
-			if _, err := os.Stat(dockerfilePath); os.IsNotExist(err) {
-				fmt.Println("Your .gitpod.yml points to a Dockerfile that doesn't exist: " + dockerfilePath)
-				event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileNotFound).Send(ctx)
-				return
-			}
-			dockerfile, err := os.ReadFile(dockerfilePath)
-			if err != nil {
-				event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileCannotRead)
-				log.WithError(err).Error("Could not read the Dockerfile")
-				return
-			}
-			if string(dockerfile) == "" {
-				fmt.Println("Your Gitpod's Dockerfile is empty")
-				fmt.Println("")
-				fmt.Println("To learn how to customize your workspace, check out the following docs:")
-				fmt.Println("https://www.gitpod.io/docs/configure/workspaces/workspace-image#use-a-custom-dockerfile")
-				fmt.Println("")
-				fmt.Println("Once you configure your Dockerfile, re-run this command to validate your changes")
-				event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileEmpty)
-				return
-			}
-			baseimage = "\n" + string(dockerfile) + "\n"
-		default:
-			fmt.Println("Check your .gitpod.yml and make sure the image property is configured correctly")
-			event.Set("ErrorCode", utils.RebuildErrorCode_MalformedGitpodYaml)
-			return
-		}
+	if baseimage == "" {
+		fmt.Println("Your project is not using any custom Docker image.")
+		fmt.Println("Check out the following docs, to know how to get started")
+		fmt.Println("")
+		fmt.Println("https://www.gitpod.io/docs/configure/workspaces/workspace-image#use-a-public-docker-image")
+		event.Set("ErrorCode", utils.RebuildErrorCode_NoCustomImage)
+		return err
+	}
 
-		if baseimage == "" {
-			fmt.Println("Your project is not using any custom Docker image.")
-			fmt.Println("Check out the following docs, to know how to get started")
-			fmt.Println("")
-			fmt.Println("https://www.gitpod.io/docs/configure/workspaces/workspace-image#use-a-public-docker-image")
-			event.Set("ErrorCode", utils.RebuildErrorCode_NoCustomImage)
-			return
-		}
+	err = os.WriteFile(filepath.Join(tmpDir, "Dockerfile"), []byte(baseimage), 0644)
+	if err != nil {
+		fmt.Println("Could not write the temporary Dockerfile")
+		event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileCannotWirte)
+		return err
+	}
 
-		err = os.WriteFile(filepath.Join(tmpDir, "Dockerfile"), []byte(baseimage), 0644)
-		if err != nil {
-			fmt.Println("Could not write the temporary Dockerfile")
-			event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileCannotWirte)
-			log.WithError(err).Error(err)
-			return
-		}
+	dockerPath, err := exec.LookPath("docker")
+	if err != nil {
+		fmt.Println("Docker is not installed in your workspace")
+		event.Set("ErrorCode", utils.RebuildErrorCode_DockerNotFound)
+		return err
+	}
 
-		dockerPath, err := exec.LookPath("docker")
-		if err != nil {
-			fmt.Println("Docker is not installed in your workspace")
-			event.Set("ErrorCode", utils.RebuildErrorCode_DockerNotFound)
-			return
-		}
+	tag := "gp-rebuild-temp-build"
 
-		tag := "gp-rebuild-temp-build"
+	dockerCmd := exec.Command(dockerPath, "build", "-t", tag, "--progress=tty", ".")
+	dockerCmd.Dir = tmpDir
+	dockerCmd.Stdout = os.Stdout
+	dockerCmd.Stderr = os.Stderr
 
-		dockerCmd := exec.Command(dockerPath, "build", "-t", tag, "--progress=tty", ".")
-		dockerCmd.Dir = tmpDir
-		dockerCmd.Stdout = os.Stdout
-		dockerCmd.Stderr = os.Stderr
+	imageBuildStartTime := time.Now()
+	err = dockerCmd.Run()
+	if _, ok := err.(*exec.ExitError); ok {
+		fmt.Println("Image Build Failed")
+		event.Set("ErrorCode", utils.RebuildErrorCode_DockerBuildFailed)
+		return err
+	} else if err != nil {
+		fmt.Println("Docker error")
+		event.Set("ErrorCode", utils.RebuildErrorCode_DockerErr)
+		return err
+	}
+	iamgeBuildDurationSeconds := time.Since(imageBuildStartTime).Seconds()
+	event.Set("ImageBuildDurationSeconds", iamgeBuildDurationSeconds)
 
-		imageBuildStartTime := time.Now()
-		err = dockerCmd.Run()
-		if _, ok := err.(*exec.ExitError); ok {
-			fmt.Println("Image Build Failed")
-			event.Set("ErrorCode", utils.RebuildErrorCode_DockerBuildFailed)
-			log.WithError(err).Error(err)
-			return
-		} else if err != nil {
-			fmt.Println("Docker error")
-			event.Set("ErrorCode", utils.RebuildErrorCode_DockerErr)
-			log.WithError(err).Error(err)
-			return
-		}
-		iamgeBuildDurationSeconds := time.Since(imageBuildStartTime).Seconds()
-		event.Set("ImageBuildDurationSeconds", iamgeBuildDurationSeconds)
+	err = TerminateExistingContainer()
+	if err != nil {
+		utils.LogError(ctx, err, "Failed to stop previous gp rebuild container", supervisorClient)
+	}
 
-		err = TerminateExistingContainer()
+	messages := []string{
+		"\n\nYou are now connected to the container",
+		"You can inspect the container and make sure the necessary tools & libraries are installed.",
+		"When you are done, just type exit to return to your Gitpod workspace\n",
+	}
+
+	welcomeMessage := strings.Join(messages, "\n")
+
+	dockerRunCmd := exec.Command(
+		dockerPath,
+		"run",
+		"--rm",
+		"--label", "gp-rebuild=true",
+		"-it",
+		tag,
+		"bash",
+		"-c",
+		fmt.Sprintf("echo '%s'; bash", welcomeMessage),
+	)
+
+	dockerRunCmd.Stdout = os.Stdout
+	dockerRunCmd.Stderr = os.Stderr
+	dockerRunCmd.Stdin = os.Stdin
+
+	err = dockerRunCmd.Run()
+	if _, ok := err.(*exec.ExitError); ok {
+		fmt.Println("Docker Run Command Failed")
+		event.Set("ErrorCode", utils.RebuildErrorCode_DockerRunFailed)
+		return err
+	} else if err != nil {
+		fmt.Println("Docker error")
+		event.Set("ErrorCode", utils.RebuildErrorCode_DockerErr)
+		return err
+	}
+
+	return nil
+}
+
+var buildCmd = &cobra.Command{
+	Use:    "rebuild",
+	Short:  "Re-builds the workspace image (useful to debug a workspace custom image)",
+	Hidden: false,
+	Run: func(cmd *cobra.Command, args []string) {
+		ctx := context.Background()
+		supervisorClient, err := supervisor.New(ctx)
 		if err != nil {
-			utils.LogError(ctx, err, "Failed to stop previous gp rebuild container", client)
+			utils.LogError(ctx, err, "Could not get workspace info required to build", supervisorClient)
+			return
 		}
+		defer supervisorClient.Close()
+
+		event := utils.TrackEvent(ctx, supervisorClient, &utils.TrackCommandUsageParams{
+			Command: cmd.Name(),
+		})
 
-		messages := []string{
-			"\n\nYou are now connected to the container",
-			"You can inspect the container and make sure the necessary tools & libraries are installed.",
-			"When you are done, just type exit to return to your Gitpod workspace\n",
+		err = runRebuild(ctx, supervisorClient, event)
+		if err != nil && event.Data.ErrorCode == "" {
+			event.Set("ErrorCode", "System")
 		}
+		event.Send(ctx)
 
-		welcomeMessage := strings.Join(messages, "\n")
-
-		dockerRunCmd := exec.Command(
-			dockerPath,
-			"run",
-			"--rm",
-			"--label", "gp-rebuild=true",
-			"-it",
-			tag,
-			"bash",
-			"-c",
-			fmt.Sprintf("echo '%s'; bash", welcomeMessage),
-		)
-
-		dockerRunCmd.Stdout = os.Stdout
-		dockerRunCmd.Stderr = os.Stderr
-		dockerRunCmd.Stdin = os.Stdin
-
-		err = dockerRunCmd.Run()
-		if _, ok := err.(*exec.ExitError); ok {
-			fmt.Println("Docker Run Command Failed")
-			event.Set("ErrorCode", utils.RebuildErrorCode_DockerRunFailed)
-			log.WithError(err).Error(err)
-			return
-		} else if err != nil {
-			fmt.Println("Docker error")
-			event.Set("ErrorCode", utils.RebuildErrorCode_DockerErr)
-			log.WithError(err).Error(err)
-			return
+		if err != nil {
+			utils.LogError(ctx, err, "Failed to rebuild", supervisorClient)
+			os.Exit(1)
 		}
 	},
 }