not working draft of core install

Author: saniales

cmd/arduino_core.go

@@ -204,12 +204,43 @@ func executeCoreInstallCommand(cmd *cobra.Command, args []string) error {
 	}
 
 	IDTuples := cores.ParseArgs(args)
-	coresToDownload, failOutputs := status.Process(IDTuples)
+	coresToDownload, toolsToDownload, failOutputs := status.Process(IDTuples)
 	outputResults := output.CoreProcessResults{
 		Cores: failOutputs,
 	}
+
+	releases.ParallelDownload(toolsToDownload, false, "Installed", GlobalFlags.Verbose, &outputResults.Tools, "tool")
+	// while downloading the cores, install the tools.
+	go func() {
+		for i, item := range toolsToDownload {
+			err = cores.InstallTool(item.Name, item.Release)
+			if err != nil {
+				outputResults.Tools[i] = output.ProcessResult{
+					ItemName: item.Name,
+					Status:   "",
+					Error:    err.Error(),
+				}
+			}
+		}
+	}()
 	releases.ParallelDownload(coresToDownload, false, "Installed", GlobalFlags.Verbose, &outputResults.Cores, "core")
-	// TODO : install
+
+	root, err := common.GetDefaultPkgFolder()
+	if err != nil {
+		formatter.PrintErrorMessage("Cannot get core install path, try again.")
+		return nil
+	}
+
+	for i, item := range coresToDownload {
+		err = cores.Install(item.Name, item.Release)
+		if err != nil {
+			outputResults.Cores[i] = output.ProcessResult{
+				ItemName: item.Name,
+				Status:   "",
+				Error:    err.Error(),
+			}
+		}
+	}
 	return nil
 }
 

cmd/arduino_lib.go

@@ -199,14 +199,21 @@ func executeInstallCommand(cmd *cobra.Command, args []string) error {
 	}
 	releases.ParallelDownload(libsToDownload, false, "Installed", GlobalFlags.Verbose, &outputResults.Libraries, "library")
 
+	folder, err := common.GetDefaultLibFolder()
+	if err != nil {
+		formatter.PrintErrorMessage("Cannot get default lib install path, try again.")
+		return nil
+	}
+
 	for i, item := range libsToDownload {
-		err = libraries.InstallLib(item.Name, item.Release)
+		err = libraries.Install(item.Name, item.Release)
 		if err != nil {
 			outputResults.Libraries[i] = output.ProcessResult{
 				ItemName: item.Name,
-				Status:   "",
-				Error:    err.Error(),
+				Error:    err.Error()
 			}
+		} else {
+			outputResults.Libraries[i].Path
 		}
 	}
 

common/releases/helpers.go

@@ -45,12 +45,12 @@ import (
 
 // IsCached returns a bool representing if the release has already been downloaded
 func IsCached(release Release) bool {
-	stagingFolder, err := release.GetDownloadCacheFolder()
+	archivePath, err := ArchivePath(release)
 	if err != nil {
 		return false
 	}
 
-	_, err = os.Stat(filepath.Join(stagingFolder, release.ArchiveName()))
+	_, err = os.Stat(archivePath)
 	return !os.IsNotExist(err)
 }
 

common/releases/interfaces.go

@@ -41,4 +41,6 @@ type Release interface {
 	ArchiveSize() int64
 	// GetDownloadCacheFolder returns the path of the staging folders for this release.
 	GetDownloadCacheFolder() (string, error)
+	// VersionName represents the version of the release.
+	VersionName() string
 }

cores/cores.go

@@ -172,3 +172,8 @@ func (release Release) ArchiveURL() string {
 func (release Release) GetDownloadCacheFolder() (string, error) {
 	return common.GetDownloadCacheFolder("packages")
 }
+
+// VersionName represents the version of the release.
+func (release Release) VersionName() string {
+	return release.Version
+}

cores/install_uninstall.go

@@ -0,0 +1,92 @@
+package cores
+
+import (
+	"archive/zip"
+	"errors"
+	"io/ioutil"
+	"os"
+
+	"github.com/bcmi-labs/arduino-cli/common"
+	"github.com/bcmi-labs/arduino-cli/common/releases"
+	"github.com/codeclysm/extract"
+)
+
+// Install installs a specific release of a core.
+func Install(packager, name string, release releases.Release) error {
+	if release == nil {
+		return errors.New("Not existing version of the core")
+	}
+
+	coresFolder, err := common.GetDefaultCoresFolder(packager)
+	if err != nil {
+		return err
+	}
+
+	cacheFilePath, err := releases.ArchivePath(release)
+	if err != nil {
+		return err
+	}
+
+	tempFolder, err := ioutil.TempDir("cores", name)
+	if err != nil {
+		return err
+	}
+
+	file, err := os.Open(cacheFilePath)
+	if err != nil {
+		return err
+	}
+
+	extract.Archive(file, tempFolder, nil)
+
+	purgeTempDir()
+	moveTempDir()
+
+	return nil
+}
+
+// Install installs a library.
+func Install(name string, release releases.Release) error {
+	if release == nil {
+		return errors.New("Not existing version of the library")
+	}
+
+	/*
+		installedRelease, err := library.InstalledRelease()
+		if err != nil {
+			return err
+		}
+		if installedRelease != nil {
+			//if installedRelease.Version != library.Latest().Version {
+			err := removeRelease(library.Name, installedRelease)
+			if err != nil {
+				return err
+			}
+			//} else {
+			//	return nil // Already installed and latest version.
+			//}
+		}
+	*/
+	libFolder, err := common.GetDefaultLibFolder()
+	if err != nil {
+		return err
+	}
+
+	cacheFilePath, err := release.ArchivePath()
+	if err != nil {
+		return err
+	}
+
+	zipArchive, err := zip.OpenReader(cacheFilePath)
+	if err != nil {
+		return err
+	}
+	defer zipArchive.Close()
+
+	err = common.Unzip(zipArchive, libFolder)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

cores/status.go

@@ -139,9 +139,10 @@ func (sc StatusContext) GetDeps(release *Release) ([]CoreDependency, error) {
 // Process takes a set of ID tuples and returns
 // a set of items to download and a set of outputs for non
 // existing cores.
-func (sc StatusContext) Process(items []CoreIDTuple) ([]releases.DownloadItem, []output.ProcessResult) {
+func (sc StatusContext) Process(items []CoreIDTuple) ([]releases.DownloadItem, []releases.DownloadItem, []output.ProcessResult) {
 	itemC := len(items)
-	ret := make([]releases.DownloadItem, 0, itemC)
+	retCores := make([]releases.DownloadItem, 0, itemC)
+	retTools := make([]releases.DownloadItem, 0, itemC)
 	fails := make([]output.ProcessResult, 0, itemC)
 
 	// value is not used, this map is only to check if an item is inside (set implementation)
@@ -192,12 +193,12 @@ func (sc StatusContext) Process(items []CoreIDTuple) ([]releases.DownloadItem, [
 		if err != nil {
 			fails = append(fails, output.ProcessResult{
 				ItemName: item.CoreName,
-				Error:    fmt.Sprintf("Tool %s not found", err.Error()),
+				Error:    fmt.Sprintf("Cannot get tool dependencies of %s core: %s", core.Name, err.Error()),
 			})
 			continue
 		}
 
-		ret = append(ret, releases.DownloadItem{
+		ret = append(retCores, releases.DownloadItem{
 			Name:    core.Name,
 			Release: release,
 		})
@@ -210,11 +211,11 @@ func (sc StatusContext) Process(items []CoreIDTuple) ([]releases.DownloadItem, [
 			}
 
 			presenceMap[tool.ToolName] = true
-			ret = append(ret, releases.DownloadItem{
+			retTools = append(retTools, releases.DownloadItem{
 				Name:    tool.ToolName,
 				Release: tool.Release,
 			})
 		}
 	}
-	return ret, fails
+	return retCores, retTools, fails
 }

cores/tools.go

@@ -202,3 +202,8 @@ func (tr ToolRelease) ArchiveSize() int64 {
 func (tr ToolRelease) GetDownloadCacheFolder() (string, error) {
 	return common.GetDownloadCacheFolder("packages")
 }
+
+// VersionName represents the version of the release.
+func (tr ToolRelease) VersionName() string {
+	return tr.Version
+}

libraries/install_uninstall.go

@@ -45,8 +45,8 @@ import (
 // Uninstall a library means remove its directory.
 var Uninstall = os.RemoveAll
 
-// InstallLib installs a library.
-func InstallLib(name string, release releases.Release) error {
+// Install installs a library.
+func Install(name string, release releases.Release) error {
 	if release == nil {
 		return errors.New("Not existing version of the library")
 	}
@@ -72,13 +72,11 @@ func InstallLib(name string, release releases.Release) error {
 		return err
 	}
 
-	stagingFolder, err := release.GetDownloadCacheFolder()
+	cacheFilePath, err := releases.ArchivePath(release)
 	if err != nil {
 		return err
 	}
 
-	cacheFilePath := filepath.Join(stagingFolder, release.ArchiveName())
-
 	zipArchive, err := zip.OpenReader(cacheFilePath)
 	if err != nil {
 		return err

libraries/libraries.go

@@ -223,3 +223,8 @@ func (r Release) ExpectedChecksum() string {
 func (r Release) GetDownloadCacheFolder() (string, error) {
 	return common.GetDownloadCacheFolder("libraries")
 }
+
+// VersionName represents the version of the release.
+func (r Release) VersionName() string {
+	return r.Version
+}