internal/task: move "unwait" task to ReleaseCycleTasks, add "apply wait"

The new "apply wait" task is analogous to the existing "unwait" one,
and was tested out during the Go 1.24 freeze two weeks ago.

Move both of them into a new release cycle-focused struct where more
release-cycle logic will be added next.

For golang/go#70655.

Change-Id: Id8443f6d3ca366c27b15e0e8e4ef3aa1901d32d2
Reviewed-on: https://go-review.googlesource.com/c/build/+/633579
Reviewed-by: Michael Knyszek <[email protected]>
Auto-Submit: Dmitri Shuralyov <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Dmitri Shuralyov <[email protected]>

Author: dmitshur

cmd/relui/main.go

@@ -287,7 +287,10 @@ func main() {
 			Branch:    "main",
 		},
 	}
-	if err := relui.RegisterReleaseWorkflows(ctx, dh, buildTasks, milestoneTasks, versionTasks, commTasks); err != nil {
+	cycleTasks := task.ReleaseCycleTasks{
+		Gerrit: gerritClient,
+	}
+	if err := relui.RegisterReleaseWorkflows(ctx, dh, buildTasks, milestoneTasks, versionTasks, cycleTasks, commTasks); err != nil {
 		log.Fatalf("RegisterReleaseWorkflows: %v", err)
 	}
 

internal/relui/workflows.go

@@ -255,7 +255,7 @@ func ApproveActionDep(p db.PGDBTX) func(*wf.TaskContext) error {
 }
 
 // RegisterReleaseWorkflows registers workflows for issuing Go releases.
-func RegisterReleaseWorkflows(ctx context.Context, h *DefinitionHolder, build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks, comm task.CommunicationTasks) error {
+func RegisterReleaseWorkflows(ctx context.Context, h *DefinitionHolder, build *BuildReleaseTasks, milestone *task.MilestoneTasks, version *task.VersionTasks, cycle task.ReleaseCycleTasks, comm task.CommunicationTasks) error {
 	// Register prod release workflows.
 	if err := registerProdReleaseWorkflows(ctx, h, build, milestone, version, comm); err != nil {
 		return err
@@ -292,7 +292,14 @@ func RegisterReleaseWorkflows(ctx context.Context, h *DefinitionHolder, build *B
 		h.RegisterDefinition("pre-announce next minor release for Go "+strings.Join(names, " and "), wd)
 	}
 
-	// Register workflows for miscellaneous tasks that happen as part of the Go release cycle.
+	// Register workflows for miscellaneous tasks that happen as part of the Go release cycle (go.dev/s/release).
+	{
+		// Register an "apply wait-release to CLs" workflow.
+		wd := wf.New(wf.ACL{Groups: []string{groups.ReleaseTeam}})
+		waited := wf.Task0(wd, "Apply wait-release to CLs", cycle.ApplyWaitReleaseCLs)
+		wf.Output(wd, "waited", waited)
+		h.RegisterDefinition("apply wait-release to CLs", wd)
+	}
 	{
 		// Register a "ping early-in-cycle issues" workflow.
 		wd := wf.New(wf.ACL{Groups: []string{groups.ReleaseTeam}})
@@ -315,7 +322,7 @@ func RegisterReleaseWorkflows(ctx context.Context, h *DefinitionHolder, build *B
 	{
 		// Register an "unwait wait-release CLs" workflow.
 		wd := wf.New(wf.ACL{Groups: []string{groups.ReleaseTeam}})
-		unwaited := wf.Task0(wd, "Unwait wait-release CLs", version.UnwaitWaitReleaseCLs)
+		unwaited := wf.Task0(wd, "Unwait wait-release CLs", cycle.UnwaitWaitReleaseCLs)
 		wf.Output(wd, "unwaited", unwaited)
 		h.RegisterDefinition("unwait wait-release CLs", wd)
 	}

internal/task/releasecycle.go

@@ -0,0 +1,69 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package task
+
+import (
+	"time"
+
+	"golang.org/x/build/gerrit"
+	"golang.org/x/build/internal/workflow"
+)
+
+// ReleaseCycleTasks implements tasks related to the Go release cycle (go.dev/s/release).
+type ReleaseCycleTasks struct {
+	Gerrit GerritClient
+}
+
+// ApplyWaitReleaseCLs applies a "wait-release" hashtag to remaining open CLs that are
+// adding new APIs and should wait for next release. This is done once at the start of
+// the release freeze.
+func (t ReleaseCycleTasks) ApplyWaitReleaseCLs(ctx *workflow.TaskContext) (result struct{}, _ error) {
+	clsToWait, err := t.Gerrit.QueryChanges(ctx, "repo:go status:open -is:wip dir:api/next -hashtag:wait-release")
+	if err != nil {
+		return struct{}{}, err
+	}
+	ctx.Printf("Processing %d open Gerrit CLs to be marked with wait-release hashtag.", len(clsToWait))
+	for _, cl := range clsToWait {
+		const dryRun = false
+		if dryRun {
+			ctx.Printf("[dry run] Would've waited CL %d (%.32s…).", cl.ChangeNumber, cl.Subject)
+			continue
+		}
+		err := t.Gerrit.SetHashtags(ctx, cl.ID, gerrit.HashtagsInput{Add: []string{"wait-release"}})
+		if err != nil {
+			return struct{}{}, err
+		}
+		ctx.Printf("Waited CL %d (%.32s…).", cl.ChangeNumber, cl.Subject)
+		time.Sleep(3 * time.Second) // Take a moment between updating CLs to avoid a high rate of modify operations.
+	}
+	return struct{}{}, nil
+}
+
+// UnwaitWaitReleaseCLs changes all open Gerrit CLs with hashtag "wait-release" into "ex-wait-release".
+// This is done once at the opening of a release cycle, currently via a standalone workflow.
+func (t ReleaseCycleTasks) UnwaitWaitReleaseCLs(ctx *workflow.TaskContext) (result struct{}, _ error) {
+	waitingCLs, err := t.Gerrit.QueryChanges(ctx, "status:open hashtag:wait-release")
+	if err != nil {
+		return struct{}{}, err
+	}
+	ctx.Printf("Processing %d open Gerrit CL with wait-release hashtag.", len(waitingCLs))
+	for _, cl := range waitingCLs {
+		const dryRun = false
+		if dryRun {
+			ctx.Printf("[dry run] Would've unwaited CL %d (%.32s…).", cl.ChangeNumber, cl.Subject)
+			continue
+		}
+		err := t.Gerrit.SetHashtags(ctx, cl.ID, gerrit.HashtagsInput{
+			Remove: []string{"wait-release"},
+			Add:    []string{"ex-wait-release"},
+		})
+		if err != nil {
+			return struct{}{}, err
+		}
+		ctx.Printf("Unwaited CL %d (%.32s…).", cl.ChangeNumber, cl.Subject)
+		time.Sleep(3 * time.Second) // Take a moment between updating CLs to avoid a high rate of modify operations.
+	}
+	return struct{}{}, nil
+}

internal/task/version.go

@@ -233,30 +233,3 @@ func (t *VersionTasks) CreateUpdateStdlibIndexCL(ctx *workflow.TaskContext, revi
 	}
 	return t.Gerrit.CreateAutoSubmitChange(ctx, changeInput, reviewers, files)
 }
-
-// UnwaitWaitReleaseCLs changes all open Gerrit CLs with hashtag "wait-release" into "ex-wait-release".
-// This is done once at the opening of a release cycle, currently via a standalone workflow.
-func (t *VersionTasks) UnwaitWaitReleaseCLs(ctx *workflow.TaskContext) (result struct{}, _ error) {
-	waitingCLs, err := t.Gerrit.QueryChanges(ctx, "status:open hashtag:wait-release")
-	if err != nil {
-		return struct{}{}, err
-	}
-	ctx.Printf("Processing %d open Gerrit CL with wait-release hashtag.", len(waitingCLs))
-	for _, cl := range waitingCLs {
-		const dryRun = false
-		if dryRun {
-			ctx.Printf("[dry run] Would've unwaited CL %d (%.32s…).", cl.ChangeNumber, cl.Subject)
-			continue
-		}
-		err := t.Gerrit.SetHashtags(ctx, cl.ID, gerrit.HashtagsInput{
-			Remove: []string{"wait-release"},
-			Add:    []string{"ex-wait-release"},
-		})
-		if err != nil {
-			return struct{}{}, err
-		}
-		ctx.Printf("Unwaited CL %d (%.32s…).", cl.ChangeNumber, cl.Subject)
-		time.Sleep(3 * time.Second) // Take a moment between updating CLs to avoid a high rate of modify operations.
-	}
-	return struct{}{}, nil
-}