Update gRPC API of remaining commands to return status.Status instead of error

Author: per1234

cli/compile/compile.go

@@ -180,7 +180,7 @@ func run(cmd *cobra.Command, args []string) {
 	compileErr := new(bytes.Buffer)
 	verboseCompile := configuration.Settings.GetString("logging.level") == "debug"
 	var compileRes *rpc.CompileResponse
-	var err error
+	var err *status.Status
 	if output.OutputFormat == "json" {
 		compileRes, err = compile.Compile(context.Background(), compileRequest, compileOut, compileErr, verboseCompile)
 	} else {
@@ -198,7 +198,6 @@ func run(cmd *cobra.Command, args []string) {
 			ImportDir:  buildPath,
 			Programmer: programmer,
 		}
-		var err *status.Status
 		if output.OutputFormat == "json" {
 			// TODO: do not print upload output in json mode
 			uploadOut := new(bytes.Buffer)

cli/core/upgrade.go

@@ -94,7 +94,7 @@ func runUpgradeCommand(cmd *cobra.Command, args []string) {
 		}
 
 		_, err := core.PlatformUpgrade(context.Background(), r, output.ProgressBar(), output.TaskProgress())
-		if err == core.ErrAlreadyLatest {
+		if err.Message() == core.ErrAlreadyLatest.Error() {
 			feedback.Printf("Platform %s is already at the latest version", platformRef)
 		} else if err != nil {
 			feedback.Errorf("Error during upgrade: %v", err)

cli/debug/debug.go

@@ -33,7 +33,6 @@ import (
 	"github.com/fatih/color"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"google.golang.org/grpc/status"
 )
 
 var (
@@ -90,12 +89,8 @@ func run(command *cobra.Command, args []string) {
 	if printInfo {
 
 		if res, err := debug.GetDebugConfig(context.Background(), debugConfigRequested); err != nil {
-			if status, ok := status.FromError(err); ok {
-				feedback.Errorf("Error getting Debug info: %v", status.Message())
-				errorcodes.ExitWithGrpcStatus(status)
-			}
-			feedback.Errorf("Error getting Debug info: %v", err)
-			os.Exit(errorcodes.ErrGeneric)
+			feedback.Errorf("Error getting Debug info: %v", err.Message())
+			errorcodes.ExitWithGrpcStatus(err)
 		} else {
 			feedback.PrintResult(&debugInfoResult{res})
 		}

cli/instance/instance.go

@@ -26,7 +26,6 @@ import (
 	"github.com/arduino/arduino-cli/configuration"
 	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
 	"github.com/arduino/go-paths-helper"
-	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
@@ -117,7 +116,7 @@ func FirstUpdate(instance *rpc.Instance) *status.Status {
 			output.ProgressBar(),
 		)
 		if err != nil {
-			return status.Newf(codes.FailedPrecondition, err.Error())
+			return err
 		}
 	}
 
@@ -132,7 +131,7 @@ func FirstUpdate(instance *rpc.Instance) *status.Status {
 			output.ProgressBar(),
 		)
 		if err != nil {
-			return status.Newf(codes.FailedPrecondition, err.Error())
+			return err
 		}
 	}
 

cli/lib/args.go

@@ -75,13 +75,13 @@ func ParseLibraryReferenceArgs(args []string) ([]*LibraryReferenceArg, error) {
 // ParseLibraryReferenceArgAndAdjustCase parse a command line argument that reference a
 // library and possibly adjust the case of the name to match a library in the index
 func ParseLibraryReferenceArgAndAdjustCase(instance *rpc.Instance, arg string) (*LibraryReferenceArg, error) {
-	libRef, err := ParseLibraryReferenceArg(arg)
+	libRef, _ := ParseLibraryReferenceArg(arg)
 	res, err := lib.LibrarySearch(context.Background(), &rpc.LibrarySearchRequest{
 		Instance: instance,
 		Query:    libRef.Name,
 	})
 	if err != nil {
-		return nil, err
+		return nil, err.Err()
 	}
 
 	candidates := []*rpc.SearchedLibrary{}

cli/lib/check_deps.go

@@ -51,12 +51,12 @@ func runDepsCommand(cmd *cobra.Command, args []string) {
 		os.Exit(errorcodes.ErrBadArgument)
 	}
 
-	deps, err := lib.LibraryResolveDependencies(context.Background(), &rpc.LibraryResolveDependenciesRequest{
+	deps, stat := lib.LibraryResolveDependencies(context.Background(), &rpc.LibraryResolveDependenciesRequest{
 		Instance: instance,
 		Name:     libRef.Name,
 		Version:  libRef.Version,
 	})
-	if err != nil {
+	if stat != nil {
 		feedback.Errorf("Error resolving dependencies for %s: %s", libRef, err)
 	}
 

commands/compile/compile.go

@@ -40,10 +40,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/segmentio/stats/v4"
 	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 // Compile FIXMEDOC
-func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream io.Writer, debug bool) (r *rpc.CompileResponse, e error) {
+func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream io.Writer, debug bool) (r *rpc.CompileResponse, e *status.Status) {
 
 	// There is a binding between the export binaries setting and the CLI flag to explicitly set it,
 	// since we want this binding to work also for the gRPC interface we must read it here in this
@@ -87,29 +89,29 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 
 	pm := commands.GetPackageManager(req.GetInstance().GetId())
 	if pm == nil {
-		return nil, errors.New("invalid instance")
+		return nil, status.New(codes.InvalidArgument, "invalid instance")
 	}
 
 	logrus.Tracef("Compile %s for %s started", req.GetSketchPath(), req.GetFqbn())
 	if req.GetSketchPath() == "" {
-		return nil, fmt.Errorf("missing sketchPath")
+		return nil, status.New(codes.InvalidArgument, "missing sketchPath")
 	}
 	sketchPath := paths.New(req.GetSketchPath())
 	sketch, err := sketches.NewSketchFromPath(sketchPath)
 	if err != nil {
-		return nil, fmt.Errorf("opening sketch: %s", err)
+		return nil, status.Newf(codes.NotFound, "opening sketch: %s", err)
 	}
 
 	fqbnIn := req.GetFqbn()
 	if fqbnIn == "" && sketch != nil && sketch.Metadata != nil {
 		fqbnIn = sketch.Metadata.CPU.Fqbn
 	}
 	if fqbnIn == "" {
-		return nil, fmt.Errorf("no FQBN provided")
+		return nil, status.New(codes.InvalidArgument, "no FQBN provided")
 	}
 	fqbn, err := cores.ParseFQBN(fqbnIn)
 	if err != nil {
-		return nil, fmt.Errorf("incorrect FQBN: %s", err)
+		return nil, status.Newf(codes.InvalidArgument, "incorrect FQBN: %s", err)
 	}
 
 	targetPlatform := pm.FindPlatform(&packagemanager.PlatformReference{
@@ -122,7 +124,7 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 		// 	"\"%[1]s:%[2]s\" platform is not installed, please install it by running \""+
 		// 		version.GetAppName()+" core install %[1]s:%[2]s\".", fqbn.Package, fqbn.PlatformArch)
 		// feedback.Error(errorMessage)
-		return nil, fmt.Errorf("platform not installed")
+		return nil, status.New(codes.NotFound, "platform not installed")
 	}
 
 	builderCtx := &types.Context{}
@@ -145,7 +147,7 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 		builderCtx.BuildPath = paths.New(req.GetBuildPath())
 	}
 	if err = builderCtx.BuildPath.MkdirAll(); err != nil {
-		return nil, fmt.Errorf("cannot create build directory: %s", err)
+		return nil, status.Newf(codes.PermissionDenied, "cannot create build directory: %s", err)
 	}
 	builderCtx.CompilationDatabase = bldr.NewCompilationDatabase(
 		builderCtx.BuildPath.Join("compile_commands.json"),
@@ -175,7 +177,7 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 		builderCtx.BuildCachePath = paths.New(req.GetBuildCachePath())
 		err = builderCtx.BuildCachePath.MkdirAll()
 		if err != nil {
-			return nil, fmt.Errorf("cannot create build cache directory: %s", err)
+			return nil, status.Newf(codes.PermissionDenied, "cannot create build cache directory: %s", err)
 		}
 	}
 
@@ -218,14 +220,14 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 
 	// if --preprocess or --show-properties were passed, we can stop here
 	if req.GetShowProperties() {
-		return r, builder.RunParseHardwareAndDumpBuildProperties(builderCtx)
+		return r, status.Convert(builder.RunParseHardwareAndDumpBuildProperties(builderCtx))
 	} else if req.GetPreprocess() {
-		return r, builder.RunPreprocess(builderCtx)
+		return r, status.Convert(builder.RunPreprocess(builderCtx))
 	}
 
 	// if it's a regular build, go on...
 	if err := builder.RunBuilder(builderCtx); err != nil {
-		return r, err
+		return r, status.Convert(err)
 	}
 
 	// If the export directory is set we assume you want to export the binaries
@@ -247,17 +249,17 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 		}
 		logrus.WithField("path", exportPath).Trace("Saving sketch to export path.")
 		if err := exportPath.MkdirAll(); err != nil {
-			return r, errors.Wrap(err, "creating output dir")
+			return r, status.New(codes.PermissionDenied, errors.Wrap(err, "creating output dir").Error())
 		}
 
 		// Copy all "sketch.ino.*" artifacts to the export directory
 		baseName, ok := builderCtx.BuildProperties.GetOk("build.project_name") // == "sketch.ino"
 		if !ok {
-			return r, errors.New("missing 'build.project_name' build property")
+			return r, status.New(codes.Internal, "missing 'build.project_name' build property")
 		}
 		buildFiles, err := builderCtx.BuildPath.ReadDir()
 		if err != nil {
-			return r, errors.Errorf("reading build directory: %s", err)
+			return r, status.Newf(codes.PermissionDenied, "reading build directory: %s", err)
 		}
 		buildFiles.FilterPrefix(baseName)
 		for _, buildFile := range buildFiles {
@@ -267,7 +269,7 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 				WithField("dest", exportedFile).
 				Trace("Copying artifact.")
 			if err = buildFile.CopyTo(exportedFile); err != nil {
-				return r, errors.Wrapf(err, "copying output file %s", buildFile)
+				return r, status.New(codes.PermissionDenied, errors.Wrapf(err, "copying output file %s", buildFile).Error())
 			}
 		}
 	}
@@ -276,7 +278,7 @@ func Compile(ctx context.Context, req *rpc.CompileRequest, outStream, errStream
 	for _, lib := range builderCtx.ImportedLibraries {
 		rpcLib, err := lib.ToRPCLibrary()
 		if err != nil {
-			return r, fmt.Errorf("converting library %s to rpc struct: %w", lib.Name, err)
+			return r, status.Newf(codes.PermissionDenied, fmt.Errorf("converting library %s to rpc struct: %w", lib.Name, err).Error())
 		}
 		importedLibs = append(importedLibs, rpcLib)
 	}

commands/core/download.go

@@ -17,25 +17,26 @@ package core
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	"github.com/arduino/arduino-cli/arduino/cores"
 	"github.com/arduino/arduino-cli/arduino/cores/packagemanager"
 	"github.com/arduino/arduino-cli/commands"
 	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 // PlatformDownload FIXMEDOC
-func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadRequest, downloadCB commands.DownloadProgressCB) (*rpc.PlatformDownloadResponse, error) {
+func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadRequest, downloadCB commands.DownloadProgressCB) (*rpc.PlatformDownloadResponse, *status.Status) {
 	pm := commands.GetPackageManager(req.GetInstance().GetId())
 	if pm == nil {
-		return nil, errors.New("invalid instance")
+		return nil, status.New(codes.InvalidArgument, "invalid instance")
 	}
 
 	version, err := commands.ParseVersion(req)
 	if err != nil {
-		return nil, fmt.Errorf("invalid version: %s", err)
+		return nil, status.Newf(codes.InvalidArgument, "invalid version: %s", err)
 	}
 
 	platform, tools, err := pm.FindPlatformReleaseDependencies(&packagemanager.PlatformReference{
@@ -44,18 +45,18 @@ func PlatformDownload(ctx context.Context, req *rpc.PlatformDownloadRequest, dow
 		PlatformVersion:      version,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("find platform dependencies: %s", err)
+		return nil, status.Newf(codes.InvalidArgument, "find platform dependencies: %s", err)
 	}
 
 	err = downloadPlatform(pm, platform, downloadCB)
 	if err != nil {
-		return nil, err
+		return nil, status.New(codes.Unavailable, err.Error())
 	}
 
 	for _, tool := range tools {
 		err := downloadTool(pm, tool, downloadCB)
 		if err != nil {
-			return nil, fmt.Errorf("downloading tool %s: %s", tool, err)
+			return nil, status.Newf(codes.Unavailable, "downloading tool %s: %s", tool, err)
 		}
 	}
 

commands/core/install.go

@@ -23,21 +23,22 @@ import (
 	"github.com/arduino/arduino-cli/arduino/cores/packagemanager"
 	"github.com/arduino/arduino-cli/commands"
 	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
-	"github.com/pkg/errors"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 // PlatformInstall FIXMEDOC
 func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallRequest,
-	downloadCB commands.DownloadProgressCB, taskCB commands.TaskProgressCB) (*rpc.PlatformInstallResponse, error) {
+	downloadCB commands.DownloadProgressCB, taskCB commands.TaskProgressCB) (*rpc.PlatformInstallResponse, *status.Status) {
 
 	pm := commands.GetPackageManager(req.GetInstance().GetId())
 	if pm == nil {
-		return nil, errors.New("invalid instance")
+		return nil, status.New(codes.InvalidArgument, "invalid instance")
 	}
 
 	version, err := commands.ParseVersion(req)
 	if err != nil {
-		return nil, fmt.Errorf("invalid version: %s", err)
+		return nil, status.Newf(codes.InvalidArgument, "invalid version: %s", err)
 	}
 
 	platform, tools, err := pm.FindPlatformReleaseDependencies(&packagemanager.PlatformReference{
@@ -46,17 +47,17 @@ func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallRequest,
 		PlatformVersion:      version,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("finding platform dependencies: %s", err)
+		return nil, status.Newf(codes.InvalidArgument, "finding platform dependencies: %s", err)
 	}
 
 	err = installPlatform(pm, platform, tools, downloadCB, taskCB, req.GetSkipPostInstall())
 	if err != nil {
-		return nil, err
+		return nil, status.Convert(err)
 	}
 
 	status := commands.Init(&rpc.InitRequest{Instance: req.Instance}, nil)
 	if status != nil {
-		return nil, status.Err()
+		return nil, status
 	}
 
 	return &rpc.PlatformInstallResponse{}, nil

commands/core/list.go

@@ -21,21 +21,22 @@ import (
 
 	"github.com/arduino/arduino-cli/commands"
 	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
-	"github.com/pkg/errors"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 // GetPlatforms returns a list of installed platforms, optionally filtered by
 // those requiring an update.
-func GetPlatforms(req *rpc.PlatformListRequest) ([]*rpc.Platform, error) {
+func GetPlatforms(req *rpc.PlatformListRequest) ([]*rpc.Platform, *status.Status) {
 	instanceID := req.Instance.Id
 	i := commands.GetInstance(instanceID)
 	if i == nil {
-		return nil, errors.Errorf("unable to find an instance with ID: %d", instanceID)
+		return nil, status.Newf(codes.InvalidArgument, "unable to find an instance with ID: %d", instanceID)
 	}
 
 	packageManager := i.PackageManager
 	if packageManager == nil {
-		return nil, errors.New("invalid instance")
+		return nil, status.New(codes.InvalidArgument, "invalid instance")
 	}
 
 	res := []*rpc.Platform{}