// GetPluginPath ...
func GetPluginPath(name, pluginType string) (string, error) {
pluginsPath, err := GetPluginsDir()
if err != nil {
return "", err
}
pluginTypeDir := path.Join(pluginsPath, pluginType)
if err := pathutil.EnsureDirExist(pluginTypeDir); err != nil {
return "", err
}
return path.Join(pluginTypeDir, name), nil
}
// GetPluginsDir ...
func GetPluginsDir() (string, error) {
if err := bitrise.EnsureBitriseConfigDirExists(); err != nil {
log.Errorf("Failed to ensure bitrise configs dir, err: %s", err)
}
bitriseDir := bitrise.GetBitriseConfigsDirPath()
pluginsDir := path.Join(bitriseDir, "plugins")
if err := pathutil.EnsureDirExist(pluginsDir); err != nil {
return "", err
}
return pluginsDir, nil
}
// Install ...
func (toolkit GoToolkit) Install() error {
versionStr := minGoVersionForToolkit
osStr := runtime.GOOS
archStr := runtime.GOARCH
extentionStr := "tar.gz"
if osStr == "windows" {
extentionStr = "zip"
}
downloadURL := fmt.Sprintf("https://storage.googleapis.com/golang/go%s.%s-%s.%s",
versionStr, osStr, archStr, extentionStr)
log.Debugln("downloadURL: ", downloadURL)
goTmpDirPath := goToolkitTmpDirPath()
if err := pathutil.EnsureDirExist(goTmpDirPath); err != nil {
return fmt.Errorf("Failed to create Toolkits TMP directory, error: %s", err)
}
localFileName := "go." + extentionStr
goArchiveDownloadPath := filepath.Join(goTmpDirPath, localFileName)
var downloadErr error
fmt.Print("=> Downloading ...")
progress.SimpleProgress(".", 2*time.Second, func() {
downloadErr = retry.Times(2).Wait(5 * time.Second).Try(func(attempt uint) error {
if attempt > 0 {
fmt.Println()
fmt.Println("==> Download failed, retrying ...")
fmt.Println()
}
return tools.DownloadFile(downloadURL, goArchiveDownloadPath)
})
})
if downloadErr != nil {
return fmt.Errorf("Failed to download toolkit (%s), error: %s", downloadURL, downloadErr)
}
log.Debugln("Toolkit downloaded to: ", goArchiveDownloadPath)
fmt.Println("=> Installing ...")
if err := installGoTar(goArchiveDownloadPath); err != nil {
return fmt.Errorf("Failed to install Go toolkit, error: %s", err)
}
if err := os.Remove(goArchiveDownloadPath); err != nil {
return fmt.Errorf("Failed to remove the downloaded Go archive (path: %s), error: %s", goArchiveDownloadPath, err)
}
fmt.Println("=> Installing [DONE]")
return nil
}
func installGoTar(goTarGzPath string) error {
installToPath := goToolkitInstallToPath()
if err := os.RemoveAll(installToPath); err != nil {
return fmt.Errorf("Failed to remove previous Go toolkit install (path: %s), error: %s", installToPath, err)
}
if err := pathutil.EnsureDirExist(installToPath); err != nil {
return fmt.Errorf("Failed create Go toolkit directory (path: %s), error: %s", installToPath, err)
}
cmd := cmdex.NewCommand("tar", "-C", installToPath, "-xzf", goTarGzPath)
if combinedOut, err := cmd.RunAndReturnTrimmedCombinedOutput(); err != nil {
log.Errorln(" [!] Failed to uncompress Go toolkit, output:")
log.Errorln(combinedOut)
return fmt.Errorf("Failed to uncompress Go toolkit, error: %s", err)
}
return nil
}
// EnsureBitriseConfigDirExists ...
func EnsureBitriseConfigDirExists() error {
confDirPth := GetBitriseHomeDirPath()
return pathutil.EnsureDirExist(confDirPth)
}
// InitPaths ...
func InitPaths() error {
if err := initBitriseWorkPaths(); err != nil {
return fmt.Errorf("Failed to init bitrise paths, error: %s", err)
}
// --- Bitrise TOOLS
bitriseToolsDirPth := GetBitriseToolsDirPath()
if err := pathutil.EnsureDirExist(bitriseToolsDirPth); err != nil {
return err
}
pthWithBitriseTools := generatePATHEnvString(os.Getenv("PATH"), bitriseToolsDirPth)
if err := os.Setenv("PATH", pthWithBitriseTools); err != nil {
return fmt.Errorf("Failed to set PATH to include BITRISE_HOME/tools! Error: %s", err)
}
inputEnvstorePath, err := filepath.Abs(filepath.Join(BitriseWorkDirPath, "input_envstore.yml"))
if err != nil {
return fmt.Errorf("Failed to set input envstore path, error: %s", err)
}
InputEnvstorePath = inputEnvstorePath
outputEnvstorePath, err := filepath.Abs(filepath.Join(BitriseWorkDirPath, "output_envstore.yml"))
if err != nil {
return fmt.Errorf("Failed to set output envstore path, error: %s", err)
}
OutputEnvstorePath = outputEnvstorePath
formoutPath, err := filepath.Abs(filepath.Join(BitriseWorkDirPath, "formatted_output.md"))
if err != nil {
return fmt.Errorf("Failed to set formatted output path, error: %s", err)
}
FormattedOutputPath = formoutPath
currentDir, err := filepath.Abs("./")
if err != nil {
return fmt.Errorf("Failed to set current dir, error: %s", err)
}
CurrentDir = currentDir
// BITRISE_SOURCE_DIR
if os.Getenv(BitriseSourceDirEnvKey) == "" {
if err := os.Setenv(BitriseSourceDirEnvKey, currentDir); err != nil {
return fmt.Errorf("Failed to set BITRISE_SOURCE_DIR, error: %s", err)
}
}
// BITRISE_DEPLOY_DIR
if os.Getenv(BitriseDeployDirEnvKey) == "" {
deployDir, err := pathutil.NormalizedOSTempDirPath("deploy")
if err != nil {
return fmt.Errorf("Failed to set deploy dir, error: %s", err)
}
if err := os.Setenv(BitriseDeployDirEnvKey, deployDir); err != nil {
return fmt.Errorf("Failed to set BITRISE_DEPLOY_DIR, error: %s", err)
}
}
// BITRISE_CACHE_DIR
if os.Getenv(BitriseCacheDirEnvKey) == "" {
cacheDir, err := pathutil.NormalizedOSTempDirPath("cache")
if err != nil {
return fmt.Errorf("Failed to set cache dir, error: %s", err)
}
if err := os.Setenv(BitriseCacheDirEnvKey, cacheDir); err != nil {
return fmt.Errorf("Failed to set BITRISE_CACHE_DIR, error: %s", err)
}
}
return nil
}
