cmd/relui,internal/task: add workflow for re-syncing go-private master

This is currently a manual process that requires a high-priv grant, a
workflow significantly reduces the likelihood of getting this wrong. It
also lets us use a cron-like schedule to automate these updates.

Updates golang/go#59717

Change-Id: Iff7ce7c37f2ecd9dfee79ee8e80cfb98810011e6
Reviewed-on: https://go-review.googlesource.com/c/build/+/486575
Run-TryBot: Roland Shoemaker <[email protected]>
Reviewed-by: Heschi Kreinick <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: rolandshoemaker

cmd/relui/main.go

@@ -245,6 +245,12 @@ func main() {
 	}
 	dh.RegisterDefinition("Tag a new version of x/telemetry/config (if necessary)", tagTelemetryTasks.NewDefinition())
 
+	privateSyncTask := &task.PrivateMasterSyncTask{
+		PrivateGerritURL: "https://team.googlesource.com/golang/go-private",
+		Ref:              "public",
+	}
+	dh.RegisterDefinition("Sync go-private master branch with public", privateSyncTask.NewDefinition())
+
 	var base *url.URL
 	if *baseURL != "" {
 		base, err = url.Parse(*baseURL)

internal/task/sync_private.go

@@ -0,0 +1,47 @@
+// Copyright 2023 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 (
+	"fmt"
+
+	wf "golang.org/x/build/internal/workflow"
+)
+
+type PrivateMasterSyncTask struct {
+	PrivateGerritURL string
+	Ref              string
+}
+
+func (t *PrivateMasterSyncTask) NewDefinition() *wf.Definition {
+	wd := wf.New()
+	// We use a Task, instead of an Action, even though we don't actually want
+	// to return any result, because nothing depends on the Action, and if we
+	// use an Action the definition will tell us we don't reference it anywhere
+	// and say it should be deleted.
+	synced := wf.Task0(wd, "Sync go-private master to public", func(ctx *wf.TaskContext) (string, error) {
+		git := &Git{}
+		repo, err := git.Clone(ctx, t.PrivateGerritURL)
+		if err != nil {
+			return "", err
+		}
+
+		// NOTE: we assume this is generally safe in the case of a race between
+		// submitting a patch and resetting the master branch due to the ordering
+		// of operations at Gerrit. If the submit wins, we reset the master
+		// branch, and the submitted commit is orphaned, which is the expected
+		// behavior anyway. If the reset wins, the submission will either be
+		// cherry-picked onto the new base, which should either succeed, or fail
+		// due to a merge conflict, or Gerrit will reject the submission because
+		// something changed underneath it. Either case seems fine.
+		if _, err := repo.RunCommand(ctx.Context, "push", "--force", "origin", fmt.Sprintf("origin/%s:refs/heads/master", t.Ref)); err != nil {
+			return "", err
+		}
+
+		return "finished", nil
+	})
+	wf.Output(wd, fmt.Sprintf("Reset master to %s", t.Ref), synced)
+	return wd
+}

internal/task/sync_private_test.go

@@ -0,0 +1,46 @@
+package task
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/build/internal/workflow"
+)
+
+func TestSyncPrivate(t *testing.T) {
+	fakeRepo := NewFakeRepo(t, "fake")
+	masterCommit := fakeRepo.CommitOnBranch("master", map[string]string{
+		"hello": "there",
+	})
+	fakeRepo.Branch("public", masterCommit)
+	publicCommit := fakeRepo.CommitOnBranch("public", map[string]string{
+		"general": "kenobi",
+	})
+
+	sync := &PrivateMasterSyncTask{
+		PrivateGerritURL: fakeRepo.dir.dir, // kind of wild that this works
+		Ref:              "public",
+	}
+
+	wd := sync.NewDefinition()
+	w, err := workflow.Start(wd, map[string]any{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	_, err = w.Run(ctx, &verboseListener{t: t})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fakeRepo.runGit("switch", "master")
+	newMasterCommit := strings.TrimSpace(string(fakeRepo.runGit("rev-parse", "HEAD")))
+	// newMasterCommit := fakeRepo.ReadBranchHead(context.Background(), )
+
+	if newMasterCommit != publicCommit {
+		t.Fatalf("unexpected master commit: got %q, want %q", newMasterCommit, publicCommit)
+	}
+}