Implemented TaskProgress, replacing formatter module

Author: cmaglie

cli/compile/compile.go

@@ -21,11 +21,11 @@ import (
 	"context"
 	"os"
 
+	"github.com/arduino/arduino-cli/cli"
 	"github.com/arduino/arduino-cli/commands/compile"
 	"github.com/arduino/arduino-cli/common/formatter"
+	"github.com/arduino/arduino-cli/output"
 	"github.com/arduino/arduino-cli/rpc"
-
-	"github.com/arduino/arduino-cli/cli"
 	"github.com/spf13/cobra"
 )
 
@@ -111,7 +111,7 @@ func run(cmd *cobra.Command, args []string) {
 		Quiet:           flags.quiet,
 		VidPid:          flags.vidPid,
 		ExportFile:      flags.exportFile,
-	}, os.Stdout)
+	}, os.Stdout, output.NewTaskProgressCB())
 	if err == nil {
 		outputCompileResp(compRes)
 	} else {

cli/core/install.go

@@ -55,7 +55,7 @@ func runInstallCommand(cmd *cobra.Command, args []string) {
 			PlatformPackage: platformRef.Package,
 			Architecture:    platformRef.PlatformArchitecture,
 			Version:         platformRef.PlatformVersion.String(),
-		}, output.DownloadProgressBar())
+		}, output.DownloadProgressBar(), output.NewTaskProgressCB())
 		// if err != nil {
 		// 	formatter.PrintError(err, "Error during build")
 		// 	os.Exit(cli.ErrGeneric)

cli/core/upgrade.go

@@ -54,6 +54,6 @@ func runUpgradeCommand(cmd *cobra.Command, args []string) {
 			PlatformPackage: platformRef.Package,
 			Architecture:    platformRef.PlatformArchitecture,
 			Version:         platformRef.PlatformVersion.String(),
-		}, output.DownloadProgressBar())
+		}, output.DownloadProgressBar(), output.NewTaskProgressCB())
 	}
 }

commands/compile/compile.go

@@ -14,6 +14,7 @@ import (
 	"github.com/arduino/arduino-cli/arduino/cores"
 	"github.com/arduino/arduino-cli/arduino/cores/packagemanager"
 	"github.com/arduino/arduino-cli/cli"
+	"github.com/arduino/arduino-cli/commands"
 	"github.com/arduino/arduino-cli/commands/core"
 	"github.com/arduino/arduino-cli/common/formatter"
 	"github.com/arduino/arduino-cli/rpc"
@@ -22,7 +23,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-func Compile(ctx context.Context, req *rpc.CompileReq, output io.Writer) (*rpc.CompileResp, error) {
+func Compile(ctx context.Context, req *rpc.CompileReq,
+	output io.Writer, taskCB commands.TaskProgressCB) (*rpc.CompileResp, error) {
 	logrus.Info("Executing `arduino compile`")
 	var sketchPath *paths.Path
 	if req.GetSketchPath() != "" {
@@ -55,7 +57,7 @@ func Compile(ctx context.Context, req *rpc.CompileReq, output io.Writer) (*rpc.C
 		core.DownloadToolRelease(pm, ctags, func(curr *rpc.DownloadProgress) {
 			fmt.Printf(">> %+v\n", curr)
 		})
-		core.InstallToolRelease(pm, ctags)
+		core.InstallToolRelease(pm, ctags, taskCB)
 
 		if err := pm.LoadHardware(cli.Config); err != nil {
 			return nil, fmt.Errorf("loading hardware packages: %s", err)

commands/core/download.go

@@ -30,7 +30,7 @@ import (
 	semver "go.bug.st/relaxed-semver"
 )
 
-func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadReq, progressCallback func(*rpc.DownloadProgress)) (*rpc.PlatformDownloadResp, error) {
+func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadReq, progress commands.ProgressCB) (*rpc.PlatformDownloadResp, error) {
 	var version *semver.Version
 	if v, err := semver.Parse(req.Version); err == nil {
 		version = v
@@ -48,13 +48,13 @@ func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadReq, progres
 		return nil, fmt.Errorf("find platform dependencies: %s", err)
 	}
 
-	err = downloadPlatform(pm, platform, progressCallback)
+	err = downloadPlatform(pm, platform, progress)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, tool := range tools {
-		err := downloadTool(pm, tool, progressCallback)
+		err := downloadTool(pm, tool, progress)
 		if err != nil {
 			return nil, fmt.Errorf("downloading tool %s: %s", tool, err)
 		}
@@ -63,53 +63,53 @@ func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadReq, progres
 	return &rpc.PlatformDownloadResp{}, nil
 }
 
-func downloadPlatform(pm *packagemanager.PackageManager, platformRelease *cores.PlatformRelease, progressCallback func(*rpc.DownloadProgress)) error {
+func downloadPlatform(pm *packagemanager.PackageManager, platformRelease *cores.PlatformRelease, progress commands.ProgressCB) error {
 	// Download platform
 	resp, err := pm.DownloadPlatformRelease(platformRelease)
 	if err != nil {
 		return err
 	}
-	return download(resp, platformRelease.String(), progressCallback)
+	return download(resp, platformRelease.String(), progress)
 }
 
-func downloadTool(pm *packagemanager.PackageManager, tool *cores.ToolRelease, progressCallback func(*rpc.DownloadProgress)) error {
+func downloadTool(pm *packagemanager.PackageManager, tool *cores.ToolRelease, progress commands.ProgressCB) error {
 	// Check if tool has a flavor available for the current OS
 	if tool.GetCompatibleFlavour() == nil {
 		return fmt.Errorf("tool %s not available for the current OS", tool)
 	}
 
-	return DownloadToolRelease(pm, tool, progressCallback)
+	return DownloadToolRelease(pm, tool, progress)
 }
 
 // DownloadToolRelease downloads a ToolRelease
-func DownloadToolRelease(pm *packagemanager.PackageManager, toolRelease *cores.ToolRelease, progressCallback func(*rpc.DownloadProgress)) error {
+func DownloadToolRelease(pm *packagemanager.PackageManager, toolRelease *cores.ToolRelease, progress commands.ProgressCB) error {
 	resp, err := pm.DownloadToolRelease(toolRelease)
 	if err != nil {
 		return err
 	}
-	return download(resp, toolRelease.String(), progressCallback)
+	return download(resp, toolRelease.String(), progress)
 }
 
-func download(d *downloader.Downloader, label string, progressCallback func(*rpc.DownloadProgress)) error {
+func download(d *downloader.Downloader, label string, progress commands.ProgressCB) error {
 	if d == nil {
 		// This signal means that the file is already downloaded
-		progressCallback(&rpc.DownloadProgress{
+		progress(&rpc.DownloadProgress{
 			File:      label,
 			Completed: true,
 		})
 		return nil
 	}
-	progressCallback(&rpc.DownloadProgress{
+	progress(&rpc.DownloadProgress{
 		File:      label,
 		Url:       d.URL,
 		TotalSize: d.Size(),
 	})
 	d.RunAndPoll(func(downloaded int64) {
-		progressCallback(&rpc.DownloadProgress{Downloaded: downloaded})
+		progress(&rpc.DownloadProgress{Downloaded: downloaded})
 	}, 250*time.Millisecond)
 	if d.Error() != nil {
 		return d.Error()
 	}
-	progressCallback(&rpc.DownloadProgress{Completed: true})
+	progress(&rpc.DownloadProgress{Completed: true})
 	return nil
 }

commands/core/install.go

@@ -12,7 +12,8 @@ import (
 	semver "go.bug.st/relaxed-semver"
 )
 
-func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallReq, progress commands.ProgressCB) (*rpc.PlatformInstallResp, error) {
+func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallReq,
+	progress commands.ProgressCB, taskCB commands.TaskProgressCB) (*rpc.PlatformInstallResp, error) {
 	var version *semver.Version
 	if req.Version != "" {
 		if v, err := semver.Parse(req.Version); err == nil {
@@ -21,18 +22,18 @@ func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallReq, progress
 			return nil, fmt.Errorf("invalid version: %s", err)
 		}
 	}
-	ref := &packagemanager.PlatformReference{
+
+	pm := commands.GetPackageManager(req)
+	platform, tools, err := pm.FindPlatformReleaseDependencies(&packagemanager.PlatformReference{
 		Package:              req.PlatformPackage,
 		PlatformArchitecture: req.Architecture,
-		PlatformVersion:      version}
-	pm := commands.GetPackageManager(req)
-	platform, tools, err := pm.FindPlatformReleaseDependencies(ref)
+		PlatformVersion:      version,
+	})
 	if err != nil {
-		formatter.PrintError(err, "Could not determine platform dependencies")
-		return nil, fmt.Errorf("Could not determine platform dependencies: %s", err)
+		return nil, fmt.Errorf("finding platform dependencies: %s", err)
 	}
 
-	err = installPlatform(pm, platform, tools, progress)
+	err = installPlatform(pm, platform, tools, progress, taskCB)
 	if err != nil {
 		return nil, err
 	}
@@ -47,51 +48,56 @@ func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallReq, progress
 
 func installPlatform(pm *packagemanager.PackageManager,
 	platformRelease *cores.PlatformRelease, requiredTools []*cores.ToolRelease,
-	progress commands.ProgressCB) error {
+	progress commands.ProgressCB, taskCB commands.TaskProgressCB) error {
 	log := pm.Log.WithField("platform", platformRelease)
 
 	// Prerequisite checks before install
 	if platformRelease.IsInstalled() {
 		log.Warn("Platform already installed")
-		formatter.Print("Platform " + platformRelease.String() + " already installed")
-		return fmt.Errorf("Platform " + platformRelease.String() + " already installed")
+		taskCB(&rpc.TaskProgress{Name: "Platform " + platformRelease.String() + " already installed", Completed: true})
+		return nil
 	}
 	toolsToInstall := []*cores.ToolRelease{}
 	for _, tool := range requiredTools {
 		if tool.IsInstalled() {
 			log.WithField("tool", tool).Warn("Tool already installed")
-			formatter.Print("Tool " + tool.String() + " already installed")
+			taskCB(&rpc.TaskProgress{Name: "Tool " + tool.String() + " already installed", Completed: true})
 		} else {
 			toolsToInstall = append(toolsToInstall, tool)
 		}
 	}
 
 	// Package download
+	taskCB(&rpc.TaskProgress{Name: "Downloading packages"})
 	for _, tool := range toolsToInstall {
 		downloadTool(pm, tool, progress)
 	}
 	downloadPlatform(pm, platformRelease, progress)
+	taskCB(&rpc.TaskProgress{Completed: true})
 
+	// Install tools first
 	for _, tool := range toolsToInstall {
-		InstallToolRelease(pm, tool)
+		err := InstallToolRelease(pm, tool, taskCB)
+		if err != nil {
+			// TODO: handle error
+		}
 	}
 
 	// Are we installing or upgrading?
 	platform := platformRelease.Platform
 	installed := pm.GetInstalledPlatformRelease(platform)
 	if installed == nil {
 		log.Info("Installing platform")
-		formatter.Print("Installing " + platformRelease.String() + "...")
+		taskCB(&rpc.TaskProgress{Name: "Installing " + platformRelease.String()})
 	} else {
 		log.Info("Updating platform " + installed.String())
-		formatter.Print("Updating " + installed.String() + " with " + platformRelease.String() + "...")
+		taskCB(&rpc.TaskProgress{Name: "Updating " + installed.String() + " with " + platformRelease.String()})
 	}
 
 	// Install
 	err := pm.InstallPlatform(platformRelease)
 	if err != nil {
 		log.WithError(err).Error("Cannot install platform")
-		formatter.PrintError(err, "Cannot install platform")
 		return err
 	}
 
@@ -102,43 +108,44 @@ func installPlatform(pm *packagemanager.PackageManager,
 		// In case of error try to rollback
 		if errUn != nil {
 			log.WithError(errUn).Error("Error updating platform.")
-			formatter.PrintError(errUn, "Error updating platform")
+			taskCB(&rpc.TaskProgress{Message: "Error updating platform: " + err.Error()})
 
 			// Rollback
 			if err := pm.UninstallPlatform(platformRelease); err != nil {
 				log.WithError(err).Error("Error rolling-back changes.")
-				formatter.PrintError(err, "Error rolling-back changes.")
-				return fmt.Errorf("rolling-back changes: %s", err)
+				taskCB(&rpc.TaskProgress{Message: "Error rolling-back changes: " + err.Error()})
+				//return fmt.Errorf("rolling-back changes: %s", err)
 			}
+
 			return fmt.Errorf("updating platform: %s", errUn)
 		}
 	}
 
 	log.Info("Platform installed")
-	formatter.Print(platformRelease.String() + " installed")
+	taskCB(&rpc.TaskProgress{Message: platformRelease.String() + " installed", Completed: true})
 	return nil
 }
 
 // InstallToolRelease installs a ToolRelease
-func InstallToolRelease(pm *packagemanager.PackageManager, toolRelease *cores.ToolRelease) error {
+func InstallToolRelease(pm *packagemanager.PackageManager, toolRelease *cores.ToolRelease, taskCB commands.TaskProgressCB) error {
 	log := pm.Log.WithField("Tool", toolRelease)
 
 	if toolRelease.IsInstalled() {
 		log.Warn("Tool already installed")
-		formatter.Print("Tool " + toolRelease.String() + " already installed")
-		return fmt.Errorf("Tool " + toolRelease.String() + " already installed")
+		taskCB(&rpc.TaskProgress{Name: "Tool " + toolRelease.String() + " already installed", Completed: true})
+		return nil
 	}
 
 	log.Info("Installing tool")
-	formatter.Print("Installing " + toolRelease.String() + "...")
+	taskCB(&rpc.TaskProgress{Name: "Installing " + toolRelease.String()})
 	err := pm.InstallTool(toolRelease)
 	if err != nil {
 		log.WithError(err).Warn("Cannot install tool")
 		formatter.PrintError(err, "Cannot install tool: "+toolRelease.String())
 		return fmt.Errorf("Cannot install tool: "+toolRelease.String(), err)
 	}
-
 	log.Info("Tool installed")
-	formatter.Print(toolRelease.String() + " installed")
+	taskCB(&rpc.TaskProgress{Message: toolRelease.String() + " installed", Completed: true})
+
 	return nil
 }

commands/core/upgrade.go

@@ -28,7 +28,8 @@ import (
 	semver "go.bug.st/relaxed-semver"
 )
 
-func PlatformUpgrade(ctx context.Context, req *rpc.PlatformUpgradeReq, progress commands.ProgressCB) (*rpc.PlatformUpgradeResp, error) {
+func PlatformUpgrade(ctx context.Context, req *rpc.PlatformUpgradeReq,
+	progress commands.ProgressCB, taskCB commands.TaskProgressCB) (*rpc.PlatformUpgradeResp, error) {
 	// Extract all PlatformReference to platforms that have updates
 	var version *semver.Version
 	if req.Version != "" {
@@ -44,7 +45,7 @@ func PlatformUpgrade(ctx context.Context, req *rpc.PlatformUpgradeReq, progress
 		PlatformVersion:      version}
 	pm := commands.GetPackageManager(req)
 
-	err := upgradePlatform(pm, ref, progress)
+	err := upgradePlatform(pm, ref, progress, taskCB)
 	if err != nil {
 		return nil, err
 	}
@@ -57,7 +58,8 @@ func PlatformUpgrade(ctx context.Context, req *rpc.PlatformUpgradeReq, progress
 	return &rpc.PlatformUpgradeResp{}, nil
 }
 
-func upgradePlatform(pm *packagemanager.PackageManager, platformRef *packagemanager.PlatformReference, progress commands.ProgressCB) error {
+func upgradePlatform(pm *packagemanager.PackageManager, platformRef *packagemanager.PlatformReference,
+	progress commands.ProgressCB, taskCB commands.TaskProgressCB) error {
 	if platformRef.PlatformVersion != nil {
 		formatter.PrintErrorMessage("Invalid item " + platformRef.String() + ", upgrade doesn't accept parameters with version")
 		return fmt.Errorf("Invalid item " + platformRef.String() + ", upgrade doesn't accept parameters with version")
@@ -88,7 +90,7 @@ func upgradePlatform(pm *packagemanager.PackageManager, platformRef *packagemana
 		if err != nil {
 			return fmt.Errorf("Platform " + platformRef.String() + " is not installed")
 		}
-		err = installPlatform(pm, platform, tools, progress)
+		err = installPlatform(pm, platform, tools, progress, taskCB)
 		if err != nil {
 			return err
 		}

commands/progress.go

@@ -4,3 +4,6 @@ import "github.com/arduino/arduino-cli/rpc"
 
 // ProgressCB is a callback to get updates on download progress
 type ProgressCB func(curr *rpc.DownloadProgress)
+
+// TaskProgressCB is a callback to receive progress messages
+type TaskProgressCB func(msg *rpc.TaskProgress)

daemon/daemon.go

@@ -67,14 +67,18 @@ func (s *ArduinoCoreServerImpl) Compile(req *rpc.CompileReq, stream rpc.ArduinoC
 			}
 		}
 	}()
-	resp, err := compile.Compile(stream.Context(), req, w)
+	resp, err := compile.Compile(stream.Context(), req, w, func(taskProgress *rpc.TaskProgress) {
+		// TODO
+	})
 	stream.Send(resp)
 	return err
 }
 
 func (s *ArduinoCoreServerImpl) PlatformInstall(req *rpc.PlatformInstallReq, stream rpc.ArduinoCore_PlatformInstallServer) error {
 	resp, err := core.PlatformInstall(stream.Context(), req, func(progress *rpc.DownloadProgress) {
 		stream.Send(&rpc.PlatformInstallResp{Progress: progress})
+	}, func(taskProgress *rpc.TaskProgress) {
+		// TODO
 	})
 	if err != nil {
 		return err
@@ -99,6 +103,8 @@ func (s *ArduinoCoreServerImpl) PlatformUninstall(ctx context.Context, req *rpc.
 func (s *ArduinoCoreServerImpl) PlatformUpgrade(req *rpc.PlatformUpgradeReq, stream rpc.ArduinoCore_PlatformUpgradeServer) error {
 	resp, err := core.PlatformUpgrade(stream.Context(), req, func(progress *rpc.DownloadProgress) {
 		stream.Send(&rpc.PlatformUpgradeResp{Progress: progress})
+	}, func(taskProgress *rpc.TaskProgress) {
+		// TODO
 	})
 	if err != nil {
 		return err