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

Diff for: README.md

@@ -1,32 +1,92 @@
-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.
+# iot-cloud-cli
+
+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
- * The folder containing the precompiled provisioning firmwares (`binaries`) needs to be in the same location you run the command from
+ * 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 needs to be configured before being used. In particular a client ID and the corresponding secret ID should be set.
+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>`
 
-A file named `config.yaml` will be created in the Current Working Directory containing the login credentials.
-Example
+## 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.
 
-```yaml
-client: 00112233445566778899aabbccddeeff
-secret: 00112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100
+```
+$ iot-cloud-cli ping -u "<deviceId>" -p "<secret>" -t <thing ID>>
+  Connected to Arduino IoT Cloud
+  Subscribed true
+  Property value sent successfully 81
+  Property value sent successfully 87
 ```
 
-## Device provisioning
+### How to set up the device and thing in IoT Cloud
 
-When provisioning a device, you can optionally specify the port to which the device is connected to and its fqbn. If they are not given, then the first device found will be provisioned.
+#### Device
 
-Use this command to provision a device:
+ * Visit https://create.arduino.cc/iot/devices and select "Add device".
+ * Select "Set up a 3rd party device".
+ * Select "ESP8266". 
+ * From the drop down select "Generic ESP8266 Module", and click "Continue".
+ * 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
 
-`$ iot-cloud-cli device create --name <deviceName> --port <port> --fqbn <deviceFqbn>`
+ * 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
+
+You should connect the new device to the new thing.
+
+#### Testing
+
+##### Connect to the PROD environment
+
+```shell
+$ iot-cloud-cli ping -u "<Device ID>" -p "<Secret Key>" -t <Thing ID>>
+```
+
+If every works as expected you should see something similar to this output:
+```
+Connected to Arduino IoT Cloud
+Subscribed true
+Property value sent successfully 81
+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
+
+The DEV environment is using a different broker, so you need to add the option `--host`:
+
+```shell
+$ iot-cloud-cli ping --host tcps://mqtts-sa.iot.oniudra.cc:8884 -u "<Device ID>" -p "<Secret Key>" -t "<thing-id>"
+```

Diff for: 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

Diff for: 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
+}

Diff for: 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
+}

Diff for: binaries/arduino.samd.mkr1000.bin

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

Diff for: 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
+}