Made gRPC Init return a full Profile structure

Makes it more future-proof in case of further expasion

Author: cmaglie

cli/compile/compile.go

@@ -46,7 +46,7 @@ import (
 
 var (
 	fqbnArg                 arguments.Fqbn       // Fully Qualified Board Name, e.g.: arduino:avr:uno.
-	profile                 arguments.Profile    // Profile to use
+	profileArg              arguments.Profile    // Profile to use
 	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.
@@ -92,7 +92,7 @@ func NewCommand() *cobra.Command {
 	}
 
 	fqbnArg.AddToCommand(compileCommand)
-	profile.AddToCommand(compileCommand)
+	profileArg.AddToCommand(compileCommand)
 	compileCommand.Flags().BoolVar(&showProperties, "show-properties", false, tr("Show all build properties used instead of compiling."))
 	compileCommand.Flags().BoolVar(&preprocess, "preprocess", false, tr("Print preprocessed code to stdout instead of compiling."))
 	compileCommand.Flags().StringVar(&buildCachePath, "build-cache-path", "", tr("Builds of 'core.a' are saved into this path to be cached and reused."))
@@ -150,9 +150,9 @@ func runCompileCommand(cmd *cobra.Command, args []string) {
 	sketchPath := arguments.InitSketchPath(path)
 	sk := arguments.NewSketch(sketchPath)
 
-	inst, profileFqbn := instance.CreateAndInitWithProfile(profile.Get(), sketchPath)
+	inst, profile := instance.CreateAndInitWithProfile(profileArg.Get(), sketchPath)
 	if fqbnArg.String() == "" {
-		fqbnArg.Set(profileFqbn)
+		fqbnArg.Set(profile.GetFqbn())
 	}
 
 	fqbn, port := arguments.CalculateFQBNAndPort(&portArgs, &fqbnArg, inst, sk)

cli/instance/instance.go

@@ -41,17 +41,17 @@ func CreateAndInit() *rpc.Instance {
 	return inst
 }
 
-func CreateAndInitWithProfile(profile string, sketchPath *paths.Path) (*rpc.Instance, string) {
+func CreateAndInitWithProfile(profileName string, sketchPath *paths.Path) (*rpc.Instance, *rpc.Profile) {
 	instance, err := Create()
 	if err != nil {
 		feedback.Errorf(tr("Error creating instance: %v"), err)
 		os.Exit(errorcodes.ErrGeneric)
 	}
-	fqbn, errs := InitWithProfile(instance, profile, sketchPath)
+	profile, errs := InitWithProfile(instance, profileName, sketchPath)
 	for _, err := range errs {
 		feedback.Errorf(tr("Error initializing instance: %v"), err)
 	}
-	return instance, fqbn
+	return instance, profile
 }
 
 // Create and return a new Instance.
@@ -73,12 +73,12 @@ func Init(instance *rpc.Instance) []error {
 	return errs
 }
 
-func InitWithProfile(instance *rpc.Instance, profile string, sketchPath *paths.Path) (string, []error) {
+func InitWithProfile(instance *rpc.Instance, profileName string, sketchPath *paths.Path) (*rpc.Profile, []error) {
 	errs := []error{}
 
 	// In case the CLI is executed for the first time
 	if err := FirstUpdate(instance); err != nil {
-		return "", append(errs, err)
+		return nil, append(errs, err)
 	}
 
 	downloadCallback := output.ProgressBar()
@@ -87,9 +87,9 @@ func InitWithProfile(instance *rpc.Instance, profile string, sketchPath *paths.P
 	initReq := &rpc.InitRequest{Instance: instance}
 	if sketchPath != nil {
 		initReq.SketchPath = sketchPath.String()
-		initReq.Profile = profile
+		initReq.Profile = profileName
 	}
-	profileFqbn := ""
+	var profile *rpc.Profile
 	err := commands.Init(initReq, func(res *rpc.InitResponse) {
 		if st := res.GetError(); st != nil {
 			errs = append(errs, errors.New(st.Message))
@@ -104,15 +104,15 @@ func InitWithProfile(instance *rpc.Instance, profile string, sketchPath *paths.P
 			}
 		}
 
-		if fqbn := res.GetProfileSelectedFqbn(); fqbn != "" {
-			profileFqbn = fqbn
+		if p := res.GetProfile(); p != nil {
+			profile = p
 		}
 	})
 	if err != nil {
 		errs = append(errs, err)
 	}
 
-	return profileFqbn, errs
+	return profile, errs
 }
 
 // FirstUpdate downloads libraries and packages indexes if they don't exist.

cli/upload/upload.go

@@ -41,7 +41,7 @@ import (
 var (
 	fqbnArg    arguments.Fqbn
 	portArgs   arguments.Port
-	profile    arguments.Profile
+	profileArg arguments.Profile
 	verbose    bool
 	verify     bool
 	importDir  string
@@ -67,7 +67,7 @@ func NewCommand() *cobra.Command {
 
 	fqbnArg.AddToCommand(uploadCommand)
 	portArgs.AddToCommand(uploadCommand)
-	profile.AddToCommand(uploadCommand)
+	profileArg.AddToCommand(uploadCommand)
 	uploadCommand.Flags().StringVarP(&importDir, "input-dir", "", "", tr("Directory containing binaries to upload."))
 	uploadCommand.Flags().StringVarP(&importFile, "input-file", "i", "", tr("Binary file to upload."))
 	uploadCommand.Flags().BoolVarP(&verify, "verify", "t", false, tr("Verify uploaded binary after the upload."))
@@ -97,9 +97,9 @@ func runUploadCommand(command *cobra.Command, args []string) {
 		os.Exit(errorcodes.ErrGeneric)
 	}
 
-	instance, profileFqbn := instance.CreateAndInitWithProfile(profile.Get(), sketchPath)
+	instance, profile := instance.CreateAndInitWithProfile(profileArg.Get(), sketchPath)
 	if fqbnArg.String() == "" {
-		fqbnArg.Set(profileFqbn)
+		fqbnArg.Set(profile.GetFqbn())
 	}
 
 	fqbn, port := arguments.CalculateFQBNAndPort(&portArgs, &fqbnArg, instance, sk)

commands/instances.go

@@ -212,8 +212,12 @@ func Init(req *rpc.InitRequest, responseCallback func(r *rpc.InitResponse)) erro
 		}
 		profile = sk.GetProfile(req.GetProfile())
 		responseCallback(&rpc.InitResponse{
-			Message: &rpc.InitResponse_ProfileSelectedFqbn{
-				ProfileSelectedFqbn: profile.FQBN,
+			Message: &rpc.InitResponse_Profile{
+				Profile: &rpc.Profile{
+					Name: req.GetProfile(),
+					Fqbn: profile.FQBN,
+					// TODO: Other profile infos may be provided here...
+				},
 			},
 		})
 	}