install.go

// This file is part of arduino-cli.
//
// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
//
// This software is released under the GNU General Public License version 3,
// which covers the main part of arduino-cli.
// The terms of this license can be found at:
// https://www.gnu.org/licenses/gpl-3.0.en.html
//
// You can be released from the requirements of the above licenses by purchasing
// a commercial license. Buying such a license is mandatory if you want to
// modify or otherwise use the software for commercial activities involving the
// Arduino software without disclosing the source code of your own applications.
// To purchase a commercial license, send an email to license@arduino.cc.

package lib

import (
"context"
"errors"
"fmt"

"github.com/arduino/arduino-cli/arduino"
"github.com/arduino/arduino-cli/arduino/libraries"
"github.com/arduino/arduino-cli/arduino/libraries/librariesindex"
"github.com/arduino/arduino-cli/arduino/libraries/librariesmanager"
"github.com/arduino/arduino-cli/commands"
 rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
"github.com/arduino/go-paths-helper"
"github.com/sirupsen/logrus"
)

// LibraryInstall resolves the library dependencies, then downloads and installs the libraries into the install location.
funcLibraryInstall(ctx context.Context, req*rpc.LibraryInstallRequest, downloadCB rpc.DownloadProgressCB, taskCB rpc.TaskProgressCB) error {
lm:=commands.GetLibraryManager(req)
iflm==nil {
return&arduino.InvalidInstanceError{}
 }

toInstall:=map[string]*rpc.LibraryDependencyStatus{}
installLocation:=libraries.FromRPCLibraryInstallLocation(req.GetInstallLocation())
ifreq.NoDeps {
toInstall[req.Name] =&rpc.LibraryDependencyStatus{
Name: req.Name,
VersionRequired: req.Version,
 }
 } else {
res, err:=LibraryResolveDependencies(ctx, &rpc.LibraryResolveDependenciesRequest{
Instance: req.Instance,
Name: req.Name,
Version: req.Version,
 })
iferr!=nil {
returnerr
 }

for_, dep:=rangeres.Dependencies {
ifexistingDep, has:=toInstall[dep.Name]; has {
ifexistingDep.VersionRequired!=dep.VersionRequired {
err:=errors.New(
tr("two different versions of the library %[1]s are required: %[2]s and %[3]s",
dep.Name, dep.VersionRequired, existingDep.VersionRequired))
return&arduino.LibraryDependenciesResolutionFailedError{Cause: err}
 }
 }
toInstall[dep.Name] =dep
 }
 }

// Find the libReleasesToInstall to install
libReleasesToInstall:=map[*librariesindex.Release]*librariesmanager.LibraryInstallPlan{}
for_, lib:=rangetoInstall {
libRelease, err:=findLibraryIndexRelease(lm, &rpc.LibraryInstallRequest{
Name: lib.Name,
Version: lib.VersionRequired,
 })
iferr!=nil {
returnerr
 }

installTask, err:=lm.InstallPrerequisiteCheck(libRelease.Library.Name, libRelease.Version, installLocation)
iferr!=nil {
returnerr
 }
ifinstallTask.UpToDate {
taskCB(&rpc.TaskProgress{Message: tr("Already installed %s", libRelease), Completed: true})
continue
 }

ifreq.GetNoOverwrite() {
ifinstallTask.ReplacedLib!=nil {
returnfmt.Errorf(tr("Library %[1]s is already installed, but with a different version: %[2]s", libRelease, installTask.ReplacedLib))
 }
 }
libReleasesToInstall[libRelease] =installTask
 }

forlibRelease, installTask:=rangelibReleasesToInstall {
// Checks if libRelease is the requested library and not a dependency
downloadReason:="depends"
iflibRelease.GetName() ==req.Name {
downloadReason="install"
ifinstallTask.ReplacedLib!=nil {
downloadReason="upgrade"
 }
ifinstallLocation==libraries.IDEBuiltIn {
downloadReason+="-builtin"
 }
 }
iferr:=downloadLibrary(lm, libRelease, downloadCB, taskCB, downloadReason); err!=nil {
returnerr
 }
iferr:=installLibrary(lm, libRelease, installTask, taskCB); err!=nil {
returnerr
 }
 }

iferr:=commands.Init(&rpc.InitRequest{Instance: req.Instance}, nil); err!=nil {
returnerr
 }

returnnil
}

funcinstallLibrary(lm*librariesmanager.LibrariesManager, libRelease*librariesindex.Release, installTask*librariesmanager.LibraryInstallPlan, taskCB rpc.TaskProgressCB) error {
taskCB(&rpc.TaskProgress{Name: tr("Installing %s", libRelease)})
logrus.WithField("library", libRelease).Info("Installing library")

iflibReplaced:=installTask.ReplacedLib; libReplaced!=nil {
taskCB(&rpc.TaskProgress{Message: tr("Replacing %[1]s with %[2]s", libReplaced, libRelease)})
iferr:=lm.Uninstall(libReplaced); err!=nil {
return&arduino.FailedLibraryInstallError{
Cause: fmt.Errorf("%s: %s", tr("could not remove old library"), err)}
 }
 }
iferr:=lm.Install(libRelease, installTask.TargetPath); err!=nil {
return&arduino.FailedLibraryInstallError{Cause: err}
 }

taskCB(&rpc.TaskProgress{Message: tr("Installed %s", libRelease), Completed: true})
returnnil
}

// ZipLibraryInstall FIXMEDOC
funcZipLibraryInstall(ctx context.Context, req*rpc.ZipLibraryInstallRequest, taskCB rpc.TaskProgressCB) error {
lm:=commands.GetLibraryManager(req)
iferr:=lm.InstallZipLib(ctx, paths.New(req.Path), req.Overwrite); err!=nil {
return&arduino.FailedLibraryInstallError{Cause: err}
 }
taskCB(&rpc.TaskProgress{Message: tr("Library installed"), Completed: true})
returnnil
}

// GitLibraryInstall FIXMEDOC
funcGitLibraryInstall(ctx context.Context, req*rpc.GitLibraryInstallRequest, taskCB rpc.TaskProgressCB) error {
lm:=commands.GetLibraryManager(req)
iferr:=lm.InstallGitLib(req.Url, req.Overwrite); err!=nil {
return&arduino.FailedLibraryInstallError{Cause: err}
 }
taskCB(&rpc.TaskProgress{Message: tr("Library installed"), Completed: true})
returnnil
}