Add loading of PluggableDiscoveries when loading a platform release

Author: silvanocerza

arduino/cores/packagemanager/loader.go

@@ -588,3 +588,96 @@ func (pm *PackageManager) LoadToolsFromBundleDirectory(toolsPath *paths.Path) er
 	}
 	return nil
 }
+
+// LoadDiscoveries load all discoveries for all loaded platforms
+// Returns error if:
+// * A PluggableDiscovery instance can't be created
+// * Tools required by the PlatformRelease cannot be found
+// * Command line to start PluggableDiscovery has malformed or mismatched quotes
+func (pm *PackageManager) LoadDiscoveries() []*status.Status {
+	statuses := []*status.Status{}
+	for _, platform := range pm.InstalledPlatformReleases() {
+		statuses = append(statuses, pm.loadDiscoveries(platform)...)
+	}
+	return statuses
+}
+
+func (pm *PackageManager) loadDiscoveries(release *cores.PlatformRelease) []*status.Status {
+	statuses := []*status.Status{}
+	discoveryProperties := release.Properties.SubTree("discovery")
+
+	if discoveryProperties.Size() == 0 {
+		return nil
+	}
+
+	// Handles discovery properties formatted like so:
+	//
+	// Case 1:
+	//    "discovery.required": "PLATFORM:DISCOVERY_NAME",
+	//
+	// Case 2:
+	//    "discovery.required.0": "PLATFORM:DISCOVERY_ID_1",
+	//    "discovery.required.1": "PLATFORM:DISCOVERY_ID_2",
+	//
+	// If both indexed and unindexed properties are found the unindexed are ignored
+	for _, id := range discoveryProperties.ExtractSubIndexLists("required") {
+		tool := pm.GetTool(id)
+		if tool == nil {
+			statuses = append(statuses, status.Newf(codes.FailedPrecondition, "discovery not found: %s", id))
+			continue
+		}
+		toolRelease := tool.GetLatestInstalled()
+		discoveryPath := toolRelease.InstallDir.Join(tool.Name).String()
+		d, err := discovery.New(id, discoveryPath)
+		if err != nil {
+			statuses = append(statuses, status.Newf(codes.FailedPrecondition, "creating discovery: %s", err))
+			continue
+		}
+		pm.discoveryManager.Add(d)
+	}
+
+	discoveryIDs := discoveryProperties.FirstLevelOf()
+	delete(discoveryIDs, "required")
+	// Get the list of tools only we if have there are discoveries that use Direct discovery integration.
+	// See:
+	// https://github.com/arduino/tooling-rfcs/blob/main/RFCs/0002-pluggable-discovery.md#direct-discovery-integration-not-recommended
+	// We need the tools only in that case since we might need some tool's
+	// runtime properties to expand the discovery pattern to run it correctly.
+	var tools []*cores.ToolRelease
+	if len(discoveryIDs) > 0 {
+		var err error
+		tools, err = pm.FindToolsRequiredFromPlatformRelease(release)
+		if err != nil {
+			statuses = append(statuses, status.New(codes.Internal, err.Error()))
+		}
+	}
+
+	// Handles discovery properties formatted like so:
+	//
+	// discovery.DISCOVERY_ID.pattern: "COMMAND_TO_EXECUTE"
+	for discoveryID, props := range discoveryIDs {
+		pattern, ok := props.GetOk("pattern")
+		if !ok {
+			statuses = append(statuses, status.Newf(codes.FailedPrecondition, "can't find pattern for discovery with id %s", discoveryID))
+			continue
+		}
+		configuration := release.Properties.Clone()
+		configuration.Merge(release.RuntimeProperties())
+		configuration.Merge(props)
+
+		for _, tool := range tools {
+			configuration.Merge(tool.RuntimeProperties())
+		}
+
+		cmd := configuration.ExpandPropsInString(pattern)
+		if cmdArgs, err := properties.SplitQuotedString(cmd, `"'`, true); err != nil {
+			statuses = append(statuses, status.New(codes.Internal, err.Error()))
+		} else if d, err := discovery.New(discoveryID, cmdArgs...); err != nil {
+			statuses = append(statuses, status.New(codes.Internal, err.Error()))
+		} else {
+			pm.discoveryManager.Add(d)
+		}
+	}
+
+	return statuses
+}

arduino/cores/packagemanager/loader_test.go

@@ -18,8 +18,10 @@ package packagemanager
 import (
 	"testing"
 
+	"github.com/arduino/go-paths-helper"
 	"github.com/arduino/go-properties-orderedmap"
 	"github.com/stretchr/testify/require"
+	semver "go.bug.st/relaxed-semver"
 )
 
 func TestVidPidConvertionToPluggableDiscovery(t *testing.T) {
@@ -103,3 +105,73 @@ arduino_zero_native.pid.3=0x024d
   "upload_port.3.pid": "0x024d",
 }`, zero4.Dump())
 }
+
+func TestLoadDiscoveries(t *testing.T) {
+	// Create all the necessary data to load discoveries
+	fakePath := paths.New("fake-path")
+	packageManager := NewPackageManager(fakePath, fakePath, fakePath, fakePath)
+	pack := packageManager.Packages.GetOrCreatePackage("arduino")
+	// ble-discovery tool
+	tool := pack.GetOrCreateTool("arduino:ble-discovery")
+	toolRelease := tool.GetOrCreateRelease(semver.ParseRelaxed("1.0.0"))
+	// We set this to fake the tool is installed
+	toolRelease.InstallDir = fakePath
+	tool.GetOrCreateRelease(semver.ParseRelaxed("0.1.0"))
+
+	// serial-discovery tool
+	tool = pack.GetOrCreateTool("arduino:serial-discovery")
+	tool.GetOrCreateRelease(semver.ParseRelaxed("1.0.0"))
+	toolRelease = tool.GetOrCreateRelease(semver.ParseRelaxed("0.1.0"))
+	// We set this to fake the tool is installed
+	toolRelease.InstallDir = fakePath
+
+	platform := pack.GetOrCreatePlatform("avr")
+	release := platform.GetOrCreateRelease(semver.MustParse("1.0.0"))
+
+	release.Properties = properties.NewFromHashmap(map[string]string{
+		"discovery.required": "arduino:ble-discovery",
+	})
+
+	discoveries, err := packageManager.LoadDiscoveries(release)
+	require.Len(t, discoveries, 1)
+	require.NoError(t, err)
+	require.Equal(t, discoveries[0].GetID(), "arduino:ble-discovery")
+
+	release.Properties = properties.NewFromHashmap(map[string]string{
+		"discovery.required.0": "arduino:ble-discovery",
+		"discovery.required.1": "arduino:serial-discovery",
+	})
+
+	discoveries, err = packageManager.LoadDiscoveries(release)
+	require.Len(t, discoveries, 2)
+	require.NoError(t, err)
+	require.Equal(t, discoveries[0].GetID(), "arduino:ble-discovery")
+	require.Equal(t, discoveries[1].GetID(), "arduino:serial-discovery")
+
+	release.Properties = properties.NewFromHashmap(map[string]string{
+		"discovery.required.0":     "arduino:ble-discovery",
+		"discovery.required.1":     "arduino:serial-discovery",
+		"discovery.teensy.pattern": "\"{runtime.tools.teensy_ports.path}/hardware/tools/teensy_ports\" -J2",
+	})
+
+	discoveries, err = packageManager.LoadDiscoveries(release)
+	require.Len(t, discoveries, 3)
+	require.NoError(t, err)
+	require.Equal(t, discoveries[0].GetID(), "arduino:ble-discovery")
+	require.Equal(t, discoveries[1].GetID(), "arduino:serial-discovery")
+	require.Equal(t, discoveries[2].GetID(), "teensy")
+
+	release.Properties = properties.NewFromHashmap(map[string]string{
+		"discovery.required":       "arduino:some-discovery",
+		"discovery.required.0":     "arduino:ble-discovery",
+		"discovery.required.1":     "arduino:serial-discovery",
+		"discovery.teensy.pattern": "\"{runtime.tools.teensy_ports.path}/hardware/tools/teensy_ports\" -J2",
+	})
+
+	discoveries, err = packageManager.LoadDiscoveries(release)
+	require.Len(t, discoveries, 3)
+	require.NoError(t, err)
+	require.Equal(t, discoveries[0].GetID(), "arduino:ble-discovery")
+	require.Equal(t, discoveries[1].GetID(), "arduino:serial-discovery")
+	require.Equal(t, discoveries[2].GetID(), "teensy")
+}

arduino/cores/packagemanager/package_manager.go

@@ -439,6 +439,39 @@ func (pm *PackageManager) InstalledBoards() []*cores.Board {
 	return boards
 }
 
+func (pm *PackageManager) FindToolsRequiredFromPlatformRelease(platform *cores.PlatformRelease) ([]*cores.ToolRelease, error) {
+	pm.Log.Infof("Searching tools required for platform %s", platform)
+
+	// maps "PACKAGER:TOOL" => ToolRelease
+	foundTools := map[string]*cores.ToolRelease{}
+	// A Platform may not specify required tools (because it's a platform that comes from a
+	// user/hardware dir without a package_index.json) then add all available tools
+	for _, targetPackage := range pm.Packages {
+		for _, tool := range targetPackage.Tools {
+			rel := tool.GetLatestInstalled()
+			if rel != nil {
+				foundTools[rel.Tool.Name] = rel
+			}
+		}
+	}
+	// replace the default tools above with the specific required by the current platform
+	requiredTools := []*cores.ToolRelease{}
+	platform.ToolDependencies.Sort()
+	for _, toolDep := range platform.ToolDependencies {
+		pm.Log.WithField("tool", toolDep).Infof("Required tool")
+		tool := pm.FindToolDependency(toolDep)
+		if tool == nil {
+			return nil, fmt.Errorf("tool release not found: %s", toolDep)
+		}
+		requiredTools = append(requiredTools, tool)
+		delete(foundTools, tool.Tool.Name)
+	}
+	for _, toolRel := range foundTools {
+		requiredTools = append(requiredTools, toolRel)
+	}
+	return requiredTools, nil
+}
+
 // GetTool searches for tool in all packages and platforms.
 func (pm *PackageManager) GetTool(toolID string) *cores.Tool {
 	split := strings.Split(toolID, ":")