// IsToolAvailableInPATH ...
func (toolkit BashToolkit) IsToolAvailableInPATH() bool {
binPath, err := utils.CheckProgramInstalledPath("bash")
if err != nil {
return false
}
return len(binPath) > 0
}
// IsToolAvailableInPATH ...
func (toolkit GoToolkit) IsToolAvailableInPATH() bool {
if configs.IsDebugUseSystemTools() {
log.Warn("[BitriseDebug] Using system tools (system installed Go), instead of the ones in BITRISE_HOME")
return true
}
if _, err := utils.CheckProgramInstalledPath("go"); err != nil {
return false
}
if _, err := cmdex.RunCommandAndReturnStdout("go", "version"); err != nil {
return false
}
return true
}
// Check ...
func (toolkit BashToolkit) Check() (bool, ToolkitCheckResult, error) {
binPath, err := utils.CheckProgramInstalledPath("bash")
if err != nil {
return false, ToolkitCheckResult{}, fmt.Errorf("Failed to get bash binary path, error: %s", err)
}
verOut, err := cmdex.RunCommandAndReturnStdout("bash", "--version")
if err != nil {
return false, ToolkitCheckResult{}, fmt.Errorf("Failed to check bash version, error: %s", err)
}
verStr := stringutil.ReadFirstLine(verOut, true)
return false, ToolkitCheckResult{
Path: binPath,
Version: verStr,
}, nil
}
func selectGoConfiguration() (bool, ToolkitCheckResult, GoConfigurationModel, error) {
potentialGoConfigurations := []GoConfigurationModel{}
// from PATH
{
binPath, err := utils.CheckProgramInstalledPath("go")
if err == nil {
potentialGoConfigurations = append(potentialGoConfigurations, GoConfigurationModel{GoBinaryPath: binPath})
}
}
// from Bitrise Toolkits
{
binPath := goBinaryInToolkitFullPath()
if isExist, err := pathutil.IsPathExists(binPath); err != nil {
log.Warnf("Failed to check the status of the 'go' binary inside the Bitrise Toolkit dir, error: %s", err)
} else if isExist {
potentialGoConfigurations = append(potentialGoConfigurations, GoConfigurationModel{
GoBinaryPath: binPath,
GOROOT: goToolkitInstallRootPath(),
})
}
}
isRequireInstall := true
checkResult := ToolkitCheckResult{}
goConfig := GoConfigurationModel{}
var checkError error
for _, aPotentialGoInfoToUse := range potentialGoConfigurations {
isInstReq, chkRes, err := checkGoConfiguration(aPotentialGoInfoToUse)
checkResult = chkRes
checkError = err
if !isInstReq {
// select this one
goConfig = aPotentialGoInfoToUse
isRequireInstall = false
break
}
}
if len(potentialGoConfigurations) > 0 && isRequireInstall {
log.Warnf("Installed go found (path: %s), but not a supported version: %s", checkResult.Path, checkResult.Version)
}
return isRequireInstall, checkResult, goConfig, checkError
}
// PrintInstalledXcodeInfos ...
func PrintInstalledXcodeInfos() error {
xcodeSelectPth, err := cmdex.RunCommandAndReturnStdout("xcode-select", "--print-path")
if err != nil {
xcodeSelectPth = "xcode-select --print-path failed to detect the location of activate Xcode Command Line Tools path"
}
progInstallPth, err := utils.CheckProgramInstalledPath("xcodebuild")
if err != nil {
return errors.New("xcodebuild is not installed")
}
isFullXcodeAvailable := false
verStr, err := cmdex.RunCommandAndReturnCombinedStdoutAndStderr("xcodebuild", "-version")
if err != nil {
// No full Xcode available, only the Command Line Tools
// verStr is something like "xcode-select: error: tool 'xcodebuild' requires Xcode, but active developer directory '/Library/Developer/CommandLineTools' is a command line tools instance"
isFullXcodeAvailable = false
} else {
// version OK - full Xcode available
// we'll just format it a bit to fit into one line
isFullXcodeAvailable = true
verStr = strings.Join(strings.Split(verStr, "\n"), " | ")
}
log.Infoln(" * "+colorstring.Green("[OK]")+" xcodebuild path :", progInstallPth)
if !isFullXcodeAvailable {
log.Infoln(" version (xcodebuild) :", colorstring.Yellowf("%s", verStr))
} else {
log.Infoln(" version (xcodebuild) :", verStr)
}
log.Infoln(" active Xcode (Command Line Tools) path (xcode-select --print-path) :", xcodeSelectPth)
if !isFullXcodeAvailable {
log.Warn(colorstring.Yellowf("%s", "No Xcode found, only the Xcode Command Line Tools are available!"))
log.Warn(colorstring.Yellowf("%s", "Full Xcode is required to build, test and archive iOS apps!"))
}
return nil
}
// CheckIsRubyGemsInstalled ...
func CheckIsRubyGemsInstalled() error {
officialSiteURL := "https://rubygems.org"
progInstallPth, err := utils.CheckProgramInstalledPath("gem")
if err != nil {
fmt.Println()
log.Warn("It seems that RubyGems is not installed on your system.")
log.Infoln("RubyGems is required in order to be able to auto-install all the bitrise dependencies.")
// log.Infoln("You should be able to install brew by copying this command and running it in your Terminal:")
// log.Infoln(brewRubyInstallCmdString)
log.Infoln("You can find more information about RubyGems on its official site at:", officialSiteURL)
log.Warn("Once the installation of RubyGems is finished you should call the bitrise setup again.")
return err
}
verStr, err := cmdex.RunCommandAndReturnStdout("gem", "--version")
if err != nil {
log.Infoln("")
return errors.New("Failed to get version")
}
log.Debugln(" * [OK] RubyGems :", progInstallPth)
log.Debugln(" version :", verStr)
return nil
}
// CheckIsHomebrewInstalled ...
func CheckIsHomebrewInstalled(isFullSetupMode bool) error {
brewRubyInstallCmdString := `$ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"`
officialSiteURL := "http://brew.sh/"
progInstallPth, err := utils.CheckProgramInstalledPath("brew")
if err != nil {
fmt.Println()
log.Warn("It seems that Homebrew is not installed on your system.")
log.Infoln("Homebrew (short: brew) is required in order to be able to auto-install all the bitrise dependencies.")
log.Infoln("You should be able to install brew by copying this command and running it in your Terminal:")
log.Infoln(brewRubyInstallCmdString)
log.Infoln("You can find more information about Homebrew on its official site at:", officialSiteURL)
log.Warn("Once the installation of brew is finished you should call the bitrise setup again.")
return err
}
verStr, err := cmdex.RunCommandAndReturnStdout("brew", "--version")
if err != nil {
log.Infoln("")
return errors.New("Failed to get version")
}
if isFullSetupMode {
// brew doctor
doctorOutput, err := cmdex.RunCommandAndReturnCombinedStdoutAndStderr("brew", "doctor")
if err != nil {
fmt.Println("")
log.Warn("brew doctor returned an error:")
log.Warnf("%s", doctorOutput)
return errors.New("Failed to: brew doctor")
}
}
log.Infoln(" * "+colorstring.Green("[OK]")+" Homebrew :", progInstallPth)
log.Infoln(" version :", verStr)
return nil
}
func checkIsBitriseToolInstalled(toolname, minVersion string, isInstall bool) error {
doInstall := func() error {
officialGithub := "https://github.com/bitrise-io/" + toolname
fmt.Println()
log.Warnln("No supported " + toolname + " version found.")
log.Infoln("You can find more information about "+toolname+" on its official GitHub page:", officialGithub)
// Install
fmt.Print("Installing...")
err := progress.SimpleProgressE(".", 2*time.Second, func() error {
return retry.Times(2).Wait(5 * time.Second).Try(func(attempt uint) error {
if attempt > 0 {
fmt.Println()
fmt.Print("==> Download failed, retrying ...")
}
return tools.InstallToolFromGitHub(toolname, "bitrise-io", minVersion)
})
})
fmt.Println()
if err != nil {
return err
}
// check again
return checkIsBitriseToolInstalled(toolname, minVersion, false)
}
// check whether installed
progInstallPth, err := utils.CheckProgramInstalledPath(toolname)
if err != nil {
if !isInstall {
return err
}
return doInstall()
}
verStr, err := cmdex.RunCommandAndReturnStdout(toolname, "-version")
if err != nil {
log.Infoln("")
return errors.New("Failed to get version")
}
// version check
isVersionOk, err := versions.IsVersionGreaterOrEqual(verStr, minVersion)
if err != nil {
log.Error("Failed to validate installed version")
return err
}
if !isVersionOk {
log.Warn("Installed "+toolname+" found, but not a supported version: ", verStr)
if !isInstall {
return errors.New("Failed to install required version.")
}
log.Warn("Updating...")
return doInstall()
}
log.Infoln(" * "+colorstring.Green("[OK]")+" "+toolname+" :", progInstallPth)
log.Infoln(" version :", verStr)
return nil
}
