func (tool *codeReviewTool) FinaliseRelease(v *version.Version) (action.Action, error) {
// Get a GitHub client.
config, err := LoadConfig()
if err != nil {
return nil, err
}
client := ghutil.NewClient(config.Token())
owner, repo, err := git.ParseUpstreamURL()
if err != nil {
return nil, err
}
// Get the relevant review milestone.
releaseString := v.BaseString()
task := fmt.Sprintf("Get GitHub review milestone for release %v", releaseString)
log.Run(task)
milestone, err := milestoneForVersion(config, owner, repo, v)
if err != nil {
return nil, errs.NewError(task, err)
}
if milestone == nil {
log.Warn(fmt.Sprintf(
"Weird, GitHub review milestone for release %v not found", releaseString))
return nil, nil
}
// Close the milestone unless there are some issues open.
task = fmt.Sprintf(
"Make sure the review milestone for release %v can be closed", releaseString)
if num := *milestone.OpenIssues; num != 0 {
return nil, errs.NewError(
task,
fmt.Errorf(
"review milestone for release %v cannot be closed: %v issue(s) open",
releaseString, num))
}
milestoneTask := fmt.Sprintf("Close GitHub review milestone for release %v", releaseString)
log.Run(milestoneTask)
milestone, _, err = client.Issues.EditMilestone(owner, repo, *milestone.Number, &github.Milestone{
State: github.String("closed"),
})
if err != nil {
return nil, errs.NewError(milestoneTask, err)
}
// Return a rollback function.
return action.ActionFunc(func() error {
log.Rollback(milestoneTask)
task := fmt.Sprintf("Reopen GitHub review milestone for release %v", releaseString)
_, _, err := client.Issues.EditMilestone(owner, repo, *milestone.Number, &github.Milestone{
State: github.String("open"),
})
if err != nil {
return errs.NewError(task, err)
}
return nil
}), nil
}
func (tool *codeReviewTool) InitialiseRelease(v *version.Version) (action.Action, error) {
// Get necessary config.
config, err := LoadConfig()
if err != nil {
return nil, err
}
owner, repo, err := git.ParseUpstreamURL()
if err != nil {
return nil, err
}
// Check whether the review milestone exists or not.
// People can create milestones manually, so this makes the thing more robust.
task := fmt.Sprintf("Check whether GitHub review milestone exists for release %v", v.BaseString())
log.Run(task)
milestone, err := milestoneForVersion(config, owner, repo, v)
if err != nil {
return nil, errs.NewError(task, err)
}
if milestone != nil {
// Milestone already exists, we are done.
log.Log(fmt.Sprintf("GitHub review milestone '%v' already exists", milestoneTitle(v)))
return nil, nil
}
// Create the review milestone.
_, act, err := createMilestone(config, owner, repo, v)
return act, err
}
func (tracker *issueTracker) getVersionResource(ver *version.Version) (*jira.Version, error) {
var (
projectKey = tracker.config.ProjectKey()
versionName = ver.ReleaseTagString()
api = newClient(tracker.config)
)
// In case the resource cache is empty, fill it.
if tracker.versionCache == nil {
vs, _, err := api.Projects.ListVersions(projectKey)
if err != nil {
return nil, err
}
m := make(map[string]*jira.Version, len(vs))
for _, v := range vs {
m[v.Name] = v
}
tracker.versionCache = m
}
// Return the resource we are looking for.
if res, ok := tracker.versionCache[versionName]; ok {
return res, nil
}
return nil, nil
}
// getOrCreateMilestone just calls ghissues.GetOrCreateMilestoneForTitle
// using the client and config as contained in this issueTracker.
func (tracker *issueTracker) getOrCreateMilestone(
v *version.Version,
) (*github.Milestone, action.Action, error) {
var (
client = tracker.newClient()
owner = tracker.config.GitHubOwner
repo = tracker.config.GitHubRepository
title = v.BaseString()
milestone *github.Milestone
act action.Action
err error
)
withRequestAllocated(func() {
milestone, act, err = ghissues.GetOrCreateMilestoneForTitle(client, owner, repo, title)
})
return milestone, act, err
}
func runMain() (err error) {
// Load repo config.
gitConfig, err := git.LoadConfig()
if err != nil {
return err
}
var (
remote = gitConfig.RemoteName
trunkBranch = gitConfig.TrunkBranchName
releaseBranch = gitConfig.ReleaseBranchName
stagingBranch = gitConfig.StagingBranchName
)
// Fetch the remote repository.
if !flagNoFetch {
task := "Fetch the remote repository"
log.Run(task)
if err := git.UpdateRemotes(remote); err != nil {
return errs.NewError(task, err)
}
}
// Make sure trunk is up to date.
task := fmt.Sprintf("Make sure that branch '%v' is up to date", trunkBranch)
if err := git.CheckOrCreateTrackingBranch(trunkBranch, remote); err != nil {
return errs.NewError(task, err)
}
// Make sure the staging branch is up to date, in case it exists.
//
// We check stage here as well since it is otherwise checked later
// in releases.ListNewTrunkCommits(), which is usually called in
// release.PromptUserToConfirmStart().
task = fmt.Sprintf("Make sure that branch '%v' is up to date", stagingBranch)
if err := git.CheckOrCreateTrackingBranch(stagingBranch, remote); err != nil {
// The staging branch actually doesn't need to exist.
if _, ok := err.(*git.ErrRefNotFound); !ok {
return errs.NewError(task, err)
}
}
// Make sure that the release branch does not exist.
task = fmt.Sprintf("Make sure that branch '%v' does not exist", releaseBranch)
if err := git.EnsureBranchNotExist(releaseBranch, remote); err != nil {
return errs.NewError(task, err)
}
// Get the current trunk version string.
task = "Get the current trunk version string"
trunkVersion, err := version.GetByBranch(trunkBranch)
if err != nil {
return errs.NewError(task, err)
}
// Get the next trunk version (the future release version).
var nextTrunkVersion *version.Version
if !flagNextTrunk.Zero() {
// Make sure it's only major, minor and patch that are set.
// Make sure the new version is actually incrementing the current one.
var (
current = trunkVersion
next = flagNextTrunk
)
var part string
switch {
case len(next.Pre) != 0:
part = "Pre"
case len(next.Build) != 0:
part = "Build"
}
if part != "" {
return fmt.Errorf("invalid future version string: %v version part cannot be set", part)
}
if current.GE(next.Version) {
return fmt.Errorf("future version string not an increment: %v <= %v", next, current)
}
nextTrunkVersion = &flagNextTrunk
} else {
nextTrunkVersion = trunkVersion.IncrementMinor()
}
// Make sure the next trunk version has the right format.
nextTrunkVersion, err = nextTrunkVersion.ToTrunkVersion()
if err != nil {
return err
}
// Fetch the stories from the issue tracker.
tracker, err := modules.GetIssueTracker()
if err != nil {
return errs.NewError(task, err)
}
release := tracker.NextRelease(trunkVersion, nextTrunkVersion)
// Prompt the user to confirm the release.
fmt.Printf(`
You are about to start a new release branch.
The relevant version strings are:
current release (current trunk version): %v
future release (next trunk version): %v
`, trunkVersion, nextTrunkVersion)
ok, err := release.PromptUserToConfirmStart()
if err != nil {
return err
}
if !ok {
fmt.Println("\nYour wish is my command, exiting now!")
return nil
}
fmt.Println()
// Create the release branch on top of the trunk branch.
task = fmt.Sprintf("Create branch '%v' on top of branch '%v'", releaseBranch, trunkBranch)
log.Run(task)
if err := git.Branch(releaseBranch, trunkBranch); err != nil {
return errs.NewError(task, err)
}
defer action.RollbackTaskOnError(&err, task, action.ActionFunc(func() error {
task := fmt.Sprintf("Delete branch '%v'", releaseBranch)
if err := git.Branch("-D", releaseBranch); err != nil {
errs.NewError(task, err)
}
return nil
}))
// Bump the release branch version.
testingVersion, err := trunkVersion.ToTestingVersion()
if err != nil {
return err
}
task = fmt.Sprintf("Bump version (branch '%v' -> %v)", releaseBranch, testingVersion)
log.Run(task)
_, err = version.SetForBranch(testingVersion, releaseBranch)
if err != nil {
return errs.NewError(task, err)
}
// No need for a rollback function here, git branch -d specified as a rollback
// for the previous step will take care of deleting this change as well.
// Bump the trunk branch version.
task = fmt.Sprintf("Bump version (branch '%v' -> %v)", trunkBranch, nextTrunkVersion)
log.Run(task)
act, err := version.SetForBranch(nextTrunkVersion, trunkBranch)
if err != nil {
return errs.NewError(task, err)
}
defer action.RollbackTaskOnError(&err, task, act)
// Initialise the next release in the code review tool.
codeReviewTool, err := modules.GetCodeReviewTool()
if err != nil {
return err
}
act, err = codeReviewTool.NewRelease(nextTrunkVersion).Initialise()
if err != nil {
return err
}
defer action.RollbackTaskOnError(&err, task, act)
// Start the release in the issue tracker.
act, err = release.Start()
if err != nil {
return err
}
defer action.RollbackTaskOnError(&err, task, act)
// Push the modified branches.
task = "Push changes to the remote repository"
log.Run(task)
err = git.Push(remote, trunkBranch+":"+trunkBranch, releaseBranch+":"+releaseBranch)
if err != nil {
return errs.NewError(task, err)
}
return nil
}
// issuesByRelease returns the issues assigned to the relevant milestone.
func (tracker *issueTracker) issuesByRelease(v *version.Version) ([]*github.Issue, error) {
return tracker.searchIssues(`milestone:"%v"`, v.BaseString())
}
func milestoneTitle(v *version.Version) string {
return fmt.Sprintf("%v-review", v.BaseString())
}
func (tracker *issueTracker) issuesByRelease(v *version.Version) ([]*jira.Issue, error) {
label := v.ReleaseTagString()
return tracker.searchIssues("labels = %v", label)
}
func getReleaseLabel(ver *version.Version) string {
return fmt.Sprintf("release-%v", ver.BaseString())
}