Add support for upload user fields

cli/arguments/user_fields.go

@@ -0,0 +1,51 @@
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+package arguments
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+
+	"github.com/arduino/arduino-cli/cli/feedback"
+	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// AskForUserFields prompts the user to input the provided user fields.
+// If there is an error reading input it panics.
+func AskForUserFields(userFields []*rpc.UserField) map[string]string {
+	writer := feedback.OutputWriter()
+	fields := map[string]string{}
+	reader := bufio.NewReader(os.Stdin)
+	for _, f := range userFields {
+		fmt.Fprintf(writer, "%s: ", f.Label)
+		var value []byte
+		var err error
+		if f.Secret {
+			value, err = terminal.ReadPassword(int(os.Stdin.Fd()))
+		} else {
+			value, err = reader.ReadBytes('\n')
+		}
+		if err != nil {
+			panic(err)
+		}
+		fields[f.Name] = string(value)
+	}
+	fmt.Fprintln(writer, "")
+
+	return fields
+}

cli/compile/compile.go

@@ -190,16 +190,33 @@ func run(cmd *cobra.Command, args []string) {
 	}
 
 	if err == nil && uploadAfterCompile {
-
 		var sk *sketch.Sketch
 		sk, err = sketch.New(sketchPath)
 		if err != nil {
-
+			feedback.Errorf("Error during Upload: %v", err)
+			os.Exit(errorcodes.ErrGeneric)
 		}
 		var discoveryPort *discovery.Port
 		discoveryPort, err = port.GetPort(inst, sk)
 		if err != nil {
+			feedback.Errorf("Error during Upload: %v", err)
+			os.Exit(errorcodes.ErrGeneric)
+		}
+
+		userFieldRes, err := upload.SupportedUserFields(context.Background(), &rpc.SupportedUserFieldsRequest{
+			Instance: inst,
+			Fqbn:     fqbn,
+			Protocol: discoveryPort.Protocol,
+		})
+		if err != nil {
+			feedback.Errorf("Error during Upload: %v", err)
+			os.Exit(errorcodes.ErrGeneric)
+		}
 
+		fields := map[string]string{}
+		if len(userFieldRes.UserFields) > 0 {
+			feedback.Printf("Uploading to specified board using %s protocol requires the following info:", discoveryPort.Protocol)
+			fields = arguments.AskForUserFields(userFieldRes.UserFields)
 		}
 
 		uploadRequest := &rpc.UploadRequest{
@@ -211,8 +228,8 @@ func run(cmd *cobra.Command, args []string) {
 			Verify:     verify,
 			ImportDir:  buildPath,
 			Programmer: programmer,
+			UserFields: fields,
 		}
-		var err error
 		if output.OutputFormat == "json" {
 			// TODO: do not print upload output in json mode
 			uploadOut := new(bytes.Buffer)

cli/upload/upload.go

@@ -102,6 +102,22 @@ func run(command *cobra.Command, args []string) {
 		os.Exit(errorcodes.ErrGeneric)
 	}
 
+	userFieldRes, err := upload.SupportedUserFields(context.Background(), &rpc.SupportedUserFieldsRequest{
+		Instance: instance,
+		Fqbn:     fqbn,
+		Protocol: discoveryPort.Protocol,
+	})
+	if err != nil {
+		feedback.Errorf("Error during Upload: %v", err)
+		os.Exit(errorcodes.ErrGeneric)
+	}
+
+	fields := map[string]string{}
+	if len(userFieldRes.UserFields) > 0 {
+		feedback.Printf("Uploading to specified board using %s protocol requires the following info:", discoveryPort.Protocol)
+		fields = arguments.AskForUserFields(userFieldRes.UserFields)
+	}
+
 	if _, err := upload.Upload(context.Background(), &rpc.UploadRequest{
 		Instance:   instance,
 		Fqbn:       fqbn,
@@ -113,6 +129,7 @@ func run(command *cobra.Command, args []string) {
 		ImportDir:  importDir,
 		Programmer: programmer,
 		DryRun:     dryRun,
+		UserFields: fields,
 	}, os.Stdout, os.Stderr); err != nil {
 		feedback.Errorf(tr("Error during Upload: %v"), err)
 		os.Exit(errorcodes.ErrGeneric)

commands/upload/burnbootloader.go

@@ -48,6 +48,7 @@ func BurnBootloader(ctx context.Context, req *rpc.BurnBootloaderRequest, outStre
 		outStream,
 		errStream,
 		req.GetDryRun(),
+		map[string]string{}, // User fields
 	)
 	if err != nil {
 		return nil, err

commands/upload/upload.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"io"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/arduino/arduino-cli/arduino/cores"
@@ -39,6 +40,43 @@ import (
 
 var tr = i18n.Tr
 
+// SupportedUserFields returns a SupportedUserFieldsResponse containing all the UserFields supported
+// by the upload tools needed by the board using the protocol specified in SupportedUserFieldsRequest.
+func SupportedUserFields(ctx context.Context, req *rpc.SupportedUserFieldsRequest) (*rpc.SupportedUserFieldsResponse, error) {
+	if req.Protocol == "" {
+		return nil, fmt.Errorf("missing protocol")
+	}
+
+	pm := commands.GetPackageManager(req.GetInstance().GetId())
+	if pm == nil {
+		return nil, fmt.Errorf("invalid instance")
+	}
+
+	fqbn, err := cores.ParseFQBN(req.GetFqbn())
+	if err != nil {
+		return nil, fmt.Errorf("parsing fqbn: %s", err)
+	}
+
+	_, platformRelease, board, _, _, err := pm.ResolveFQBN(fqbn)
+	if err != nil {
+		return nil, fmt.Errorf("loading board data: %s", err)
+	}
+
+	toolId, err := getToolId(board.Properties, "upload", req.Protocol)
+	if err != nil {
+		return nil, err
+	}
+
+	userFields, err := getUserFields(toolId, platformRelease)
+	if err != nil {
+		return nil, err
+	}
+
+	return &rpc.SupportedUserFieldsResponse{
+		UserFields: userFields,
+	}, nil
+}
+
 // getToolId returns the ID of the tool that supports the action and protocol combination by searching in props.
 // Returns error if tool cannot be found.
 func getToolId(props *properties.Map, action, protocol string) (string, error) {
@@ -55,6 +93,35 @@ func getToolId(props *properties.Map, action, protocol string) (string, error) {
 	return "", fmt.Errorf("cannot find tool: undefined '%s' property", toolProperty)
 }
 
+// getUserFields return all user fields supported by the tools specified.
+// Returns error only in case the secret property is not a valid boolean.
+func getUserFields(toolId string, platformRelease *cores.PlatformRelease) ([]*rpc.UserField, error) {
+	userFields := []*rpc.UserField{}
+	fields := platformRelease.Properties.SubTree(fmt.Sprintf("tools.%s.upload.field", toolId))
+	keys := fields.FirstLevelKeys()
+
+	for _, key := range keys {
+		value := fields.Get(key)
+		secretProp := fmt.Sprintf("%s.secret", key)
+		secret, ok := fields.GetOk(secretProp)
+		if !ok {
+			secret = "false"
+		}
+		isSecret, err := strconv.ParseBool(secret)
+		if err != nil {
+			return nil, fmt.Errorf(`parsing "tools.%s.upload.field.%s.secret", property is not a boolean`, toolId, key)
+		}
+		userFields = append(userFields, &rpc.UserField{
+			ToolId: toolId,
+			Name:   key,
+			Label:  value,
+			Secret: isSecret,
+		})
+	}
+
+	return userFields, nil
+}
+
 // Upload FIXMEDOC
 func Upload(ctx context.Context, req *rpc.UploadRequest, outStream io.Writer, errStream io.Writer) (*rpc.UploadResponse, error) {
 	logrus.Tracef("Upload %s on %s started", req.GetSketchPath(), req.GetFqbn())
@@ -83,6 +150,7 @@ func Upload(ctx context.Context, req *rpc.UploadRequest, outStream io.Writer, er
 		outStream,
 		errStream,
 		req.GetDryRun(),
+		req.GetUserFields(),
 	)
 	if err != nil {
 		return nil, err
@@ -107,6 +175,7 @@ func UsingProgrammer(ctx context.Context, req *rpc.UploadUsingProgrammerRequest,
 		Programmer: req.GetProgrammer(),
 		Verbose:    req.GetVerbose(),
 		Verify:     req.GetVerify(),
+		UserFields: req.GetUserFields(),
 	}, outStream, errStream)
 	return &rpc.UploadUsingProgrammerResponse{}, err
 }
@@ -117,7 +186,7 @@ func runProgramAction(pm *packagemanager.PackageManager,
 	programmerID string,
 	verbose, verify, burnBootloader bool,
 	outStream, errStream io.Writer,
-	dryRun bool) error {
+	dryRun bool, userFields map[string]string) error {
 
 	if burnBootloader && programmerID == "" {
 		return fmt.Errorf(tr("no programmer specified for burning bootloader"))
@@ -231,6 +300,14 @@ func runProgramAction(pm *packagemanager.PackageManager,
 		}
 	}
 
+	// Certain tools require the user to provide custom fields at run time,
+	// if they've been provided set them
+	// For more info:
+	// https://github.com/arduino/tooling-rfcs/blob/main/RFCs/0002-pluggable-discovery.md#user-provided-fields
+	for name, value := range userFields {
+		uploadProperties.Set(fmt.Sprintf("%s.field.%s", action, name), value)
+	}
+
 	if !uploadProperties.ContainsKey("upload.protocol") && programmer == nil {
 		return fmt.Errorf(tr("a programmer is required to upload for this board"))
 	}
@@ -367,6 +444,11 @@ func runProgramAction(pm *packagemanager.PackageManager,
 		}
 	}
 
+	// Get Port properties gathered using Pluggable Discovery
+	for prop, value := range actualPort.Properties {
+		uploadProperties.Set(fmt.Sprintf("upload.port.properties.%s", prop), value)
+	}
+
 	// Run recipes for upload
 	if burnBootloader {
 		if err := runTool("erase.pattern", uploadProperties, outStream, errStream, verbose, dryRun); err != nil {

commands/upload/upload_test.go

@@ -266,3 +266,40 @@ upload.tool.network=arduino_ota`))
 	require.NoError(t, err)
 	require.Equal(t, "avrdude", toolId)
 }
+
+func TestGetUserFields(t *testing.T) {
+	platformRelease := &cores.PlatformRelease{}
+
+	props, err := properties.LoadFromBytes([]byte(`
+tools.avrdude.upload.field.username=Username
+tools.avrdude.upload.field.password=Password
+tools.avrdude.upload.field.password.secret=true
+tools.arduino_ota.upload.field.username=Username
+tools.arduino_ota.upload.field.password=Password
+tools.arduino_ota.upload.field.password.secret=true`))
+	require.NoError(t, err)
+
+	platformRelease.Properties = props
+
+	userFields, err := getUserFields("avrdude", platformRelease)
+	require.NoError(t, err)
+	require.Len(t, userFields, 2)
+	require.Equal(t, userFields[0].ToolId, "avrdude")
+	require.Equal(t, userFields[0].Name, "username")
+	require.Equal(t, userFields[0].Label, "Username")
+	require.False(t, userFields[0].Secret)
+	require.Equal(t, userFields[1].ToolId, "avrdude")
+	require.Equal(t, userFields[1].Name, "password")
+	require.Equal(t, userFields[1].Label, "Password")
+	require.True(t, userFields[1].Secret)
+
+	props, err = properties.LoadFromBytes([]byte(`
+tools.arduino_ota.upload.field.password=Password
+tools.arduino_ota.upload.field.password.secret=THIS_IS_NOT_A_BOOLEAN`))
+	require.NoError(t, err)
+	platformRelease.Properties = props
+
+	userFields, err = getUserFields("arduino_ota", platformRelease)
+	require.Nil(t, userFields)
+	require.EqualError(t, err, `parsing "tools.arduino_ota.upload.field.password.secret", property is not a boolean`)
+}