Merge branch 'daemon' of github.com:cmaglie/arduino-cli into HEAD

Author: Rocketct

cli/cli.go

@@ -20,6 +20,7 @@ package cli
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -84,17 +85,6 @@ var AppName = filepath.Base(os.Args[0])
 
 var Config *configs.Configuration
 
-// InitPackageAndLibraryManagerWithoutBundles initializes the PackageManager
-// and the LibraryManager but ignores bundles and user installed cores
-func InitPackageAndLibraryManagerWithoutBundles() (*packagemanager.PackageManager, *librariesmanager.LibrariesManager) {
-	logrus.Info("Package manager will scan only managed hardware folder")
-
-	fakeResult := false
-	Config.IDEBundledCheckResult = &fakeResult
-	Config.SketchbookDir = nil
-	return InitPackageAndLibraryManager()
-}
-
 func packageManagerInitReq() *rpc.InitReq {
 	urls := []string{}
 	for _, URL := range Config.BoardManagerAdditionalUrls {
@@ -112,41 +102,61 @@ func packageManagerInitReq() *rpc.InitReq {
 	return &rpc.InitReq{Configuration: conf}
 }
 
+func InitInstance(libManagerOnly bool) *rpc.InitResp {
+	if libManagerOnly {
+		logrus.Info("Initializing library manager")
+	} else {
+		logrus.Info("Initializing package manager")
+	}
+	req := packageManagerInitReq()
+	req.LibraryManagerOnly = libManagerOnly
+	resp, err := commands.Init(context.Background(), req)
+	if err != nil {
+		if libManagerOnly {
+			formatter.PrintError(err, "Error initializing library manager")
+		} else {
+			formatter.PrintError(err, "Error initializing package manager")
+		}
+		os.Exit(ErrGeneric)
+	}
+	return resp
+}
+
 // CreateInstance creates and return an instance of the Arduino Core engine
 func CreateInstance() *rpc.Instance {
-	logrus.Info("Initializing package manager")
-	resp, err := commands.Init(context.Background(), packageManagerInitReq())
-	if err != nil {
-		formatter.PrintError(err, "Error initializing package manager")
-		os.Exit(rpc.ErrGeneric)
+	resp := InitInstance(false)
+	if resp.GetPlatformsIndexErrors() != nil {
+		for _, err := range resp.GetPlatformsIndexErrors() {
+			formatter.PrintError(errors.New(err), "Error loading index")
+		}
+		formatter.PrintErrorMessage("Launch '" + AppName + " core update-index' to fix or download indexes.")
+		os.Exit(ErrGeneric)
 	}
 	return resp.GetInstance()
 }
 
 // InitPackageAndLibraryManager initializes the PackageManager and the LibaryManager
 // TODO: for the daemon mode, this might be called at startup, but for now only commands needing the PM will call it
 func InitPackageAndLibraryManager() (*packagemanager.PackageManager, *librariesmanager.LibrariesManager) {
-	logrus.Info("Initializing package manager")
-	resp, err := commands.Init(context.Background(), packageManagerInitReq())
-	if err != nil {
-		formatter.PrintError(err, "Error initializing package manager")
-		os.Exit(rpc.ErrGeneric)
-	}
+	resp := InitInstance(false)
 	return commands.GetPackageManager(resp), commands.GetLibraryManager(resp)
 }
 
+// InitPackageAndLibraryManagerWithoutBundles initializes the PackageManager
+// and the LibraryManager but ignores bundles and user installed cores
+func InitPackageAndLibraryManagerWithoutBundles() (*packagemanager.PackageManager, *librariesmanager.LibrariesManager) {
+	logrus.Info("Package manager will scan only managed hardware folder")
+
+	fakeResult := false
+	Config.IDEBundledCheckResult = &fakeResult
+	Config.SketchbookDir = nil
+	return InitPackageAndLibraryManager()
+}
+
 // InitLibraryManager initializes the LibraryManager. If pm is nil, the library manager will not handle core-libraries.
 // TODO: for the daemon mode, this might be called at startup, but for now only commands needing the PM will call it
 func InitLibraryManager(cfg *configs.Configuration) *librariesmanager.LibrariesManager {
-	req := packageManagerInitReq()
-	req.LibraryManagerOnly = true
-
-	logrus.Info("Initializing library manager")
-	resp, err := commands.Init(context.Background(), req)
-	if err != nil {
-		formatter.PrintError(err, "Error initializing library manager")
-		os.Exit(rpc.ErrGeneric)
-	}
+	resp := InitInstance(true)
 	return commands.GetLibraryManager(resp)
 }
 

cli/core/update_index.go

@@ -43,7 +43,7 @@ func initUpdateIndexCommand() *cobra.Command {
 }
 
 func runUpdateIndexCommand(cmd *cobra.Command, args []string) {
-	instance := cli.CreateInstance()
+	instance := cli.InitInstance(false).GetInstance()
 	logrus.Info("Executing `arduino core update-index`")
 
 	_, err := commands.UpdateIndex(context.Background(), &rpc.UpdateIndexReq{

commands/instances.go

@@ -95,9 +95,9 @@ func Init(ctx context.Context, req *rpc.InitReq) (*rpc.InitResp, error) {
 			return nil, fmt.Errorf("parsing url %s: %s", rawurl, err)
 		}
 	}
-	pm, lm, err := createInstance(ctx, config, req.GetLibraryManagerOnly())
+	pm, lm, reqPltIndex, reqLibIndex, err := createInstance(ctx, config, req.GetLibraryManagerOnly())
 	if err != nil {
-		return nil, fmt.Errorf("Impossible create instance")
+		return nil, fmt.Errorf("cannot initialize package manager: %s", err)
 	}
 	instance := &CoreInstance{
 		config:     config,
@@ -109,7 +109,9 @@ func Init(ctx context.Context, req *rpc.InitReq) (*rpc.InitResp, error) {
 	instances[handle] = instance
 
 	return &rpc.InitResp{
-		Instance: &rpc.Instance{Id: handle},
+		Instance:             &rpc.Instance{Id: handle},
+		PlatformsIndexErrors: reqPltIndex,
+		LibrariesIndexError:  reqLibIndex,
 	}, nil
 }
 
@@ -161,35 +163,34 @@ func UpdateIndex(ctx context.Context, req *rpc.UpdateIndexReq, downloadCB Downlo
 
 		tmpFile, err := ioutil.TempFile("", "")
 		if err != nil {
-			return nil, fmt.Errorf("Error creating temp file for download", err)
-
+			return nil, fmt.Errorf("creating temp file for download: %s", err)
 		}
 		if err := tmpFile.Close(); err != nil {
-			return nil, fmt.Errorf("Error creating temp file for download", err)
+			return nil, fmt.Errorf("creating temp file for download: %s", err)
 		}
 		tmp := paths.New(tmpFile.Name())
 		defer tmp.Remove()
 
 		d, err := downloader.Download(tmp.String(), URL.String())
 		if err != nil {
-			return nil, fmt.Errorf("Error downloading index "+URL.String(), err)
+			return nil, fmt.Errorf("downloading index %s: %s", URL, err)
 		}
 		coreIndexPath := indexpath.Join(path.Base(URL.Path))
 		Download(d, "Updating index: "+coreIndexPath.Base(), downloadCB)
 		if d.Error() != nil {
-			return nil, fmt.Errorf("Error downloading index "+URL.String(), d.Error())
+			return nil, fmt.Errorf("downloading index %s: %s", URL, d.Error())
 		}
 
 		if _, err := packageindex.LoadIndex(tmp); err != nil {
-			return nil, fmt.Errorf("Invalid package index in "+URL.String(), err)
+			return nil, fmt.Errorf("invalid package index in %s: %s", URL, err)
 		}
 
 		if err := indexpath.MkdirAll(); err != nil {
-			return nil, fmt.Errorf("Can't create data directory "+indexpath.String(), err)
+			return nil, fmt.Errorf("can't create data directory %s: %s", indexpath, err)
 		}
 
 		if err := tmp.CopyTo(coreIndexPath); err != nil {
-			return nil, fmt.Errorf("Error saving downloaded index "+URL.String(), err)
+			return nil, fmt.Errorf("saving downloaded index %s: %s", URL, err)
 		}
 	}
 	Rescan(ctx, &rpc.RescanReq{Instance: req.Instance})
@@ -203,17 +204,21 @@ func Rescan(ctx context.Context, req *rpc.RescanReq) (*rpc.RescanResp, error) {
 		return nil, fmt.Errorf("invalid handle")
 	}
 
-	pm, lm, err := createInstance(ctx, coreInstance.config, coreInstance.getLibOnly)
+	pm, lm, reqPltIndex, reqLibIndex, err := createInstance(ctx, coreInstance.config, coreInstance.getLibOnly)
 	if err != nil {
-		return nil, fmt.Errorf("rescanning: %s", err)
+		return nil, fmt.Errorf("rescanning filesystem: %s", err)
 	}
 	coreInstance.pm = pm
 	coreInstance.lm = lm
-	return &rpc.RescanResp{}, nil
+	return &rpc.RescanResp{
+		PlatformsIndexErrors: reqPltIndex,
+		LibrariesIndexError:  reqLibIndex,
+	}, nil
 }
 
-func createInstance(ctx context.Context, config *configs.Configuration, getLibOnly bool) (*packagemanager.PackageManager, *librariesmanager.LibrariesManager, error) {
+func createInstance(ctx context.Context, config *configs.Configuration, getLibOnly bool) (*packagemanager.PackageManager, *librariesmanager.LibrariesManager, []string, string, error) {
 	var pm *packagemanager.PackageManager
+	platformIndexErrors := []string{}
 	if !getLibOnly {
 		pm = packagemanager.NewPackageManager(
 			config.IndexesDir(),
@@ -223,14 +228,17 @@ func createInstance(ctx context.Context, config *configs.Configuration, getLibOn
 
 		for _, URL := range config.BoardManagerAdditionalUrls {
 			if err := pm.LoadPackageIndex(URL); err != nil {
-				return nil, nil, fmt.Errorf("loading "+URL.String()+" package index: %s", err)
+				platformIndexErrors = append(platformIndexErrors, err.Error())
 			}
 		}
 
 		if err := pm.LoadHardware(config); err != nil {
-			return nil, nil, fmt.Errorf("loading hardware packages: %s", err)
+			return nil, nil, nil, "", fmt.Errorf("loading hardware packages: %s", err)
 		}
 	}
+	if len(platformIndexErrors) == 0 {
+		platformIndexErrors = nil
+	}
 
 	// Initialize library manager
 	// --------------------------
@@ -258,20 +266,16 @@ func createInstance(ctx context.Context, config *configs.Configuration, getLibOn
 	}
 
 	// Load index and auto-update it if needed
+	librariesIndexError := ""
 	if err := lm.LoadIndex(); err != nil {
-		UpdateLibrariesIndex(ctx, lm, func(curr *rpc.DownloadProgress) {
-			fmt.Printf(">> %+v\n", curr)
-		})
-		if err := lm.LoadIndex(); err != nil {
-			return nil, nil, fmt.Errorf("loading libraries index: %s", err)
-		}
+		librariesIndexError = err.Error()
 	}
 
 	// Scan for libraries
 	if err := lm.RescanLibraries(); err != nil {
-		return nil, nil, fmt.Errorf("libraries rescan: %s", err)
+		return nil, nil, nil, "", fmt.Errorf("libraries rescan: %s", err)
 	}
-	return pm, lm, nil
+	return pm, lm, platformIndexErrors, librariesIndexError, nil
 }
 
 func Download(d *downloader.Downloader, label string, downloadCB DownloadProgressCB) error {