Upload and Compile now accept both Alias and FQBN

Author: cmaglie

arduino/cores/packagemanager/package_manager.go

@@ -116,13 +116,20 @@ func (pm *PackageManager) FindBoardsWithID(id string) []*cores.Board {
 	return res
 }
 
-// FindBoardWithFQBN returns the board identified by the fqbn, or an error
-func (pm *PackageManager) FindBoardWithFQBN(fqbnIn string) (*cores.Board, error) {
-	fqbn, err := cores.ParseFQBN(fqbnIn)
+// FindBoard search the board identified by boardArg (board alias or board fqbn).
+// It returns FQBN, RegistereBoard and Board or an error if not found.
+// The board may be present in registry but not installed, in this case o
+func (pm *PackageManager) FindBoard(boardArg string) (*cores.FQBN, *RegisteredBoard, *cores.Board, error) {
+	fqbn, registeredBoard, err := pm.Registry.FindBoard(boardArg)
 	if err != nil {
-		return nil, fmt.Errorf("parsing fqbn: %s", err)
+		return fqbn, registeredBoard, nil, err
 	}
+	board, err := pm.FindBoardWithFQBN(fqbn)
+	return fqbn, registeredBoard, board, err
+}
 
+// FindBoardWithFQBN returns the board identified by the fqbn, or an error
+func (pm *PackageManager) FindBoardWithFQBN(fqbn *cores.FQBN) (*cores.Board, error) {
 	_, _, board, _, _, err := pm.ResolveFQBN(fqbn)
 	return board, err
 }

arduino/cores/packagemanager/package_manager_test.go

@@ -41,12 +41,12 @@ func TestFindBoardWithFQBN(t *testing.T) {
 	pm := packagemanager.NewPackageManager(customHardware, customHardware, customHardware, customHardware)
 	pm.LoadHardwareFromDirectory(customHardware)
 
-	board, err := pm.FindBoardWithFQBN("arduino:avr:uno")
+	_, _, board, err := pm.FindBoard("arduino:avr:uno")
 	require.Nil(t, err)
 	require.NotNil(t, board)
 	require.Equal(t, board.Name(), "Arduino/Genuino Uno")
 
-	board, err = pm.FindBoardWithFQBN("arduino:avr:mega")
+	_, _, board, err = pm.FindBoard("arduino:avr:mega")
 	require.Nil(t, err)
 	require.NotNil(t, board)
 	require.Equal(t, board.Name(), "Arduino/Genuino Mega or Mega 2560")
@@ -178,7 +178,7 @@ func TestBoardOptionsFunctions(t *testing.T) {
 	pm := packagemanager.NewPackageManager(customHardware, customHardware, customHardware, customHardware)
 	pm.LoadHardwareFromDirectory(customHardware)
 
-	nano, err := pm.FindBoardWithFQBN("arduino:avr:nano")
+	_, _, nano, err := pm.FindBoard("arduino:avr:nano")
 	require.Nil(t, err)
 	require.NotNil(t, nano)
 	require.Equal(t, nano.Name(), "Arduino Nano")
@@ -194,7 +194,7 @@ func TestBoardOptionsFunctions(t *testing.T) {
 	expectedNanoCPUValues.Set("atmega168", "ATmega168")
 	require.EqualValues(t, expectedNanoCPUValues, nanoCPUValues)
 
-	esp8266, err := pm.FindBoardWithFQBN("esp8266:esp8266:generic")
+	_, _, esp8266, err := pm.FindBoard("esp8266:esp8266:generic")
 	require.Nil(t, err)
 	require.NotNil(t, esp8266)
 	require.Equal(t, esp8266.Name(), "Generic ESP8266 Module")
@@ -230,7 +230,7 @@ func TestFindToolsRequiredForBoard(t *testing.T) {
 	loadIndex("http://arduino.esp8266.com/stable/package_esp8266com_index.json")
 	loadIndex("https://adafruit.github.io/arduino-board-index/package_adafruit_index.json")
 	require.NoError(t, pm.LoadHardware())
-	esp32, err := pm.FindBoardWithFQBN("esp32:esp32:esp32")
+	_, _, esp32, err := pm.FindBoard("esp32:esp32:esp32")
 	require.NoError(t, err)
 	esptool231 := pm.FindToolDependency(&cores.ToolDependency{
 		ToolPackager: "esp32",
@@ -266,7 +266,7 @@ func TestFindToolsRequiredForBoard(t *testing.T) {
 	testConflictingToolsInDifferentPackages()
 	testConflictingToolsInDifferentPackages()
 
-	feather, err := pm.FindBoardWithFQBN("adafruit:samd:adafruit_feather_m0_express")
+	_, _, feather, err := pm.FindBoard("adafruit:samd:adafruit_feather_m0_express")
 	require.NoError(t, err)
 	require.NotNil(t, feather)
 	featherTools, err := pm.FindToolsRequiredForBoard(feather)

arduino/cores/packagemanager/registry.go

@@ -50,14 +50,18 @@ func (r *BoardsRegistry) addBoard(board *RegisteredBoard) {
 	r.aliastToBoard[board.Alias] = board
 }
 
-func (r *BoardsRegistry) FindBoard(fqbnOrAlias string) *RegisteredBoard {
+func (r *BoardsRegistry) FindBoard(fqbnOrAlias string) (*cores.FQBN, *RegisteredBoard, error) {
 	if found, ok := r.aliastToBoard[fqbnOrAlias]; ok {
-		return found
+		return found.FQBN, found, nil
 	}
-	if found, ok := r.fqbnToBoard[fqbnOrAlias]; ok {
-		return found
+	fqbn, err := cores.ParseFQBN(fqbnOrAlias)
+	if err != nil {
+		return nil, nil, err
 	}
-	return nil
+	if found, ok := r.fqbnToBoard[fqbn.StringWithoutConfig()]; ok {
+		return fqbn, found, nil
+	}
+	return fqbn, nil, nil
 }
 
 func (r *BoardsRegistry) SearchBoards(query string) []*RegisteredBoard {

cli/compile/compile.go

@@ -33,7 +33,7 @@ import (
 )
 
 var (
-	fqbn               string   // Fully Qualified Board Name, e.g.: arduino:avr:uno.
+	boardArg           string   // Board Alias or Board FQBN
 	showProperties     bool     // Show all build preferences used instead of compiling.
 	preprocess         bool     // Print preprocessed code to stdout.
 	buildCachePath     string   // Builds of 'core.a' are saved into this path to be cached and reused.
@@ -63,7 +63,9 @@ func NewCommand() *cobra.Command {
 		Run:     run,
 	}
 
-	command.Flags().StringVarP(&fqbn, "fqbn", "b", "", "Fully Qualified Board Name, e.g.: arduino:avr:uno")
+	command.Flags().StringVarP(&boardArg, "board", "b", "", "Board Alias or Board FQBN (e.g. 'arduino:avr:uno')")
+	command.Flags().StringVarP(&boardArg, "fqbn", "", "", "")
+	command.Flags().MarkDeprecated("fqbn", "use --board instead.")
 	command.Flags().BoolVar(&showProperties, "show-properties", false, "Show all build properties used instead of compiling.")
 	command.Flags().BoolVar(&preprocess, "preprocess", false, "Print preprocessed code to stdout instead of compiling.")
 	command.Flags().StringVar(&buildCachePath, "build-cache-path", "", "Builds of 'core.a' are saved into this path to be cached and reused.")
@@ -104,7 +106,7 @@ func run(cmd *cobra.Command, args []string) {
 
 	_, err = compile.Compile(context.Background(), &rpc.CompileReq{
 		Instance:         inst,
-		Fqbn:             fqbn,
+		Board:            boardArg,
 		SketchPath:       sketchPath.String(),
 		ShowProperties:   showProperties,
 		Preprocess:       preprocess,
@@ -129,7 +131,7 @@ func run(cmd *cobra.Command, args []string) {
 	if uploadAfterCompile {
 		_, err := upload.Upload(context.Background(), &rpc.UploadReq{
 			Instance:   inst,
-			Fqbn:       fqbn,
+			Board:      boardArg,
 			SketchPath: sketchPath.String(),
 			Port:       port,
 			Verbose:    verbose,

cli/upload/upload.go

@@ -30,7 +30,7 @@ import (
 )
 
 var (
-	fqbn       string
+	boardArg   string
 	port       string
 	verbose    bool
 	verify     bool
@@ -48,7 +48,9 @@ func NewCommand() *cobra.Command {
 		Run:     run,
 	}
 
-	uploadCommand.Flags().StringVarP(&fqbn, "fqbn", "b", "", "Fully Qualified Board Name, e.g.: arduino:avr:uno")
+	uploadCommand.Flags().StringVarP(&boardArg, "board", "b", "", "Fully Qualified Board Name, e.g.: arduino:avr:uno")
+	uploadCommand.Flags().StringVarP(&boardArg, "fqbn", "", "", "")
+	uploadCommand.Flags().MarkDeprecated("fqbn", "use --board instead.")
 	uploadCommand.Flags().StringVarP(&port, "port", "p", "", "Upload port, e.g.: COM10 or /dev/ttyACM0")
 	uploadCommand.Flags().StringVarP(&importFile, "input", "i", "", "Input file to be uploaded.")
 	uploadCommand.Flags().BoolVarP(&verify, "verify", "t", false, "Verify uploaded binary after the upload.")
@@ -72,7 +74,7 @@ func run(command *cobra.Command, args []string) {
 
 	if _, err := upload.Upload(context.Background(), &rpc.UploadReq{
 		Instance:   instance,
-		Fqbn:       fqbn,
+		Board:      boardArg,
 		SketchPath: sketchPath.String(),
 		Port:       port,
 		Verbose:    verbose,

commands/board/install.go

@@ -33,15 +33,15 @@ func Install(ctx context.Context, req *rpc.BoardInstallReq,
 		return nil, errors.New("invalid instance")
 	}
 
-	board := pm.Registry.FindBoard(req.GetBoard())
-	if board == nil {
-		return nil, errors.Errorf("board '%s' not found", req.GetBoard())
+	fqbn, _, _, err := pm.FindBoard(req.GetBoard())
+	if err != nil {
+		return nil, errors.Errorf("board '%s' not found: %s", req.GetBoard(), err)
 	}
 
 	platformInstallReq := &rpc.PlatformInstallReq{
 		Instance:        req.GetInstance(),
-		PlatformPackage: board.FQBN.Package,
-		Architecture:    board.FQBN.PlatformArch,
+		PlatformPackage: fqbn.Package,
+		Architecture:    fqbn.PlatformArch,
 	}
 	if _, err := core.PlatformInstall(ctx, platformInstallReq, downloadCB, taskCB); err != nil {
 		return nil, errors.WithMessage(err, "installing board platforms")

commands/compile/compile.go

@@ -17,15 +17,13 @@ package compile
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
 
-	"github.com/arduino/arduino-cli/arduino/cores"
 	"github.com/arduino/arduino-cli/arduino/cores/packagemanager"
 	"github.com/arduino/arduino-cli/arduino/sketches"
 	"github.com/arduino/arduino-cli/commands"
@@ -37,6 +35,7 @@ import (
 	"github.com/arduino/arduino-cli/telemetry"
 	paths "github.com/arduino/go-paths-helper"
 	properties "github.com/arduino/go-properties-orderedmap"
+	"github.com/pkg/errors"
 	"github.com/segmentio/stats/v4"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
@@ -46,6 +45,7 @@ import (
 func Compile(ctx context.Context, req *rpc.CompileReq, outStream, errStream io.Writer, debug bool) (r *rpc.CompileResp, e error) {
 
 	tags := map[string]string{
+		"board":           req.Board,
 		"fqbn":            req.Fqbn,
 		"sketchPath":      telemetry.Sanitize(req.SketchPath),
 		"showProperties":  strconv.FormatBool(req.ShowProperties),
@@ -85,16 +85,20 @@ func Compile(ctx context.Context, req *rpc.CompileReq, outStream, errStream io.W
 		return nil, fmt.Errorf("opening sketch: %s", err)
 	}
 
-	fqbnIn := req.GetFqbn()
-	if fqbnIn == "" && sketch != nil && sketch.Metadata != nil {
-		fqbnIn = sketch.Metadata.CPU.Fqbn
+	boardArg := req.GetBoard()
+	if boardArg == "" {
+		boardArg = req.GetFqbn() // DEPRECATED: Keep Fqbn field working for old clients.
 	}
-	if fqbnIn == "" {
-		return nil, fmt.Errorf("no FQBN provided")
+	if boardArg == "" && sketch != nil && sketch.Metadata != nil {
+		boardArg = sketch.Metadata.CPU.Fqbn
 	}
-	fqbn, err := cores.ParseFQBN(fqbnIn)
+	if boardArg == "" {
+		return nil, errors.Errorf("no board provided")
+	}
+
+	fqbn, _, _, err := pm.FindBoard(boardArg)
 	if err != nil {
-		return nil, fmt.Errorf("incorrect FQBN: %s", err)
+		return nil, errors.Errorf("board '%s' not found: %s", req.GetBoard(), err)
 	}
 
 	targetPlatform := pm.FindPlatform(&packagemanager.PlatformReference{
@@ -249,6 +253,6 @@ func Compile(ctx context.Context, req *rpc.CompileReq, outStream, errStream io.W
 		}
 	}
 
-	logrus.Tracef("Compile %s for %s successful", sketch.Name, fqbnIn)
+	logrus.Tracef("Compile %s for %s successful", sketch.Name, boardArg)
 	return &rpc.CompileResp{}, nil
 }

commands/upload/upload.go

@@ -33,6 +33,7 @@ import (
 	rpc "github.com/arduino/arduino-cli/rpc/commands"
 	paths "github.com/arduino/go-paths-helper"
 	properties "github.com/arduino/go-properties-orderedmap"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"go.bug.st/serial"
 )
@@ -67,19 +68,22 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
 		return nil, fmt.Errorf("no upload port provided")
 	}
 
-	fqbnIn := req.GetFqbn()
-	if fqbnIn == "" && sketch != nil && sketch.Metadata != nil {
-		fqbnIn = sketch.Metadata.CPU.Fqbn
+	boardArg := req.GetBoard()
+	if boardArg == "" {
+		boardArg = req.GetFqbn() // DEPRECATION: Keep compatiblity with old clients using Fqbn
 	}
-	if fqbnIn == "" {
-		return nil, fmt.Errorf("no Fully Qualified Board Name provided")
+	if boardArg == "" && sketch != nil && sketch.Metadata != nil {
+		boardArg = sketch.Metadata.CPU.Fqbn
 	}
-	fqbn, err := cores.ParseFQBN(fqbnIn)
-	if err != nil {
-		return nil, fmt.Errorf("incorrect FQBN: %s", err)
+	if boardArg == "" {
+		return nil, errors.Errorf("no board specified")
 	}
 
 	pm := commands.GetPackageManager(req.GetInstance().GetId())
+	fqbn, _, _, err := pm.FindBoard(boardArg)
+	if err != nil {
+		return nil, errors.Errorf("board '%s' not found: %s", req.GetBoard(), err)
+	}
 
 	// Find target board and board properties
 	_, _, board, boardProperties, _, err := pm.ResolveFQBN(fqbn)
@@ -266,7 +270,7 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
 		return nil, fmt.Errorf("uploading error: %s", err)
 	}
 
-	logrus.Tracef("Upload %s on %s successful", sketch.Name, fqbnIn)
+	logrus.Tracef("Upload %s on %s successful", sketch.Name, boardArg)
 
 	return &rpc.UploadResp{}, nil
 }