func ensureCurrentBranch(config releaseman.Config) error {
currentBranch, err := git.CurrentBranchName()
if err != nil {
return err
}
if config.Release.DevelopmentBranch != currentBranch {
if releaseman.IsCIMode {
return fmt.Errorf("Your current branch (%s), should be the development branch (%s)!", currentBranch, config.Release.DevelopmentBranch)
}
log.Warnf("Your current branch (%s), should be the development branch (%s)!", currentBranch, config.Release.DevelopmentBranch)
fmt.Println()
checkout, err := goinp.AskForBoolWithDefault(fmt.Sprintf("Would you like to checkout development branch (%s)?", config.Release.DevelopmentBranch), true)
if err != nil {
return err
}
if !checkout {
return fmt.Errorf("Current branch should be the development branch (%s)!", config.Release.DevelopmentBranch)
}
if err := git.CheckoutBranch(config.Release.DevelopmentBranch); err != nil {
return err
}
}
return nil
}
func createChangelog(c *cli.Context) {
//
// Build config
config := releaseman.Config{}
configPath := ""
if c.IsSet("config") {
configPath = c.String("config")
} else {
configPath = releaseman.DefaultConfigPth
}
if exist, err := pathutil.IsPathExists(configPath); err != nil {
log.Warnf("Failed to check if path exist, error: %#v", err)
} else if exist {
config, err = releaseman.NewConfigFromFile(configPath)
if err != nil {
log.Fatalf("Failed to parse release config at (%s), error: %#v", configPath, err)
}
}
config, err := collectChangelogConfigParams(config, c)
if err != nil {
log.Fatalf("Failed to collect config params, error: %#v", err)
}
//
// Validate config
config.Print(releaseman.ChangelogMode)
if !releaseman.IsCIMode {
ok, err := goinp.AskForBoolWithDefault("Are you ready for creating Changelog?", true)
if err != nil {
log.Fatalf("Failed to ask for input, error: %s", err)
}
if !ok {
log.Fatal("Aborted create Changelog")
}
}
//
// Run set version script
if c.IsSet(SetVersionScriptKey) {
setVersionScript := c.String(SetVersionScriptKey)
if err := runSetVersionScript(setVersionScript, config.Release.Version); err != nil {
log.Fatalf("Failed to run set version script, error: %#v", err)
}
}
//
// Generate Changelog
generateChangelog(config)
fmt.Println()
log.Infoln(colorstring.Greenf("v%s Changelog created (%s) 🚀", config.Release.Version, config.Changelog.Path))
}
// InstallWithAptGetIfNeeded ...
func InstallWithAptGetIfNeeded(aptGetDep stepmanModels.AptGetDepModel, isCIMode bool) error {
isDepInstalled := false
// First do a "which", to see if the binary is available.
// Can be available from another source, not just from brew,
// e.g. it's common to use NVM or similar to install and manage the Node.js version.
{
if out, err := cmdex.RunCommandAndReturnCombinedStdoutAndStderr("which", aptGetDep.GetBinaryName()); err != nil {
if err.Error() == "exit status 1" && out == "" {
isDepInstalled = false
} else {
// unexpected `which` error
return fmt.Errorf("which (%s) failed -- out: (%s) err: (%s)", aptGetDep.Name, out, err)
}
} else if out != "" {
isDepInstalled = true
} else {
// no error but which's output was empty
return fmt.Errorf("which (%s) failed -- no error (exit code 0) but output was empty", aptGetDep.Name)
}
}
// then do a package manager specific lookup
{
if !isDepInstalled {
// which did not find the binary, also check in brew,
// whether the package is installed
isDepInstalled = checkIfAptPackageInstalled(aptGetDep.Name)
}
}
if !isDepInstalled {
// Tool isn't installed -- install it...
if !isCIMode {
log.Infof(`This step requires "%s" to be available, but it is not installed.`, aptGetDep.GetBinaryName())
allow, err := goinp.AskForBoolWithDefault(`Would you like to install the "`+aptGetDep.Name+`" package with apt-get?`, true)
if err != nil {
return err
}
if !allow {
return errors.New("(" + aptGetDep.Name + ") is required for step")
}
}
log.Infof("(%s) isn't installed, installing...", aptGetDep.Name)
if cmdOut, err := cmdex.RunCommandAndReturnCombinedStdoutAndStderr("sudo", "apt-get", "-y", "install", aptGetDep.Name); err != nil {
log.Errorf("sudo apt-get -y install %s failed -- out: (%s) err: (%s)", aptGetDep.Name, cmdOut, err)
return err
}
log.Infof(" * "+colorstring.Green("[OK]")+" %s installed", aptGetDep.Name)
}
return nil
}
func initRelease(c *cli.Context) {
//
// Fail if git is not clean
if exist, err := pathutil.IsPathExists(releaseman.DefaultConfigPth); err != nil {
log.Fatalf("Failed to check path (%s), error: %#v", releaseman.DefaultConfigPth, err)
} else if exist {
if releaseman.IsCIMode {
log.Fatalf("Release config already exist at (%s)", releaseman.DefaultConfigPth)
} else {
ok, err := goinp.AskForBoolWithDefault(fmt.Sprintf("Release config already exist at (%s), would you like to overwrite it?", releaseman.DefaultConfigPth), true)
if err != nil {
log.Fatalf("Failed to ask for bool, error: %#v", err)
} else if !ok {
log.Fatalln("Create release config aborted")
}
}
}
releaseConfig, err := collectInitConfigParams(releaseman.Config{}, c)
if err != nil {
log.Fatalf("Failed to collect config params, error: %#v", err)
}
releaseConfig.Changelog.ContentTemplate = releaseman.ChangelogContentTemplate
releaseConfig.Changelog.HeaderTemplate = releaseman.ChangelogHeaderTemplate
releaseConfig.Changelog.FooterTemplate = releaseman.ChangelogFooterTemplate
//
// Print config
releaseConfig.Print(releaseman.FullMode)
bytes, err := yaml.Marshal(releaseConfig)
if err != nil {
log.Fatalf("Failed to marshal config, error: %#v", err)
}
if err := fileutil.WriteBytesToFile(releaseman.DefaultConfigPth, bytes); err != nil {
log.Fatalf("Failed to write config to file, error: %#v", err)
}
}
func create(c *cli.Context) {
//
// Fail if git is not clean
if err := ensureCleanGit(); err != nil {
log.Fatalf("Ensure clean git failed, error: %#v", err)
}
//
// Build config
config := releaseman.Config{}
configPath := ""
if c.IsSet("config") {
configPath = c.String("config")
} else {
configPath = releaseman.DefaultConfigPth
}
if exist, err := pathutil.IsPathExists(configPath); err != nil {
log.Warnf("Failed to check if path exist, error: %#v", err)
} else if exist {
config, err = releaseman.NewConfigFromFile(configPath)
if err != nil {
log.Fatalf("Failed to parse release config at (%s), error: %#v", configPath, err)
}
}
config, err := collectConfigParams(config, c)
if err != nil {
log.Fatalf("Failed to collect config params, error: %#v", err)
}
printRollBackMessage()
//
// Validate config
config.Print(releaseman.FullMode)
if !releaseman.IsCIMode {
ok, err := goinp.AskForBoolWithDefault("Are you ready for release?", true)
if err != nil {
log.Fatalf("Failed to ask for input, error: %s", err)
}
if !ok {
log.Fatal("Aborted release")
}
}
//
// Run set version script
if c.IsSet(SetVersionScriptKey) {
setVersionScript := c.String(SetVersionScriptKey)
if err := runSetVersionScript(setVersionScript, config.Release.Version); err != nil {
log.Fatalf("Failed to run set version script, error: %#v", err)
}
}
//
// Generate Changelog
generateChangelog(config)
//
// Create release git changes
generateRelease(config)
fmt.Println()
log.Infoln(colorstring.Greenf("v%s released 🚀", config.Release.Version))
log.Infoln("Take a look at your git, and if you are happy with the release, push the changes.")
}
func exportCodeSigningFiles(toolName, absExportOutputDirPath string, codeSigningSettings common.CodeSigningSettings) error {
fmt.Println()
fmt.Println()
utils.Printlnf("=== Required Identities/Certificates (%d) ===", len(codeSigningSettings.Identities))
for idx, anIdentity := range codeSigningSettings.Identities {
utils.Printlnf(" * (%d): %s", idx+1, anIdentity.Title)
}
fmt.Println("============================================")
fmt.Println()
utils.Printlnf("=== Required Provisioning Profiles (%d) ===", len(codeSigningSettings.ProvProfiles))
for idx, aProvProfile := range codeSigningSettings.ProvProfiles {
utils.Printlnf(" * (%d): %s (UUID: %s)", idx+1, aProvProfile.Title, aProvProfile.UUID)
}
fmt.Println("==========================================")
fmt.Println()
utils.Printlnf("=== Team IDs (%d) ===", len(codeSigningSettings.TeamIDs))
for idx, aTeamID := range codeSigningSettings.TeamIDs {
utils.Printlnf(" * (%d): %s", idx+1, aTeamID)
}
fmt.Println("==========================================")
fmt.Println()
utils.Printlnf("=== App/Bundle IDs (%d) ===", len(codeSigningSettings.AppIDs))
for idx, anAppBundleID := range codeSigningSettings.AppIDs {
utils.Printlnf(" * (%d): %s", idx+1, anAppBundleID)
}
fmt.Println("==========================================")
fmt.Println()
//
// --- Code Signing issue checks / report
//
if len(codeSigningSettings.Identities) < 1 {
return printFinishedWithError(toolName, "No Code Signing Identity detected!")
}
if len(codeSigningSettings.Identities) > 1 {
log.Warning(colorstring.Yellow("More than one Code Signing Identity (certificate) is required to sign your app!"))
log.Warning("You should check your settings and make sure a single Identity/Certificate can be used")
log.Warning(" for Archiving your app!")
}
if len(codeSigningSettings.ProvProfiles) < 1 {
return printFinishedWithError(toolName, "No Provisioning Profiles detected!")
}
//
// --- Export
//
if !isAllowExport {
isShouldExport, err := goinp.AskForBoolWithDefault("Do you want to export these files?", true)
if err != nil {
return printFinishedWithError(toolName, "Failed to process your input: %s", err)
}
if !isShouldExport {
printFinished()
return nil
}
} else {
log.Debug("Allow Export flag was set - doing export without asking")
}
exportedProvProfiles, err := collectAndExportProvisioningProfiles(codeSigningSettings, absExportOutputDirPath)
if err != nil {
return printFinishedWithError(toolName, "Failed to export Provisioning Profiles, error: %s", err)
}
if err := collectAndExportIdentities(codeSigningSettings, exportedProvProfiles.CollectTeamIDs(), absExportOutputDirPath); err != nil {
return printFinishedWithError(toolName, "Failed to export identities, error: %s", err)
}
fmt.Println()
fmt.Printf(colorstring.Green("Exports finished")+" you can find the exported files at: %s\n", absExportOutputDirPath)
if err := cmdex.RunCommand("open", absExportOutputDirPath); err != nil {
log.Errorf("Failed to open the export directory in Finder: %s", absExportOutputDirPath)
}
fmt.Println("Opened the directory in Finder.")
fmt.Println()
printFinished()
return nil
}
