func runGradleTask(gradleTool, buildFile, tasks, options string) error {
optionSlice, err := shellquote.Split(options)
if err != nil {
return err
}
taskSlice, err := shellquote.Split(tasks)
if err != nil {
return err
}
cmdSlice := []string{gradleTool, "--build-file", buildFile}
cmdSlice = append(cmdSlice, taskSlice...)
cmdSlice = append(cmdSlice, optionSlice...)
log.Done("$ %s", cmdex.PrintableCommandArgs(false, cmdSlice))
fmt.Println()
cmd, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return fmt.Errorf("failed to create command, error: %s", err)
}
cmd.SetStdout(os.Stdout)
cmd.SetStderr(os.Stderr)
return cmd.Run()
}
// Submit ...
func (testCloud Model) Submit(callback CaptureLineCallback) error {
cmdSlice := testCloud.submitCommandSlice()
command, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return err
}
cmd := *command.GetCmd()
// Redirect output
stdoutReader, err := cmd.StdoutPipe()
if err != nil {
return err
}
scanner := bufio.NewScanner(stdoutReader)
go func() {
for scanner.Scan() {
line := scanner.Text()
if callback != nil {
callback(line)
}
}
}()
if err := scanner.Err(); err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
return cmd.Wait()
}
func cmdExist(cmdSlice []string) bool {
if len(cmdSlice) == 0 {
return false
}
cmd, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return false
}
return (cmd.Run() == nil)
}
// Run ...
func (nunitConsole Model) Run() error {
cmdSlice := nunitConsole.commandSlice()
command, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return err
}
command.SetStdout(os.Stdout)
command.SetStderr(os.Stderr)
return command.Run()
}
// Run ...
func (xbuild Model) Run() error {
cmdSlice := xbuild.buildCommandSlice()
command, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return err
}
command.SetStdout(os.Stdout)
command.SetStderr(os.Stderr)
return command.Run()
}
// Command ...
func (command RubyCommandModel) Command(useBundle bool, cmdSlice []string) (*cmdex.CommandModel, error) {
if useBundle {
cmdSlice = append([]string{"bundle", "exec"}, cmdSlice...)
}
if command.sudoNeeded(cmdSlice) {
cmdSlice = append([]string{"sudo"}, cmdSlice...)
}
cmd, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return nil, err
}
return cmd, nil
}
// Run ...
func (mdtool Model) Run() error {
cmdSlice := mdtool.buildCommandSlice()
command, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return err
}
/*
command.SetStdout(os.Stdout)
command.SetStderr(os.Stderr)
return command.Run()
*/
return runCommandInDiagnosticMode(*command, "Loading projects", diagnosticModeWaitTime, diagnosticModeForceWaitTime, true)
}
// RunBuildCommand ...
func (xamarinCmd CommandModel) RunBuildCommand() (string, error) {
mdtoolPth := "/Applications/Xamarin Studio.app/Contents/MacOS/mdtool"
cmdArgs := []string{mdtoolPth, "build",
xamarinCmd.SolutionFilePath,
fmt.Sprintf("-c:%s", xamarinCmd.ConfigurationName),
fmt.Sprintf("-p:%s", xamarinCmd.ProjectName),
}
log.Infof("$ %s", cmdex.PrintableCommandArgs(true, cmdArgs))
fmt.Print("Running and analyzing log ...")
cmd, err := cmdex.NewCommandFromSlice(cmdArgs)
if err != nil {
return "", fmt.Errorf("Failed to create Xamarin command, error: %s", err)
}
xamarinBuildOutput, err := cmd.RunAndReturnTrimmedCombinedOutput()
if err != nil {
return xamarinBuildOutput, fmt.Errorf("Failed to run Xamarin command, error: %s", err)
}
log.Debugf("xamarinBuildOutput: %s", xamarinBuildOutput)
return xamarinBuildOutput, nil
}
func runCommandInDirWithEnvsAndOutput(cmdSlice []string, dir string, envs []string) (string, string, error) {
cmd, err := cmdex.NewCommandFromSlice(cmdSlice)
if err != nil {
return "", "", err
}
if len(envs) > 0 {
cmd.SetEnvs(envs)
}
if dir != "" {
cmd.SetDir(dir)
}
log.Details("=> %s", cmdex.PrintableCommandArgs(false, cmdSlice))
var errBuffer bytes.Buffer
errWriter := bufio.NewWriter(&errBuffer)
cmd.SetStderr(errWriter)
var outBuffer bytes.Buffer
outWriter := bufio.NewWriter(&outBuffer)
cmd.SetStdout(outWriter)
if err := cmd.Run(); err != nil {
if errorutil.IsExitStatusError(err) {
if !errorutil.IsExitStatusErrorStr(errBuffer.String()) {
return "", "", errors.New(errBuffer.String())
}
if !errorutil.IsExitStatusErrorStr(outBuffer.String()) {
return "", "", errors.New(outBuffer.String())
}
}
return "", "", err
}
return outBuffer.String(), errBuffer.String(), nil
}
func main() {
configs := createConfigsModelFromEnvs()
fmt.Println()
configs.print()
if err := configs.validate(); err != nil {
log.Error("Issue with input: %s", err)
os.Exit(1)
}
nugetPth := "/Library/Frameworks/Mono.framework/Versions/Current/bin/nuget"
nugetRestoreCmdArgs := []string{nugetPth}
if configs.NugetVersion == "latest" {
fmt.Println()
log.Info("Updating Nuget to latest version...")
// "sudo $nuget update -self"
cmdArgs := []string{"sudo", nugetPth, "update", "-self"}
cmd, err := cmdex.NewCommandFromSlice(cmdArgs)
if err != nil {
log.Error("Failed to create command from args (%v), error: %s", cmdArgs, err)
os.Exit(1)
}
cmd.SetStdout(os.Stdout)
cmd.SetStderr(os.Stderr)
log.Done("$ %s", cmdex.PrintableCommandArgs(false, cmdArgs))
if err := cmd.Run(); err != nil {
log.Error("Failed to update nuget, error: %s", err)
os.Exit(1)
}
} else if configs.NugetVersion != "" {
fmt.Println()
log.Info("Downloading Nuget %s version...", configs.NugetVersion)
tmpDir, err := pathutil.NormalizedOSTempDirPath("__nuget__")
if err != nil {
log.Error("Failed to create tmp dir, error: %s", err)
os.Exit(1)
}
downloadPth := filepath.Join(tmpDir, "nuget.exe")
// https://dist.nuget.org/win-x86-commandline/v3.3.0/nuget.exe
nugetURL := fmt.Sprintf("https://dist.nuget.org/win-x86-commandline/v%s/nuget.exe", configs.NugetVersion)
log.Detail("Download URL: %s", nugetURL)
if err := DownloadFile(nugetURL, downloadPth); err != nil {
log.Warn("Download failed, error: %s", err)
// https://dist.nuget.org/win-x86-commandline/v3.4.4/NuGet.exe
nugetURL = fmt.Sprintf("https://dist.nuget.org/win-x86-commandline/v%s/NuGet.exe", configs.NugetVersion)
log.Detail("Retry download URl: %s", nugetURL)
if err := DownloadFile(nugetURL, downloadPth); err != nil {
log.Error("Failed to download nuget, error: %s", err)
os.Exit(1)
}
}
nugetRestoreCmdArgs = []string{constants.MonoPath, downloadPth}
}
fmt.Println()
log.Info("Restoring Nuget packages...")
nugetRestoreCmdArgs = append(nugetRestoreCmdArgs, "restore", configs.XamarinSolution)
if err := retry.Times(1).Try(func(attempt uint) error {
if attempt > 0 {
log.Warn("Attempt %d failed, retrying...", attempt)
}
log.Done("$ %s", cmdex.PrintableCommandArgs(false, nugetRestoreCmdArgs))
cmd, err := cmdex.NewCommandFromSlice(nugetRestoreCmdArgs)
if err != nil {
log.Error("Failed to create Nuget command, error: %s", err)
os.Exit(1)
}
cmd.SetStdout(os.Stdout)
cmd.SetStderr(os.Stderr)
if err := cmd.Run(); err != nil {
log.Error("Restore failed, error: %s", err)
return err
}
return nil
}); err != nil {
log.Error("Nuget restore failed, error: %s", err)
os.Exit(1)
}
}
func main() {
configs := createConfigsModelFromEnvs()
fmt.Println()
configs.print()
if err := configs.validate(); err != nil {
registerFail("Issue with input: %s", err)
}
//
// Determining calabash-android version
fmt.Println()
log.Info("Determining calabash-android version...")
rubyCommand, err := rubycmd.NewRubyCommandModel()
if err != nil {
registerFail("Failed to create ruby command, err: %s", err)
}
calabashAndroidVersion := ""
useBundler := false
if configs.GemFilePath != "" {
if exist, err := pathutil.IsPathExists(configs.GemFilePath); err != nil {
registerFail("Failed to check if Gemfile exists at (%s) exist, error: %s", configs.GemFilePath, err)
} else if exist {
log.Detail("Gemfile exists at: %s", configs.GemFilePath)
gemfileDir := filepath.Dir(configs.GemFilePath)
gemfileLockPth := filepath.Join(gemfileDir, "Gemfile.lock")
if exist, err := pathutil.IsPathExists(gemfileLockPth); err != nil {
registerFail("Failed to check if Gemfile.lock exists at (%s), error: %s", gemfileLockPth, err)
} else if exist {
log.Detail("Gemfile.lock exists at: %s", gemfileLockPth)
version, err := calabashAndroidVersionFromGemfileLock(gemfileLockPth)
if err != nil {
registerFail("Failed to get calabash-android version from Gemfile.lock, error: %s", err)
}
log.Detail("calabash-android version in Gemfile.lock: %s", version)
calabashAndroidVersion = version
useBundler = true
} else {
log.Warn("Gemfile.lock doest no find with calabash-android gem at: %s", gemfileLockPth)
}
} else {
log.Warn("Gemfile doest no find with calabash-android gem at: %s", configs.GemFilePath)
}
}
if configs.CalabashAndroidVersion != "" {
log.Detail("calabash-android version in configs: %s", configs.CalabashAndroidVersion)
calabashAndroidVersion = configs.CalabashAndroidVersion
useBundler = false
}
if calabashAndroidVersion == "" {
log.Done("using calabash-android latest version")
} else {
log.Done("using calabash-android version: %s", calabashAndroidVersion)
}
// ---
//
// Intsalling calabash-android gem
fmt.Println()
log.Info("Installing calabash-android gem...")
calabashAndroidArgs := []string{}
// If Gemfile given with calabash-android and calabash_android_version input does not override calabash-android version
// Run `bundle install`
// Run calabash-android with `bundle exec`
if useBundler {
bundleInstallArgs := []string{"bundle", "install", "--jobs", "20", "--retry", "5"}
// bundle install
bundleInstallCmd, err := rubyCommand.Command(false, bundleInstallArgs)
if err != nil {
registerFail("Failed to create command, error: %s", err)
}
bundleInstallCmd.AppendEnvs([]string{"BUNDLE_GEMFILE=" + configs.GemFilePath})
log.Detail("$ %s", cmdex.PrintableCommandArgs(false, bundleInstallArgs))
if err := bundleInstallCmd.Run(); err != nil {
registerFail("bundle install failed, error: %s", err)
}
// ---
calabashAndroidArgs = []string{"bundle", "exec"}
}
calabashAndroidArgs = append(calabashAndroidArgs, "calabash-android")
// If no need to use bundler
if !useBundler {
if calabashAndroidVersion != "" {
// ... and calabash-android version detected
// Install calabash-android detetcted version with `gem install`
// Append version param to calabash-android command
installed, err := rubyCommand.IsGemInstalled("calabash-android", calabashAndroidVersion)
if err != nil {
registerFail("Failed to check if calabash-android (v%s) installed, error: %s", calabashAndroidVersion, err)
}
if !installed {
installCommands, err := rubyCommand.GemInstallCommands("calabash-android", calabashAndroidVersion)
if err != nil {
registerFail("Failed to create gem install commands, error: %s", err)
}
for _, installCommand := range installCommands {
log.Detail("$ %s", cmdex.PrintableCommandArgs(false, installCommand.GetCmd().Args))
if err := installCommand.Run(); err != nil {
registerFail("command failed, error: %s", err)
}
}
} else {
log.Detail("calabash-android %s installed", calabashAndroidVersion)
}
} else {
// ... and using latest version of calabash-android
// Install calabash-android latest version with `gem install`
installCommands, err := rubyCommand.GemInstallCommands("calabash-android", "")
if err != nil {
registerFail("Failed to create gem install commands, error: %s", err)
}
for _, installCommand := range installCommands {
log.Detail("$ %s", cmdex.PrintableCommandArgs(false, installCommand.GetCmd().Args))
if err := installCommand.Run(); err != nil {
registerFail("command failed, error: %s", err)
}
}
}
}
// ---
//
// Search for debug.keystore
fmt.Println()
log.Info("Search for debug.keystore...")
debugKeystorePth := ""
homeDir := pathutil.UserHomeDir()
// $HOME/.android/debug.keystore
androidDebugKeystorePth := filepath.Join(homeDir, ".android", "debug.keystore")
debugKeystorePth = androidDebugKeystorePth
if exist, err := pathutil.IsPathExists(androidDebugKeystorePth); err != nil {
registerFail("Failed to check if debug.keystore exists at (%s), error: %s", androidDebugKeystorePth, err)
} else if !exist {
log.Warn("android debug keystore not exist at: %s", androidDebugKeystorePth)
// $HOME/.local/share/Mono for Android/debug.keystore
xamarinDebugKeystorePth := filepath.Join(homeDir, ".local", "share", "Mono for Android", "debug.keystore")
log.Detail("checking xamarin debug keystore at: %s", xamarinDebugKeystorePth)
if exist, err := pathutil.IsPathExists(xamarinDebugKeystorePth); err != nil {
registerFail("Failed to check if debug.keystore exists at (%s), error: %s", xamarinDebugKeystorePth, err)
} else if !exist {
log.Warn("xamarin debug keystore not exist at: %s", xamarinDebugKeystorePth)
log.Detail("generating debug keystore")
// `keytool -genkey -v -keystore "#{debug_keystore}" -alias androiddebugkey -storepass android -keypass android -keyalg RSA -keysize 2048 -validity 10000 -dname "CN=Android Debug,O=Android,C=US"`
keytoolArgs := []string{"keytool", "-genkey", "-v", "-keystore", debugKeystorePth, "-alias", "androiddebugkey", "-storepass", "android", "-keypass", "android", "-keyalg", "RSA", "-keysize", "2048", "-validity", "10000", "-dname", "CN=Android Debug,O=Android,C=US"}
cmd, err := cmdex.NewCommandFromSlice(keytoolArgs)
if err != nil {
registerFail("Failed to create command, error: %s", err)
}
log.Detail("$ %s", cmdex.PrintableCommandArgs(false, keytoolArgs))
if err := cmd.Run(); err != nil {
registerFail("Failed to generate debug.keystore, error: %s", err)
}
log.Detail("using debug keystore: %s", debugKeystorePth)
} else {
log.Detail("using xamarin debug keystore: %s", xamarinDebugKeystorePth)
debugKeystorePth = xamarinDebugKeystorePth
}
} else {
log.Detail("using android debug keystore: %s", androidDebugKeystorePth)
}
// ---
//
// Resign apk with debug.keystore
fmt.Println()
log.Info("Resign apk with debug.keystore...")
resignArgs := []string{"calabash-android", "resign", configs.ApkPath}
resignCmd, err := rubyCommand.Command(useBundler, resignArgs)
if err != nil {
registerFail("Failed to create command, error: %s", err)
}
log.Detail("$ %s", cmdex.PrintableCommandArgs(false, resignArgs))
fmt.Println()
resignCmd.SetStdout(os.Stdout)
resignCmd.SetStderr(os.Stderr)
if err := resignCmd.Run(); err != nil {
registerFail("Failed to run command, error: %s", err)
}
// ---
//
// Run calabash-android
fmt.Println()
log.Info("Running calabash-android test...")
testArgs := []string{"calabash-android", "run", configs.ApkPath}
testCmd, err := rubyCommand.Command(useBundler, testArgs)
if err != nil {
registerFail("Failed to create command, error: %s", err)
}
log.Detail("$ %s", cmdex.PrintableCommandArgs(false, testArgs))
fmt.Println()
testCmd.SetStdout(os.Stdout)
testCmd.SetStderr(os.Stderr)
if err := testCmd.Run(); err != nil {
registerFail("Failed to run command, error: %s", err)
}
// ---
if err := exportEnvironmentWithEnvman("BITRISE_XAMARIN_TEST_RESULT", "succeeded"); err != nil {
log.Warn("Failed to export environment: %s, error: %s", "BITRISE_XAMARIN_TEST_RESULT", err)
}
}