Implemented board watch with discoveries

Author: cmaglie

arduino/discovery/discoverymanager/discoverymanager.go

@@ -23,13 +23,15 @@ import (
 // DiscoveryManager is required to handle multiple pluggable-discovery that
 // may be shared across platforms
 type DiscoveryManager struct {
-	discoveries map[string]*discovery.PluggableDiscovery
+	discoveries   map[string]*discovery.PluggableDiscovery
+	globalEventCh chan *discovery.Event
 }
 
 // New creates a new DiscoveriesManager
 func New() *DiscoveryManager {
 	return &DiscoveryManager{
-		discoveries: map[string]*discovery.PluggableDiscovery{},
+		discoveries:   map[string]*discovery.PluggableDiscovery{},
+		globalEventCh: make(chan *discovery.Event, 5),
 	}
 }
 
@@ -65,6 +67,24 @@ func (dm *DiscoveryManager) StartAll() error {
 	return nil
 }
 
+// StartSyncAll the discoveries for this DiscoveryManager,
+// returns the first error it meets or nil
+func (dm *DiscoveryManager) StartSyncAll() (<-chan *discovery.Event, []error) {
+	errs := []error{}
+	for _, d := range dm.discoveries {
+		eventCh := d.EventChannel(5)
+		if err := d.StartSync(); err != nil {
+			errs = append(errs, err)
+		}
+		go func() {
+			for ev := range eventCh {
+				dm.globalEventCh <- ev
+			}
+		}()
+	}
+	return dm.globalEventCh, errs
+}
+
 // StopAll the discoveries for this DiscoveryManager,
 // returns the first error it meets or nil
 func (dm *DiscoveryManager) StopAll() error {

commands/board/list.go

@@ -227,40 +227,49 @@ func List(instanceID int32) (r []*rpc.DetectedPort, e error) {
 // The discovery process can be interrupted by sending a message to the interrupt channel.
 func Watch(instanceID int32, interrupt <-chan bool) (<-chan *rpc.BoardListWatchResponse, error) {
 	pm := commands.GetPackageManager(instanceID)
-	eventsChan, err := commands.WatchListBoards(pm)
-	if err != nil {
+
+	if err := pm.DiscoveryManager().RunAll(); err != nil {
 		return nil, err
 	}
 
+	eventsChan, errs := pm.DiscoveryManager().StartSyncAll()
+
 	outChan := make(chan *rpc.BoardListWatchResponse)
+
 	go func() {
+		for _, err := range errs {
+			outChan <- &rpc.BoardListWatchResponse{
+				EventType: "error",
+				Error:     err.Error(),
+			}
+		}
 		for {
 			select {
 			case event := <-eventsChan:
-				boards := []*rpc.BoardListItem{}
+				serialNumber := ""
+				if props := event.Port.Properties; props != nil {
+					serialNumber = props.Get("serialNumber")
+				}
+
+				port := &rpc.DetectedPort{
+					Address:       event.Port.Address,
+					Protocol:      event.Port.Protocol,
+					ProtocolLabel: event.Port.ProtocolLabel,
+					SerialNumber:  serialNumber,
+				}
+
 				boardsError := ""
 				if event.Type == "add" {
-					boards, err = identify(pm, event.Port)
+					boards, err := identify(pm, event.Port)
 					if err != nil {
 						boardsError = err.Error()
 					}
+					port.Boards = boards
 				}
-
-				serialNumber := ""
-				if props := event.Port.Properties; props != nil {
-					serialNumber = props.Get("serialNumber")
-				}
-
 				outChan <- &rpc.BoardListWatchResponse{
 					EventType: event.Type,
-					Port: &rpc.DetectedPort{
-						Address:       event.Port.Address,
-						Protocol:      event.Port.Protocol,
-						ProtocolLabel: event.Port.ProtocolLabel,
-						Boards:        boards,
-						SerialNumber:  serialNumber,
-					},
-					Error: boardsError,
+					Port:      port,
+					Error:     boardsError,
 				}
 			case <-interrupt:
 				return

commands/bundled_tools_serial_discovery.go

@@ -17,11 +17,9 @@ package commands
 
 import (
 	"fmt"
-	"sync"
 
 	"github.com/arduino/arduino-cli/arduino/cores"
 	"github.com/arduino/arduino-cli/arduino/cores/packagemanager"
-	"github.com/arduino/arduino-cli/arduino/discovery"
 	"github.com/arduino/arduino-cli/arduino/resources"
 	semver "go.bug.st/relaxed-semver"
 )
@@ -102,37 +100,6 @@ var (
 	}
 )
 
-// WatchListBoards returns a channel that receives events from the bundled discovery tool
-func WatchListBoards(pm *packagemanager.PackageManager) (<-chan *discovery.Event, error) {
-	t, err := getBuiltinSerialDiscoveryTool(pm)
-	if err != nil {
-		return nil, err
-	}
-
-	if !t.IsInstalled() {
-		return nil, fmt.Errorf("missing serial-discovery tool")
-	}
-
-	disc, err := discovery.New("serial-discovery", t.InstallDir.Join(t.Tool.Name).String())
-	if err != nil {
-		return nil, err
-	}
-
-	if err = disc.Run(); err != nil {
-		return nil, fmt.Errorf("starting discovery: %v", err)
-	}
-
-	if err = disc.Start(); err != nil {
-		return nil, fmt.Errorf("starting discovery: %v", err)
-	}
-
-	if err = disc.StartSync(); err != nil {
-		return nil, fmt.Errorf("starting sync: %v", err)
-	}
-
-	return disc.EventChannel(10), nil
-}
-
 func getBuiltinSerialDiscoveryTool(pm *packagemanager.PackageManager) *cores.ToolRelease {
 	builtinPackage := pm.Packages.GetOrCreatePackage("builtin")
 	serialDiscoveryTool := builtinPackage.GetOrCreateTool("serial-discovery")