Added scaffolding to return updated-port after upload

commands/daemon/daemon.go

@@ -307,13 +307,17 @@ func (s *ArduinoCoreServerImpl) Upload(req *rpc.UploadRequest, stream rpc.Arduin
 			Message: &rpc.UploadResponse_ErrStream{ErrStream: data},
 		})
 	})
-	err := upload.Upload(stream.Context(), req, outStream, errStream)
+	res, err := upload.Upload(stream.Context(), req, outStream, errStream)
 	outStream.Close()
 	errStream.Close()
-	if err != nil {
-		return convertErrorToRPCStatus(err)
+	if res != nil {
+		syncSend.Send(&rpc.UploadResponse{
+			Message: &rpc.UploadResponse_Result{
+				Result: res,
+			},
+		})
 	}
-	return nil
+	return convertErrorToRPCStatus(err)
 }
 
 // UploadUsingProgrammer FIXMEDOC

commands/upload/burnbootloader.go

@@ -39,7 +39,7 @@ func BurnBootloader(ctx context.Context, req *rpc.BurnBootloaderRequest, outStre
 	}
 	defer release()
 
-	err := runProgramAction(
+	_, err := runProgramAction(
 		pme,
 		nil, // sketch
 		"",  // importFile

commands/upload/upload.go

@@ -123,24 +123,24 @@ func getUserFields(toolID string, platformRelease *cores.PlatformRelease) []*rpc
 }
 
 // Upload FIXMEDOC
-func Upload(ctx context.Context, req *rpc.UploadRequest, outStream io.Writer, errStream io.Writer) error {
+func Upload(ctx context.Context, req *rpc.UploadRequest, outStream io.Writer, errStream io.Writer) (*rpc.UploadResult, error) {
 	logrus.Tracef("Upload %s on %s started", req.GetSketchPath(), req.GetFqbn())
 
 	// TODO: make a generic function to extract sketch from request
 	// and remove duplication in commands/compile.go
 	sketchPath := paths.New(req.GetSketchPath())
 	sk, err := sketch.New(sketchPath)
 	if err != nil && req.GetImportDir() == "" && req.GetImportFile() == "" {
-		return &arduino.CantOpenSketchError{Cause: err}
+		return nil, &arduino.CantOpenSketchError{Cause: err}
 	}
 
 	pme, release := commands.GetPackageManagerExplorer(req)
 	if pme == nil {
-		return &arduino.InvalidInstanceError{}
+		return nil, &arduino.InvalidInstanceError{}
 	}
 	defer release()
 
-	if err := runProgramAction(
+	updatedPort, err := runProgramAction(
 		pme,
 		sk,
 		req.GetImportFile(),
@@ -155,11 +155,14 @@ func Upload(ctx context.Context, req *rpc.UploadRequest, outStream io.Writer, er
 		errStream,
 		req.GetDryRun(),
 		req.GetUserFields(),
-	); err != nil {
-		return err
+	)
+	if err != nil {
+		return nil, err
 	}
 
-	return nil
+	return &rpc.UploadResult{
+		UpdatedUploadPort: updatedPort,
+	}, nil
 }
 
 // UsingProgrammer FIXMEDOC
@@ -169,7 +172,7 @@ func UsingProgrammer(ctx context.Context, req *rpc.UploadUsingProgrammerRequest,
 	if req.GetProgrammer() == "" {
 		return &arduino.MissingProgrammerError{}
 	}
-	err := Upload(ctx, &rpc.UploadRequest{
+	_, err := Upload(ctx, &rpc.UploadRequest{
 		Instance:   req.GetInstance(),
 		SketchPath: req.GetSketchPath(),
 		ImportFile: req.GetImportFile(),
@@ -190,10 +193,10 @@ func runProgramAction(pme *packagemanager.Explorer,
 	programmerID string,
 	verbose, verify, burnBootloader bool,
 	outStream, errStream io.Writer,
-	dryRun bool, userFields map[string]string) error {
+	dryRun bool, userFields map[string]string) (*rpc.Port, error) {
 
 	if burnBootloader && programmerID == "" {
-		return &arduino.MissingProgrammerError{}
+		return nil, &arduino.MissingProgrammerError{}
 	}
 	if port == nil || (port.Address == "" && port.Protocol == "") {
 		// For no-port uploads use "default" protocol
@@ -203,19 +206,19 @@ func runProgramAction(pme *packagemanager.Explorer,
 
 	fqbn, err := cores.ParseFQBN(fqbnIn)
 	if err != nil {
-		return &arduino.InvalidFQBNError{Cause: err}
+		return nil, &arduino.InvalidFQBNError{Cause: err}
 	}
 	logrus.WithField("fqbn", fqbn).Tracef("Detected FQBN")
 
 	// Find target board and board properties
 	_, boardPlatform, board, boardProperties, buildPlatform, err := pme.ResolveFQBN(fqbn)
 	if boardPlatform == nil {
-		return &arduino.PlatformNotFoundError{
+		return nil, &arduino.PlatformNotFoundError{
 			Platform: fmt.Sprintf("%s:%s", fqbn.Package, fqbn.PlatformArch),
 			Cause:    err,
 		}
 	} else if err != nil {
-		return &arduino.UnknownFQBNError{Cause: err}
+		return nil, &arduino.UnknownFQBNError{Cause: err}
 	}
 	logrus.
 		WithField("boardPlatform", boardPlatform).
@@ -232,7 +235,7 @@ func runProgramAction(pme *packagemanager.Explorer,
 			programmer = buildPlatform.Programmers[programmerID]
 		}
 		if programmer == nil {
-			return &arduino.ProgrammerNotFoundError{Programmer: programmerID}
+			return nil, &arduino.ProgrammerNotFoundError{Programmer: programmerID}
 		}
 	}
 
@@ -253,7 +256,7 @@ func runProgramAction(pme *packagemanager.Explorer,
 	}
 	uploadToolID, err := getToolID(props, action, port.Protocol)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	var uploadToolPlatform *cores.PlatformRelease
@@ -268,7 +271,7 @@ func runProgramAction(pme *packagemanager.Explorer,
 		Trace("Upload tool")
 
 	if split := strings.Split(uploadToolID, ":"); len(split) > 2 {
-		return &arduino.InvalidPlatformPropertyError{
+		return nil, &arduino.InvalidPlatformPropertyError{
 			Property: fmt.Sprintf("%s.tool.%s", action, port.Protocol), // TODO: Can be done better, maybe inline getToolID(...)
 			Value:    uploadToolID}
 	} else if len(split) == 2 {
@@ -277,12 +280,12 @@ func runProgramAction(pme *packagemanager.Explorer,
 			PlatformArchitecture: boardPlatform.Platform.Architecture,
 		})
 		if p == nil {
-			return &arduino.PlatformNotFoundError{Platform: split[0] + ":" + boardPlatform.Platform.Architecture}
+			return nil, &arduino.PlatformNotFoundError{Platform: split[0] + ":" + boardPlatform.Platform.Architecture}
 		}
 		uploadToolID = split[1]
 		uploadToolPlatform = pme.GetInstalledPlatformRelease(p)
 		if uploadToolPlatform == nil {
-			return &arduino.PlatformNotFoundError{Platform: split[0] + ":" + boardPlatform.Platform.Architecture}
+			return nil, &arduino.PlatformNotFoundError{Platform: split[0] + ":" + boardPlatform.Platform.Architecture}
 		}
 	}
 
@@ -309,7 +312,7 @@ func runProgramAction(pme *packagemanager.Explorer,
 	}
 
 	if !uploadProperties.ContainsKey("upload.protocol") && programmer == nil {
-		return &arduino.ProgrammerRequiredForUploadError{}
+		return nil, &arduino.ProgrammerRequiredForUploadError{}
 	}
 
 	// Set properties for verbose upload
@@ -357,13 +360,13 @@ func runProgramAction(pme *packagemanager.Explorer,
 	if !burnBootloader {
 		importPath, sketchName, err := determineBuildPathAndSketchName(importFile, importDir, sk, fqbn)
 		if err != nil {
-			return &arduino.NotFoundError{Message: tr("Error finding build artifacts"), Cause: err}
+			return nil, &arduino.NotFoundError{Message: tr("Error finding build artifacts"), Cause: err}
 		}
 		if !importPath.Exist() {
-			return &arduino.NotFoundError{Message: tr("Compiled sketch not found in %s", importPath)}
+			return nil, &arduino.NotFoundError{Message: tr("Compiled sketch not found in %s", importPath)}
 		}
 		if !importPath.IsDir() {
-			return &arduino.NotFoundError{Message: tr("Expected compiled sketch in directory %s, but is a file instead", importPath)}
+			return nil, &arduino.NotFoundError{Message: tr("Expected compiled sketch in directory %s, but is a file instead", importPath)}
 		}
 		uploadProperties.SetPath("build.path", importPath)
 		uploadProperties.Set("build.project_name", sketchName)
@@ -466,22 +469,28 @@ func runProgramAction(pme *packagemanager.Explorer,
 	toolEnv := pme.GetEnvVarsForSpawnedProcess()
 	if burnBootloader {
 		if err := runTool("erase.pattern", uploadProperties, outStream, errStream, verbose, dryRun, toolEnv); err != nil {
-			return &arduino.FailedUploadError{Message: tr("Failed chip erase"), Cause: err}
+			return nil, &arduino.FailedUploadError{Message: tr("Failed chip erase"), Cause: err}
 		}
 		if err := runTool("bootloader.pattern", uploadProperties, outStream, errStream, verbose, dryRun, toolEnv); err != nil {
-			return &arduino.FailedUploadError{Message: tr("Failed to burn bootloader"), Cause: err}
+			return nil, &arduino.FailedUploadError{Message: tr("Failed to burn bootloader"), Cause: err}
 		}
 	} else if programmer != nil {
 		if err := runTool("program.pattern", uploadProperties, outStream, errStream, verbose, dryRun, toolEnv); err != nil {
-			return &arduino.FailedUploadError{Message: tr("Failed programming"), Cause: err}
+			return nil, &arduino.FailedUploadError{Message: tr("Failed programming"), Cause: err}
 		}
 	} else {
 		if err := runTool("upload.pattern", uploadProperties, outStream, errStream, verbose, dryRun, toolEnv); err != nil {
-			return &arduino.FailedUploadError{Message: tr("Failed uploading"), Cause: err}
+			return nil, &arduino.FailedUploadError{Message: tr("Failed uploading"), Cause: err}
 		}
 	}
 
 	logrus.Tracef("Upload successful")
+	return nil, nil // TODO: return new port
+}
+
+func detectNewUploadPort(oldPort *rpc.Port) *rpc.Port {
+	logrus.Tracef("Detecting new board port")
+	// TODO
 	return nil
 }
 

commands/upload/upload_test.go

@@ -184,7 +184,7 @@ func TestUploadPropertiesComposition(t *testing.T) {
 	testRunner := func(t *testing.T, test test, verboseVerify bool) {
 		outStream := &bytes.Buffer{}
 		errStream := &bytes.Buffer{}
-		err := runProgramAction(
+		_, err := runProgramAction(
 			pme,
 			nil,                     // sketch
 			"",                      // importFile

internal/cli/compile/compile.go

@@ -236,6 +236,8 @@ func runCompileCommand(cmd *cobra.Command, args []string) {
 		DoNotExpandBuildProperties:    showProperties == arguments.ShowPropertiesUnexpanded,
 	}
 	compileRes, compileError := compile.Compile(context.Background(), compileRequest, stdOut, stdErr, nil)
+
+	var uploadRes *rpc.UploadResult
 	if compileError == nil && uploadAfterCompile {
 		userFieldRes, err := upload.SupportedUserFields(context.Background(), &rpc.SupportedUserFieldsRequest{
 			Instance: inst,
@@ -268,8 +270,10 @@ func runCompileCommand(cmd *cobra.Command, args []string) {
 			UserFields: fields,
 		}
 
-		if err := upload.Upload(context.Background(), uploadRequest, stdOut, stdErr); err != nil {
+		if res, err := upload.Upload(context.Background(), uploadRequest, stdOut, stdErr); err != nil {
 			feedback.Fatal(tr("Error during Upload: %v", err), feedback.ErrGeneric)
+		} else {
+			uploadRes = res
 		}
 	}
 
@@ -330,6 +334,7 @@ func runCompileCommand(cmd *cobra.Command, args []string) {
 		CompilerOut:        stdIO.Stdout,
 		CompilerErr:        stdIO.Stderr,
 		BuilderResult:      compileRes,
+		UploadResult:       uploadRes,
 		ProfileOut:         profileOut,
 		Success:            compileError == nil,
 		showPropertiesMode: showProperties,
@@ -375,6 +380,7 @@ type compileResult struct {
 	CompilerOut   string               `json:"compiler_out"`
 	CompilerErr   string               `json:"compiler_err"`
 	BuilderResult *rpc.CompileResponse `json:"builder_result"`
+	UploadResult  *rpc.UploadResult    `json:"upload_result"`
 	Success       bool                 `json:"success"`
 	ProfileOut    string               `json:"profile_out,omitempty"`
 	Error         string               `json:"error,omitempty"`

internal/cli/upload/upload.go

@@ -168,8 +168,31 @@ func runUploadCommand(command *cobra.Command, args []string) {
 		DryRun:     dryRun,
 		UserFields: fields,
 	}
-	if err := upload.Upload(context.Background(), req, stdOut, stdErr); err != nil {
+	if res, err := upload.Upload(context.Background(), req, stdOut, stdErr); err != nil {
 		feedback.FatalError(err, feedback.ErrGeneric)
+	} else {
+		io := stdIOResult()
+		feedback.PrintResult(&uploadResult{
+			Stdout:            io.Stdout,
+			Stderr:            io.Stderr,
+			UpdatedUploadPort: res.UpdatedUploadPort,
+		})
 	}
-	feedback.PrintResult(stdIOResult())
+}
+
+type uploadResult struct {
+	Stdout            string    `json:"stdout"`
+	Stderr            string    `json:"stderr"`
+	UpdatedUploadPort *rpc.Port `json:"updated_upload_port,omitempty"`
+}
+
+func (r *uploadResult) Data() interface{} {
+	return r
+}
+
+func (r *uploadResult) String() string {
+	if r.UpdatedUploadPort == nil {
+		return ""
+	}
+	return tr("New upload port: %[1]s (%[2]s)", r.UpdatedUploadPort.Address, r.UpdatedUploadPort.Protocol)
 }