internal/relui: choose major versions dynamically

For convenience, I originally hardcoded Go1.17, 18, and 19 as the live
major Go versions. We're about to release 1.19, so that's not so
convenient any more.

Extract a function to read the live major version, and use it to
choose what workflows to create. While I'm here, add workflows to do
a single minor release in case we need to do that at some point.

For golang/go#51797.

Change-Id: I1e73e42b6c78df7f3e8deb0a191893ff3c887297
Reviewed-on: https://go-review.googlesource.com/c/build/+/418789
Reviewed-by: Dmitri Shuralyov <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Reviewed-by: Dmitri Shuralyov <[email protected]>
Run-TryBot: Heschi Kreinick <[email protected]>

Author: heschi

cmd/relui/main.go

@@ -161,7 +161,9 @@ func main() {
 		RepoOwner: "golang",
 		RepoName:  "go",
 	}
-	relui.RegisterReleaseWorkflows(dh, buildTasks, milestoneTasks, versionTasks, commTasks)
+	if err := relui.RegisterReleaseWorkflows(ctx, dh, buildTasks, milestoneTasks, versionTasks, commTasks); err != nil {
+		log.Fatalf("RegisterReleaseWorkflows: %v", err)
+	}
 
 	w := relui.NewWorker(dh, db, relui.NewPGListener(db))
 	go w.Run(ctx)

internal/relui/buildrelease_test.go

@@ -165,7 +165,7 @@ func newReleaseTestDeps(t *testing.T, wantVersion string) *releaseTestDeps {
 func testRelease(t *testing.T, wantVersion string, kind task.ReleaseKind) {
 	deps := newReleaseTestDeps(t, wantVersion)
 	wd := workflow.New()
-	v, err := addSingleReleaseWorkflow(deps.buildTasks, deps.milestoneTasks, deps.versionTasks, wd, "go1.18", kind)
+	v, err := addSingleReleaseWorkflow(deps.buildTasks, deps.milestoneTasks, deps.versionTasks, wd, 18, kind)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -284,7 +284,7 @@ func testSecurity(t *testing.T, mergeFixes bool) {
 
 	// Run the release.
 	wd := workflow.New()
-	v, err := addSingleReleaseWorkflow(deps.buildTasks, deps.milestoneTasks, deps.versionTasks, wd, "go1.18", task.KindRC)
+	v, err := addSingleReleaseWorkflow(deps.buildTasks, deps.milestoneTasks, deps.versionTasks, wd, 18, task.KindRC)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/relui/workflows.go

@@ -555,16 +555,31 @@ func ApproveActionDep(p *pgxpool.Pool) func(*workflow.TaskContext, interface{})
 const mergeCommTasksIntoReleaseWorkflows = false
 
 // RegisterReleaseWorkflows registers workflows for issuing Go releases.
-func RegisterReleaseWorkflows(h *DefinitionHolder, build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks, comm task.CommunicationTasks) error {
-	createSingle := func(name, major string, kind task.ReleaseKind) error {
+func RegisterReleaseWorkflows(ctx context.Context, h *DefinitionHolder, build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks, comm task.CommunicationTasks) error {
+	currentMajor, err := version.GetCurrentMajor(ctx)
+	if err != nil {
+		return err
+	}
+	releases := []struct {
+		kind   task.ReleaseKind
+		major  int
+		suffix string
+	}{
+		{task.KindMajor, currentMajor + 1, "final"},
+		{task.KindRC, currentMajor + 1, "next RC"},
+		{task.KindBeta, currentMajor + 1, "next beta"},
+		{task.KindCurrentMinor, currentMajor, "next minor"},
+		{task.KindPrevMinor, currentMajor - 1, "next minor"},
+	}
+	for _, r := range releases {
 		wd := workflow.New()
 
 		var names workflow.Value
 		if mergeCommTasksIntoReleaseWorkflows {
 			names = wd.Parameter(releaseCoordinatorNames)
 		}
 
-		versionPublished, err := addSingleReleaseWorkflow(build, milestone, version, wd, major, kind)
+		versionPublished, err := addSingleReleaseWorkflow(build, milestone, version, wd, r.major, r.kind)
 		if err != nil {
 			return err
 		}
@@ -574,64 +589,56 @@ func RegisterReleaseWorkflows(h *DefinitionHolder, build *BuildReleaseTasks, mil
 
 			// Announce that a new Go release has been published.
 			sentMail := wd.Task("mail-announcement", func(ctx *workflow.TaskContext, v string, names []string) (task.SentMail, error) {
-				switch kind {
+				switch r.kind {
 				case task.KindMajor:
 					return comm.AnnounceMajorRelease(ctx, task.ReleaseAnnouncement{Version: v, Names: names})
 				case task.KindRC:
 					return comm.AnnounceRCRelease(ctx, task.ReleaseAnnouncement{Version: v, Names: names})
 				case task.KindBeta:
 					return comm.AnnounceBetaRelease(ctx, task.ReleaseAnnouncement{Version: v, Names: names})
 				default:
-					return task.SentMail{}, fmt.Errorf("unknown release kind %v", kind)
+					return task.SentMail{}, fmt.Errorf("unknown release kind %v", r.kind)
 				}
 			}, versionPublished, names, okayToAnnounceAndTweet)
 			announcementURL := wd.Task("await-announcement", comm.AwaitAnnounceMail, sentMail)
 			tweetURL := wd.Task("post-tweet", func(ctx *workflow.TaskContext, v, ann string) (string, error) {
-				switch kind {
+				switch r.kind {
 				case task.KindMajor:
 					return comm.TweetMajorRelease(ctx, task.ReleaseTweet{Version: v})
 				case task.KindRC:
 					return comm.TweetRCRelease(ctx, task.ReleaseTweet{Version: v, Announcement: ann})
 				case task.KindBeta:
 					return comm.TweetBetaRelease(ctx, task.ReleaseTweet{Version: v, Announcement: ann})
 				default:
-					return "", fmt.Errorf("unknown release kind %v", kind)
+					return "", fmt.Errorf("unknown release kind %v", r.kind)
 				}
 			}, versionPublished, announcementURL, okayToAnnounceAndTweet)
 
 			wd.Output("Announcement URL", announcementURL)
 			wd.Output("Tweet URL", tweetURL)
 		}
 
-		h.RegisterDefinition(name, wd)
-		return nil
-	}
-	if err := createSingle("Go 1.19 final", "go1.19", task.KindMajor); err != nil {
-		return err
-	}
-	if err := createSingle("Go 1.19 next RC", "go1.19", task.KindRC); err != nil {
-		return err
-	}
-	if err := createSingle("Go 1.19 next beta", "go1.19", task.KindBeta); err != nil {
-		return err
+		h.RegisterDefinition(fmt.Sprintf("Go 1.%d %s", r.major, r.suffix), wd)
 	}
-	wd, err := createMinorReleaseWorkflow(build, milestone, version, comm, "go1.17", "go1.18")
+
+	wd, err := createMinorReleaseWorkflow(build, milestone, version, comm, currentMajor-1, currentMajor)
 	if err != nil {
 		return err
 	}
-	h.RegisterDefinition("Minor releases for Go 1.17 and 1.18", wd)
+	h.RegisterDefinition(fmt.Sprintf("Minor releases for Go 1.%d and 1.%d", currentMajor-1, currentMajor), wd)
+
 	wd = workflow.New()
-	if err := addBuildAndTestOnlyWorkflow(wd, version, build, "go1.19", task.KindBeta); err != nil {
+	if err := addBuildAndTestOnlyWorkflow(wd, version, build, currentMajor+1, task.KindBeta); err != nil {
 		return err
 	}
-	h.RegisterDefinition("dry-run (test and build only): Go 1.19 next beta", wd)
+	h.RegisterDefinition(fmt.Sprintf("dry-run (test and build only): Go 1.%d next beta", currentMajor+1), wd)
 
 	return nil
 }
 
-func addBuildAndTestOnlyWorkflow(wd *workflow.Definition, version *task.VersionTasks, build *BuildReleaseTasks, major string, kind task.ReleaseKind) error {
+func addBuildAndTestOnlyWorkflow(wd *workflow.Definition, version *task.VersionTasks, build *BuildReleaseTasks, major int, kind task.ReleaseKind) error {
 	nextVersion := wd.Task("Get next version", version.GetNextVersion, wd.Constant(kind))
-	branch := fmt.Sprintf("release-branch.%v", major)
+	branch := fmt.Sprintf("release-branch.go1.%d", major)
 	if kind == task.KindBeta {
 		branch = "master"
 	}
@@ -645,7 +652,7 @@ func addBuildAndTestOnlyWorkflow(wd *workflow.Definition, version *task.VersionT
 	return nil
 }
 
-func createMinorReleaseWorkflow(build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks, comm task.CommunicationTasks, prev, current string) (*workflow.Definition, error) {
+func createMinorReleaseWorkflow(build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks, comm task.CommunicationTasks, prevMajor, currentMajor int) (*workflow.Definition, error) {
 	wd := workflow.New()
 
 	var securitySummary, securityFixes, names workflow.Value
@@ -655,11 +662,11 @@ func createMinorReleaseWorkflow(build *BuildReleaseTasks, milestone *task.Milest
 		names = wd.Parameter(releaseCoordinatorNames)
 	}
 
-	v1Published, err := addSingleReleaseWorkflow(build, milestone, version, wd.Sub(current), current, task.KindCurrentMinor)
+	v1Published, err := addSingleReleaseWorkflow(build, milestone, version, wd.Sub(fmt.Sprintf("Go 1.%d", currentMajor)), currentMajor, task.KindCurrentMinor)
 	if err != nil {
 		return nil, err
 	}
-	v2Published, err := addSingleReleaseWorkflow(build, milestone, version, wd.Sub(prev), prev, task.KindPrevMinor)
+	v2Published, err := addSingleReleaseWorkflow(build, milestone, version, wd.Sub(fmt.Sprintf("Go 1.%d", prevMajor)), prevMajor, task.KindPrevMinor)
 	if err != nil {
 		return nil, err
 	}
@@ -685,10 +692,10 @@ func createMinorReleaseWorkflow(build *BuildReleaseTasks, milestone *task.Milest
 
 func addSingleReleaseWorkflow(
 	build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks,
-	wd *workflow.Definition, major string, kind task.ReleaseKind,
+	wd *workflow.Definition, major int, kind task.ReleaseKind,
 ) (versionPublished workflow.Value, _ error) {
 	kindVal := wd.Constant(kind)
-	branch := fmt.Sprintf("release-branch.%v", major)
+	branch := fmt.Sprintf("release-branch.go1.%d", major)
 	if kind == task.KindBeta {
 		branch = "master"
 	}
@@ -710,7 +717,7 @@ func addSingleReleaseWorkflow(
 	source := wd.Task("Build source archive", build.buildSource, startingHead, securityRef, nextVersion, checked)
 
 	// Build, test, and sign release.
-	signedAndTestedArtifacts, err := build.addBuildTasks(wd, "go1.19", nextVersion, source, false)
+	signedAndTestedArtifacts, err := build.addBuildTasks(wd, major, nextVersion, source, false)
 	if err != nil {
 		return nil, err
 	}
@@ -740,12 +747,8 @@ func addSingleReleaseWorkflow(
 
 // addBuildTasks registers tasks to build, test, and sign the release onto wd.
 // It returns the output from the last task, a slice of signed and tested artifacts.
-func (tasks *BuildReleaseTasks) addBuildTasks(wd *workflow.Definition, majorVersion string, version, source workflow.Value, skipSigning bool) (workflow.Value, error) {
-	targets, ok := releasetargets.TargetsForVersion(majorVersion)
-	if !ok {
-		return nil, fmt.Errorf("malformed/unknown version %q", majorVersion)
-	}
-
+func (tasks *BuildReleaseTasks) addBuildTasks(wd *workflow.Definition, major int, version, source workflow.Value, skipSigning bool) (workflow.Value, error) {
+	targets := releasetargets.TargetsForGo1Point(major)
 	skipTests := wd.Parameter(workflow.Parameter{Name: "Targets to skip testing (or 'all') (optional)", ParameterType: workflow.SliceShort})
 	// Artifact file paths.
 	artifacts := []workflow.Value{source}

internal/task/version.go

@@ -7,6 +7,7 @@ import (
 
 	"golang.org/x/build/gerrit"
 	"golang.org/x/build/internal/workflow"
+	"golang.org/x/net/context"
 )
 
 // VersionTasks contains tasks related to versioning the release.
@@ -15,27 +16,40 @@ type VersionTasks struct {
 	GoProject string
 }
 
-// GetNextVersion returns the next for the given type of release.
-func (t *VersionTasks) GetNextVersion(ctx *workflow.TaskContext, kind ReleaseKind) (string, error) {
-	tags, err := t.Gerrit.ListTags(ctx, t.GoProject)
+func (t *VersionTasks) GetCurrentMajor(ctx context.Context) (int, error) {
+	_, currentMajor, err := t.tagInfo(ctx)
+	return currentMajor, err
+}
+
+func (t *VersionTasks) tagInfo(ctx context.Context) (tags map[string]bool, currentMajor int, _ error) {
+	tagList, err := t.Gerrit.ListTags(ctx, t.GoProject)
 	if err != nil {
-		return "", err
+		return nil, 0, err
 	}
-	tagSet := map[string]bool{}
-	for _, tag := range tags {
-		tagSet[tag] = true
+	tags = map[string]bool{}
+	for _, tag := range tagList {
+		tags[tag] = true
 	}
 	// Find the most recently released major version.
 	// Going down from a high number is convenient for testing.
-	currentMajor := 100
+	currentMajor = 100
 	for ; ; currentMajor-- {
-		if tagSet[fmt.Sprintf("go1.%d", currentMajor)] {
+		if tags[fmt.Sprintf("go1.%d", currentMajor)] {
 			break
 		}
 	}
+	return tags, currentMajor, nil
+}
+
+// GetNextVersion returns the next for the given type of release.
+func (t *VersionTasks) GetNextVersion(ctx context.Context, kind ReleaseKind) (string, error) {
+	tags, currentMajor, err := t.tagInfo(ctx)
+	if err != nil {
+		return "", err
+	}
 	findUnused := func(v string) (string, error) {
 		for {
-			if !tagSet[v] {
+			if !tags[v] {
 				return v, nil
 			}
 			v, err = nextVersion(v)