feature/release: update sg release cut to automate stitch graph gen and release branch creation (#63794)

<!-- PR description tips:
https://www.notion.so/sourcegraph/Write-a-good-pull-request-description-610a7fd3e613496eb76f450db5a49b6e
-->

Resolve:
[https://linear.app/sourcegraph/issue/REL-253/bug-automate-the-stitched-migration-graph-bazel-archive-generation](https://linear.app/sourcegraph/issue/REL-253/bug-automate-the-stitched-migration-graph-bazel-archive-generation)

## Test plan
Tested by running `go run ./dev/sg release cut --version “5.7.0"`

<!-- REQUIRED; info at
https://docs-legacy.sourcegraph.com/dev/background-information/testing_principles
-->

## Changelog

<!-- OPTIONAL; info at
https://www.notion.so/sourcegraph/Writing-a-changelog-entry-dd997f411d524caabf0d8d38a24a878c
-->

---------

Co-authored-by: Anish Lakhwara <anish+git@lakhwara.com>
Co-authored-by: Anish Lakhwara <anish+github@lakhwara.com>

Author: DaedalusG

dev/sg/internal/release/cut.go

@@ -1,18 +1,22 @@
 package release
 
 import (
+	"context"
 	"fmt"
 	"os/exec"
+	"strings"
 
-	"github.com/Masterminds/semver"
+	"github.com/grafana/regexp"
 	"github.com/urfave/cli/v2"
-	"strings"
 
-	"github.com/sourcegraph/sourcegraph/dev/sg/internal/execute"
-	"github.com/sourcegraph/sourcegraph/dev/sg/internal/repo"
 	"github.com/sourcegraph/sourcegraph/dev/sg/internal/std"
 	"github.com/sourcegraph/sourcegraph/lib/errors"
 	"github.com/sourcegraph/sourcegraph/lib/output"
+
+	"github.com/sourcegraph/run"
+
+	"github.com/sourcegraph/sourcegraph/dev/sg/internal/execute"
+	"github.com/sourcegraph/sourcegraph/dev/sg/internal/repo"
 )
 
 func cutReleaseBranch(cctx *cli.Context) error {
@@ -24,48 +28,57 @@ func cutReleaseBranch(cctx *cli.Context) error {
 	}
 	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Using GitHub CLI at %q", ghPath))
 
-	var version string
-	if cctx.String("version") == "auto" {
-		var err error
-		version, err = determineNextReleaseVersion(cctx.Context)
-		if err != nil {
-			return err
-		}
-	} else {
-		// Normalize the version string, to prevent issues where this was given with the wrong convention
-		// which requires a full rebuild.
-		version = fmt.Sprintf("v%s", strings.TrimPrefix(cctx.String("version"), "v"))
-	}
-	v, err := semver.NewVersion(version)
-	if err != nil {
-		return errors.Newf("invalid version %q, must be semver", version)
-	}
-
-	releaseBranch := v.String()
+	// Check that main has been pulled to the local branch
 	defaultBranch := cctx.String("branch")
-
-	ctx := cctx.Context
-	releaseGitRepoBranch := repo.NewGitRepo(releaseBranch, releaseBranch)
 	defaultGitRepoBranch := repo.NewGitRepo(defaultBranch, defaultBranch)
-
-	if ok, err := defaultGitRepoBranch.IsDirty(ctx); err != nil {
-		return errors.Wrap(err, "check if current branch is dirty")
+	p = std.Out.Pending(output.Styled(output.StylePending, "Checking if the default branch exists locally..."))
+	if err := defaultGitRepoBranch.Checkout(cctx.Context); err != nil {
+		p.Destroy()
+		return errors.Wrapf(err, "checking out %q", defaultBranch)
+	}
+	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Default branch exists locally"))
+	p = std.Out.Pending(output.Styled(output.StylePending, "Checking if the default branch is up to date with remote ..."))
+	if _, err := defaultGitRepoBranch.FetchOrigin(cctx.Context); err != nil {
+		p.Destroy()
+		return errors.Wrapf(err, "fetching origin for %q", defaultBranch)
+	}
+	if ok, err := defaultGitRepoBranch.IsOutOfSync(cctx.Context); err != nil {
+		p.Destroy()
+		return errors.Wrapf(err, "checking if %q branch is up to date with remote", defaultBranch)
 	} else if ok {
-		return errors.Newf("current branch is dirty. please commit your unstaged changes")
+		p.Destroy()
+		return errors.Newf("local branch %q is not up to date with remote", defaultBranch)
 	}
+	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Local branch is up to date with remote"))
 
+	// Normalize the version string, to prevent issues where this was given with the wrong convention
+	// which requires a full rebuild.
+	version := fmt.Sprintf("v%s", strings.TrimPrefix(cctx.String("version"), "v"))
+	if !regexp.MustCompile("\\d+\\.\\d+\\.0$").MatchString(version) {
+		return errors.Newf("invalid version input %q, must be of the form X.Y.0", version)
+	}
+	releaseBranch := strings.TrimPrefix(strings.Replace(version, ".0", ".x", 1), "v")
+
+	// Ensure release branch conforms to release process policy
+	if !regexp.MustCompile("\\d+\\.\\d+\\.x$").MatchString(releaseBranch) {
+		return errors.Newf("invalid branch name %q, must be of the form X.Y.x", releaseBranch)
+	}
+
+	// Check that the branch doesn't exist locally
+	releaseGitRepoBranch := repo.NewGitRepo(releaseBranch, releaseBranch)
 	p = std.Out.Pending(output.Styled(output.StylePending, "Checking if the release branch exists locally ..."))
-	if ok, err := releaseGitRepoBranch.HasLocalBranch(ctx); err != nil {
+	if ok, err := releaseGitRepoBranch.HasLocalBranch(cctx.Context); err != nil {
 		p.Destroy()
-		return errors.Wrapf(err, "checking if %q branch exists localy", releaseBranch)
+		return errors.Wrapf(err, "checking if %q branch exists locally", releaseBranch)
 	} else if ok {
 		p.Destroy()
 		return errors.Newf("branch %q exists locally", releaseBranch)
 	}
 	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Release branch %q does not exist locally", releaseBranch))
 
+	// Check the remote doesn't have the new release branch already
 	p = std.Out.Pending(output.Styled(output.StylePending, "Checking if the release branch exists in remote ..."))
-	if ok, err := releaseGitRepoBranch.HasRemoteBranch(ctx); err != nil {
+	if ok, err := releaseGitRepoBranch.HasRemoteBranch(cctx.Context); err != nil {
 		p.Destroy()
 		return errors.Wrapf(err, "checking if %q branch exists in remote repo", releaseBranch)
 	} else if ok {
@@ -74,43 +87,61 @@ func cutReleaseBranch(cctx *cli.Context) error {
 	}
 	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Release branch %q does not exist in remote", releaseBranch))
 
-	p = std.Out.Pending(output.Styled(output.StylePending, "Checking if the default branch is up to date with remote ..."))
-	if _, err := defaultGitRepoBranch.FetchOrigin(ctx); err != nil {
-		p.Destroy()
-		return errors.Wrapf(err, "fetching origin for %q", defaultBranch)
+	// Checkout and push release branch
+	err = releaseGitRepoBranch.CheckoutNewBranch(cctx.Context)
+	if err != nil {
+		return errors.Wrapf(err, "could not checkout release branch %q", releaseBranch)
+	}
+	_, err = releaseGitRepoBranch.Push(cctx.Context)
+	if err != nil {
+		return errors.Wrapf(err, "could not push release branch %q", releaseBranch)
 	}
 
-	if err := defaultGitRepoBranch.Checkout(ctx); err != nil {
+	// generate max string const and migration graph
+	p = std.Out.Pending(output.Styled(output.StylePending, "Increasing max version number const"))
+	err = replaceMaxVersion(cctx.Context, version)
+	if err != nil {
 		p.Destroy()
-		return errors.Wrapf(err, "checking out %q", defaultBranch)
+		return err
 	}
+	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Max version number increased"))
 
-	if ok, err := defaultGitRepoBranch.IsOutOfSync(ctx); err != nil {
-		p.Destroy()
-		return errors.Wrapf(err, "checking if %q branch is up to date with remote", defaultBranch)
-	} else if ok {
+	p = std.Out.Pending(output.Styled(output.StylePending, "Generating stitched migration graph"))
+	err = genStitchMigrationGraph(cctx.Context)
+	if err != nil {
 		p.Destroy()
-		return errors.Newf("local branch %q is not up to date with remote", defaultBranch)
+		return err
 	}
-	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Local branch is up to date with remote"))
+	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Stitched migration graph generated"))
 
-	p = std.Out.Pending(output.Styled(output.StylePending, "Creating release branch..."))
-	if err := releaseGitRepoBranch.CheckoutNewBranch(ctx); err != nil {
-		p.Destroy()
-		return errors.Wrap(err, "failed to create release branch")
+	// commit changes
+	_, err = releaseGitRepoBranch.Add(cctx.Context, "internal/database/migration/shared/data/cmd/generator/consts.go")
+	if err != nil {
+		return errors.Wrap(err, "could not add consts.go to staged changes")
+	}
+	_, err = releaseGitRepoBranch.Add(cctx.Context, "internal/database/migration/shared/data/stitched-migration-graph.json")
+	if err != nil {
+		return errors.Wrap(err, "could not add stitched-migration-graph.json to staged changes")
+	}
+	_, err = releaseGitRepoBranch.Commit(cctx.Context, "chore: update max version")
+	if err != nil {
+		return errors.Wrap(err, "could not commit staged changes")
+	}
+	_, err = releaseGitRepoBranch.Push(cctx.Context)
+	if err != nil {
+		return errors.Wrap(err, "could not push staged changes")
 	}
-	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Release branch %q created", releaseBranch))
 
-	p = std.Out.Pending(output.Styled(output.StylePending, "Pushing release branch..."))
-	if _, err := releaseGitRepoBranch.Push(ctx); err != nil {
-		p.Destroy()
-		return errors.Wrap(err, "failed to push release branch")
+	// generate new stitched migration archive
+	err = genStitchMigrationArchive(cctx.Context, version)
+	if err != nil {
+		return err
 	}
-	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Release branch %q pushed", releaseBranch))
 
+	// Create backport label
 	p = std.Out.Pending(output.Styled(output.StylePending, "Creating backport label..."))
 	if _, err := execute.GH(
-		ctx,
+		cctx.Context,
 		"label",
 		"create",
 		fmt.Sprintf("backport %s", releaseBranch),
@@ -124,3 +155,40 @@ func cutReleaseBranch(cctx *cli.Context) error {
 
 	return nil
 }
+
+func replaceMaxVersion(ctx context.Context, newVersion string) error {
+	p := std.Out.Pending(output.Styled(output.StylePending, "Checking for comby CLI..."))
+	combyPath, err := exec.LookPath("comby")
+	if err != nil {
+		p.Destroy()
+		return errors.Wrap(err, "Comby (https://comby.dev/) is required for installation")
+	}
+	p.Complete(output.Linef(output.EmojiSuccess, output.StyleSuccess, "Using Comby at %q", combyPath))
+	noVNewVersion := strings.TrimPrefix(newVersion, "v")
+	err = run.Cmd(ctx, "comby", "-in-place", "\"const maxVersionString = :[1]\"", fmt.Sprintf("\"const maxVersionString = \\\"%s\\\"\"", noVNewVersion), "internal/database/migration/shared/data/cmd/generator/consts.go").Run().Wait()
+	if err != nil {
+		return errors.Wrap(err, "Could not run comby to change maxVersionString")
+	}
+	return nil
+}
+
+func genStitchMigrationGraph(ctx context.Context) error {
+	err := run.Cmd(ctx, "sg", "bazel", "run", "//internal/database/migration/shared:write_stitched_migration_graph").Run().Wait()
+	if err != nil {
+		return errors.Wrap(err, "Could not run stitch migration generator")
+	}
+	return nil
+}
+
+// TODO set timestamp during archive generation for cache
+func genStitchMigrationArchive(ctx context.Context, newVersion string) error {
+	err := run.Cmd(ctx, "git", "archive", "--format=tar.gz", "HEAD", "migrations", "-o", fmt.Sprintf("migrations-%s.tar.gz", newVersion)).Run().Wait()
+	if err != nil {
+		return errors.Wrap(err, "Could not create git archive")
+	}
+	err = run.Cmd(ctx, "CLOUDSDK_CORE_PROJECT=\"sourcegraph-ci\"", "gsutil", "cp", fmt.Sprintf("migrations-%s", newVersion), "gs://schemas-migrations/migrations/").Run().Wait()
+	if err != nil {
+		return errors.Wrap(err, "Could not push git archive to GCS")
+	}
+	return nil
+}

dev/sg/internal/release/release.go

@@ -199,7 +199,7 @@ var Command = &cli.Command{
 		},
 		{
 			Name:      "cut",
-			Usage:     "Cut a release",
+			Usage:     "Cut a minor release branch",
 			Category:  category.Util,
 			UsageText: "sg release cut",
 			Action:    cutReleaseBranch,

dev/sg/internal/repo/git_repo.go

@@ -110,6 +110,16 @@ func (g *GitRepo) IsDirty(ctx context.Context) (bool, error) {
 	return len(files) > 0, nil
 }
 
+// Add a file to staged changes
+func (g *GitRepo) Add(ctx context.Context, file string) (string, error) {
+	return run.Cmd(ctx, "git", "add", file).Run().String()
+}
+
+// Commit commits the staged changes with the given message
+func (g *GitRepo) Commit(ctx context.Context, message string) (string, error) {
+	return run.Cmd(ctx, "git", "commit", "-m", message).Run().String()
+}
+
 // Push pushes the current branch to origin using the specific push options
 func (g *GitRepo) Push(ctx context.Context, opts ...pushOpt) (string, error) {
 	cmd := []string{"git", "push", "origin", g.Branch}