Add device create command (#11)

This PR introduces a command to provision arduino devices. It must be executed on a computer with an arduino device connected via USB.
This command does everything needed to provision a device, including creating the device in Cloud, but also running the initial provisioning sketch that generates proper certificates to store in secure element.

When using this command, you can optionally explicit the port which the device is connected to and its fqbn. If they are not given, then the first device found is provisioned.
Usage:
$ iot-cloud-cli device create --name <deviceName> --port <port> --fqbn <deviceFqbn>


* Add local provisioning binaries

* Add device command

* Implement provisioning

Fix log format

Fix - add delay

Fix - use same flag as arduinocli

* Hack - don't check errstream from cli

Problem: Uploading the provisioning bin to a portenta
Description: even if the upload gets completed, the errstream from the rpc client of arduino-cli is not empty. It contains this: %!w(<nil>)
Temporary solution (hacky): don't check the errstream

* Split device create into cli and command

Fix

* Update readme

Author: Paolo Calao

README.md

@@ -1,6 +1,38 @@
 # iot-cloud-cli
 
-The iot-cloud-cli is a virtual device for Arduino IoT Cloud for testing.
+iot-cloud-cli is a command line interface that allows to exploit the features of Arduino IoT Cloud. As of now, it is possible to provision a device and to simulate a device to be connected to the cloud using MQTT for thoubleshooting purpose.
+
+### Requirements
+
+This is all you need to use iot-cloud-cli for device **provisioning**:
+ * A client ID and a secret ID, retrievable from the [cloud](https://create.arduino.cc/iot/integrations) by creating a new API key
+ * arduino-cli in daemon mode, use the command 'arduino-cli daemon'
+
+This is all you need to use iot-cloud-cli as a **virtual device**:
+ * A "Generic ESP8266 Module" or "Generic ESP32 Module" device in IoT Cloud (requires a Maker plan)
+ * A thing with a `counter` property connected to the "Generic ESP8266/ESP32 Module" device 
+
+
+## Set a configuration
+
+iot-cloud-cli should be configured before being used. In particular a client ID and the corresponding secret ID should be set.
+You can retrieve them from the [cloud](https://create.arduino.cc/iot/integrations) by creating a new API key.
+
+Once you have the IDs, call this command with your parameters:
+
+`$ iot-cloud-cli config -c <clientID> -s <secretID>`
+
+## Device provisioning
+
+When provisioning a device, you can optionally explicit the port which the device is connected to and its fqbn. If they are not given, then the first device found is provisioned.
+Use this command to provision a device:
+
+`$ iot-cloud-cli device create --name <deviceName> --port <port> --fqbn <deviceFqbn>`
+
+
+## Use iot-cloud-cli as a virtual device
+
+The iot-cloud-cli can be used as a virtual device for Arduino IoT Cloud for testing.
 
 ```
 $ iot-cloud-cli ping -u "<deviceId>" -p "<secret>" -t <thing ID>>
@@ -10,15 +42,9 @@ $ iot-cloud-cli ping -u "<deviceId>" -p "<secret>" -t <thing ID>>
   Property value sent successfully 87
 ```
 
-## Requirements
-
-This is all you need to use iot-cloud-cli:
- * A "Generic ESP8266 Module" device in IoT Cloud (requires a Maker plan)
- * A thing with a `counter` property connected to the "Generic ESP8266 Module" device 
-
-## How to set up the device and thing in IoT Cloud
+### How to set up the device and thing in IoT Cloud
 
-### Device
+#### Device
 
  * Visit https://create.arduino.cc/iot/devices and select "Add device".
  * Select "Set up a 3rd party device".
@@ -27,21 +53,21 @@ This is all you need to use iot-cloud-cli:
  * Pick a nice and friendly device name.
  * Save the "Device ID" and "Secret Key" is a safe place, because you will not be able to see them anymore.
 
-### Thing ID
+#### Thing ID
 
  * Visit https://create.arduino.cc/iot/things and select "Create Thing".
  * Select "Add Variable".
  * Give the variable the name "counter", type "Integer Number" and leave the variable permission the value "Read & Write".
  * Press the "Add Variable" button to confirm.
  * Copy the "Thing ID" from the bottom right of the page.
 
-### Connect the device and the thing
+#### Connect the device and the thing
 
 You should connect the new device to the new thing.
 
-### Testing
+#### Testing
 
-#### Connect to the PROD environment
+##### Connect to the PROD environment
 
 ```shell
 $ iot-cloud-cli ping -u "<Device ID>" -p "<Secret Key>" -t <Thing ID>>
@@ -57,7 +83,7 @@ Property value sent successfully 87
 
 If you visit https://create.arduino.cc/iot/devices the "Generic ESP8266 Module" device status should be "Online".
 
-#### Connect to the DEV environment
+##### Connect to the DEV environment
 
 The DEV environment is using a different broker, so you need to add the option `--host`:
 

arduino/grpc/compile.go

@@ -39,18 +39,14 @@ func (c compileHandler) UploadBin(fqbn, bin, port string) error {
 
 	// Wait for the upload to complete
 	for {
-		resp, err := stream.Recv()
+		_, err := stream.Recv()
 		if err != nil {
 			if err == io.EOF {
 				break
 			}
 			err = fmt.Errorf("%s: %w", "errors during upload", err)
 			return err
 		}
-		if resp.ErrStream != nil {
-			err = fmt.Errorf("%s: %w", "errors during upload", err)
-			return err
-		}
 	}
 
 	return nil

binaries/arduino.mbed_nano.nanorp2040connect.elf

@@ -0,0 +1,46 @@
+package device
+
+import (
+	"fmt"
+
+	"github.com/bcmi-labs/iot-cloud-cli/command/device"
+	"github.com/spf13/cobra"
+)
+
+var createFlags struct {
+	port string
+	name string
+	fqbn string
+}
+
+func initCreateCommand() *cobra.Command {
+	createCommand := &cobra.Command{
+		Use:   "create",
+		Short: "Create a device",
+		Long:  "Create a device for Arduino IoT Cloud",
+		RunE:  runCreateCommand,
+	}
+	createCommand.Flags().StringVarP(&createFlags.port, "port", "p", "", "Device port")
+	createCommand.Flags().StringVarP(&createFlags.name, "name", "n", "", "Device name")
+	createCommand.Flags().StringVarP(&createFlags.fqbn, "fqbn", "b", "", "Device fqbn")
+	createCommand.MarkFlagRequired("name")
+	return createCommand
+}
+
+func runCreateCommand(cmd *cobra.Command, args []string) error {
+	fmt.Printf("Creating device with name %s\n", createFlags.name)
+
+	params := &device.CreateParams{
+		Port: createFlags.port,
+		Name: createFlags.name,
+		Fqbn: createFlags.fqbn,
+	}
+
+	devID, err := device.Create(params)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("IoT Cloud device created with ID: %s\n", devID)
+	return nil
+}

binaries/arduino.mbed_portenta.envie_m7.bin

@@ -0,0 +1,17 @@
+package device
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func NewCommand() *cobra.Command {
+	deviceCommand := &cobra.Command{
+		Use:   "device",
+		Short: "Device commands.",
+		Long:  "Device commands.",
+	}
+
+	deviceCommand.AddCommand(initCreateCommand())
+
+	return deviceCommand
+}

binaries/arduino.samd.mkr1000.bin

@@ -5,6 +5,7 @@ import (
 	"os"
 
 	"github.com/bcmi-labs/iot-cloud-cli/cli/config"
+	"github.com/bcmi-labs/iot-cloud-cli/cli/device"
 	"github.com/bcmi-labs/iot-cloud-cli/cli/ping"
 	"github.com/spf13/cobra"
 )
@@ -13,6 +14,7 @@ func Execute() {
 	rootCmd := &cobra.Command{}
 	rootCmd.AddCommand(ping.NewCommand())
 	rootCmd.AddCommand(config.NewCommand())
+	rootCmd.AddCommand(device.NewCommand())
 
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Fprintln(os.Stderr, err)

binaries/arduino.samd.mkrgsm1400.bin

@@ -0,0 +1,127 @@
+package device
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
+	"github.com/bcmi-labs/iot-cloud-cli/arduino/grpc"
+	"github.com/bcmi-labs/iot-cloud-cli/internal/config"
+	"github.com/bcmi-labs/iot-cloud-cli/internal/iot"
+)
+
+// CreateParams contains the paramters needed
+// to find the device to be provisioned.
+// If Port is an empty string, then each serial port is analyzed.
+// If Fqbn is an empty string, then the first device found gets selected.
+type CreateParams struct {
+	Port string
+	Name string
+	Fqbn string
+}
+
+type device struct {
+	fqbn   string
+	serial string
+	dType  string
+	port   string
+}
+
+// Create command is used to provision a new arduino device
+// and to add it to the arduino iot cloud.
+func Create(params *CreateParams) (string, error) {
+	rpcComm, rpcClose, err := grpc.NewClient()
+	if err != nil {
+		return "", err
+	}
+	defer rpcClose()
+
+	ports, err := rpcComm.BoardList()
+	if err != nil {
+		return "", err
+	}
+	dev := deviceFromPorts(ports, params)
+	if dev == nil {
+		err = errors.New("no device found")
+		return "", err
+	}
+
+	conf, err := config.Retrieve()
+	if err != nil {
+		return "", err
+	}
+	iotClient, err := iot.NewClient(conf.Client, conf.Secret)
+	if err != nil {
+		return "", err
+	}
+
+	fmt.Println("Creating a new device on the cloud")
+	devID, err := iotClient.AddDevice(dev.fqbn, params.Name, dev.serial, dev.dType)
+	if err != nil {
+		return "", err
+	}
+
+	prov := &provision{
+		Commander: rpcComm,
+		Client:    iotClient,
+		dev:       dev,
+		id:        devID}
+	err = prov.run()
+	if err != nil {
+		// TODO: delete the device on iot cloud
+		err = fmt.Errorf("%s: %w", "cannot provision device", err)
+		return "", err
+	}
+
+	return devID, nil
+}
+
+// deviceFromPorts returns a board that matches all the criteria
+// passed in. If no criteria are passed, it returns the first device found.
+func deviceFromPorts(ports []*rpc.DetectedPort, params *CreateParams) *device {
+	for _, port := range ports {
+		if portFilter(port, params) {
+			continue
+		}
+		board := boardFilter(port.Boards, params)
+		if board != nil {
+			t := strings.Split(board.Fqbn, ":")[2]
+			dev := &device{board.Fqbn, port.SerialNumber, t, port.Address}
+			return dev
+		}
+	}
+
+	return nil
+}
+
+// portFilter filters out the given port if the port parameter is not an empty string
+// and if they do not match.
+// It returns:
+// true -> to skip the port
+// false -> to keep the port
+func portFilter(port *rpc.DetectedPort, params *CreateParams) bool {
+	if len(port.Boards) == 0 {
+		return true
+	}
+	if params.Port != "" && params.Port != port.Address {
+		return true
+	}
+	return false
+}
+
+// boardFilter looks for a board which has the same fqbn passed as parameter.
+// It returns:
+// - a board if it is found.
+// - nil if no board matching the fqbn parameter is found.
+func boardFilter(boards []*rpc.BoardListItem, params *CreateParams) (board *rpc.BoardListItem) {
+	if params.Fqbn == "" {
+		return boards[0]
+	}
+	for _, b := range boards {
+		if b.Fqbn == params.Fqbn {
+			return b
+		}
+	}
+	return
+}