// GenerateLog : generates the log for subsequent "Scan" call
func (xccmd CommandModel) GenerateLog() (string, error) {
xcoutput := ""
var err error
progress.SimpleProgress(".", 1*time.Second, func() {
xcoutput, err = xccmd.RunXcodebuildCommand("clean", "archive")
})
fmt.Println()
if err != nil {
return xcoutput, fmt.Errorf("Failed to Archive, error: %s", err)
}
return xcoutput, nil
}
// GenerateLog ...
func (xamarinCmd CommandModel) GenerateLog() (string, error) {
cmdOut := ""
var err error
progress.SimpleProgress(".", 1*time.Second, func() {
cmdOut, err = xamarinCmd.RunBuildCommand()
})
fmt.Println()
if err != nil {
return cmdOut, fmt.Errorf("Failed to Archive, error: %s", err)
}
return cmdOut, 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 main() {
configs := createConfigsModelFromEnvs()
configs.print()
if err := configs.validate(); err != nil {
log.Error("Issue with input: %s", err)
os.Exit(1)
}
fmt.Println()
log.Info("Other Configs:")
cleanBuild := (configs.IsCleanBuild == "yes")
generateCodeCoverage := (configs.GenerateCodeCoverageFiles == "yes")
exportUITestArtifacts := (configs.ExportUITestArtifacts == "true")
singleBuild := (configs.IsSingleBuild == "true")
buildBeforeTest := (configs.ShouldBuildBeforeTest == "yes")
retryOnFail := (configs.ShouldRetryTestOnFail == "yes")
// Project-or-Workspace flag
action := ""
if strings.HasSuffix(configs.ProjectPath, ".xcodeproj") {
action = "-project"
} else if strings.HasSuffix(configs.ProjectPath, ".xcworkspace") {
action = "-workspace"
} else {
log.Error("Iinvalid project file (%s), extension should be (.xcodeproj/.xcworkspace)", configs.ProjectPath)
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "failed"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
os.Exit(1)
}
log.Detail("* action: %s", action)
// Device Destination
deviceDestination := fmt.Sprintf("platform=%s,name=%s,OS=%s", configs.SimulatorPlatform, configs.SimulatorDevice, configs.SimulatorOsVersion)
log.Detail("* device_destination: %s", deviceDestination)
// Output tools versions
xcodebuildVersion, err := xcodeutil.GetXcodeVersion()
if err != nil {
log.Error("Failed to get the version of xcodebuild! Error: %s", err)
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "failed"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
os.Exit(1)
}
log.Detail("* xcodebuild_version: %s (%s)", xcodebuildVersion.Version, xcodebuildVersion.BuildVersion)
xcprettyVersion, err := cmd.GetXcprettyVersion()
if err != nil {
log.Warn("Failed to get the xcpretty version! Error: %s", err)
} else {
log.Detail("* xcpretty_version: %s", xcprettyVersion)
}
// Simulator infos
simulator, err := xcodeutil.GetSimulator(configs.SimulatorPlatform, configs.SimulatorDevice, configs.SimulatorOsVersion)
if err != nil {
log.Error(fmt.Sprintf("failed to get simulator udid, error: %s", err))
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "failed"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
os.Exit(1)
}
log.Detail("* simulator_name: %s, UDID: %s, status: %s", simulator.Name, simulator.SimID, simulator.Status)
fmt.Println()
buildParams := models.XcodeBuildParamsModel{
Action: action,
ProjectPath: configs.ProjectPath,
Scheme: configs.Scheme,
DeviceDestination: deviceDestination,
CleanBuild: cleanBuild,
}
buildTestParams := models.XcodeBuildTestParamsModel{
BuildParams: buildParams,
BuildBeforeTest: buildBeforeTest,
AdditionalOptions: configs.TestOptions,
GenerateCodeCoverage: generateCodeCoverage,
}
if singleBuild {
buildTestParams.CleanBuild = cleanBuild
}
//
// Start simulator
if simulator.Status == "Shutdown" {
log.Info("Booting simulator (%s)...", simulator.SimID)
if err := xcodeutil.BootSimulator(simulator, xcodebuildVersion); err != nil {
log.Error(fmt.Sprintf("failed to boot simulator, error: %s", err))
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "failed"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
os.Exit(1)
}
if configs.WaitForSimulatorBoot == "yes" {
log.Detail("Waiting for simulator boot")
progress.SimpleProgress(".", 1*time.Second, func() {
time.Sleep(60 * time.Second)
})
}
fmt.Println()
}
//
// Run build
if !singleBuild {
if rawXcodebuildOutput, exitCode, buildErr := runBuild(buildParams, configs.OutputTool); buildErr != nil {
if err := saveRawOutputToLogFile(rawXcodebuildOutput, false); err != nil {
log.Warn("Failed to save the Raw Output, err: %s", err)
}
log.Warn("xcode build exit code: %d", exitCode)
log.Warn("xcode build log:\n%s", rawXcodebuildOutput)
log.Error("xcode build failed with error: %s", buildErr)
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "failed"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
os.Exit(1)
}
}
//
// Run test
rawXcodebuildOutput, exitCode, testErr := runTest(buildTestParams, configs.OutputTool, configs.XcprettyTestOptions, true, retryOnFail)
if err := saveRawOutputToLogFile(rawXcodebuildOutput, (testErr == nil)); err != nil {
log.Warn("Failed to save the Raw Output, error %s", err)
}
if exportUITestArtifacts {
if err := saveAttachements(configs.ProjectPath, configs.Scheme); err != nil {
log.Warn("Failed to export UI test artifacts, error %s", err)
}
}
if testErr != nil {
log.Warn("xcode test exit code: %d", exitCode)
log.Error("xcode test failed, error: %s", testErr)
hint := `If you can't find the reason of the error in the log, please check the raw-xcodebuild-output.log
The log file is stored in $BITRISE_DEPLOY_DIR, and its full path
is available in the $BITRISE_XCODE_RAW_TEST_RESULT_TEXT_PATH environment variable`
log.Warn(hint)
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "failed"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
os.Exit(1)
}
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_RESULT", "succeeded"); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_RESULT, error: %s", err)
}
}
