internal/task/version.go - build - Git at Google

 // 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 (
 	"context"
 	"errors"
 	"fmt"
 	"go/ast"
 	"go/parser"
 	"go/token"
 	"strconv"
 	"strings"
 	"time"

 	"golang.org/x/build/gerrit"
 	"golang.org/x/build/internal/workflow"
 )

 // VersionTasks contains tasks related to versioning the release.
 type VersionTasks struct {
 	Gerrit     GerritClient
 	CloudBuild CloudBuildClient
 	GoProject  string
 	UpdateProxyTestRepoTasks
 }

 // GetCurrentMajor returns the most recent major Go version, and the time at
 // which its tag was created.
 func (t *VersionTasks) GetCurrentMajor(ctx context.Context) (int, time.Time, error) {
 	_, currentMajor, currentMajorTag, err := t.tagInfo(ctx)
 	if err != nil {
 		return 0, time.Time{}, err
 	}
 	info, err := t.Gerrit.GetTag(ctx, t.GoProject, currentMajorTag)
 	if err != nil {
 		return 0, time.Time{}, err
 	}
 	return currentMajor, info.Created.Time(), nil
 }

 func (t *VersionTasks) tagInfo(ctx context.Context) (tags map[string]bool, currentMajor int, currentMajorTag string, _ error) {
 	tagList, err := t.Gerrit.ListTags(ctx, t.GoProject)
 	if err != nil {
 		return nil, 0, "", err
 	}
 	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.
 	for currentMajor := 100; currentMajor > 0; currentMajor-- {
 		base := fmt.Sprintf("go1.%d", currentMajor)
 		// Handle either go1.20 or go1.21.0.
 		for _, tag := range []string{base, base + ".0"} {
 			if tags[tag] {
 				return tags, currentMajor, tag, nil
 			}
 		}
 	}
 	return nil, 0, "", fmt.Errorf("couldn't find the most recently released major version out of %d tags", len(tagList))
 }

 // GetNextMinorVersions returns the next minor for each of the given major series.
 // It uses the same format as Go tags (for example, "go1.23.4").
 func (t *VersionTasks) GetNextMinorVersions(ctx context.Context, majors []int) ([]string, error) {
 	var next []string
 	for _, major := range majors {
 		n, err := t.GetNextVersion(ctx, major, KindMinor)
 		if err != nil {
 			return nil, err
 		}
 		next = append(next, n)
 	}
 	return next, nil
 }

 // GetNextVersion returns the next for the given major series and kind of release.
 // It uses the same format as Go tags (for example, "go1.23.4").
 func (t *VersionTasks) GetNextVersion(ctx context.Context, major int, kind ReleaseKind) (string, error) {
 	tags, _, _, err := t.tagInfo(ctx)
 	if err != nil {
 		return "", err
 	}
 	findUnused := func(v string) (string, error) {
 		for {
 			if !tags[v] {
 				return v, nil
 			}
 			v, err = nextVersion(v)
 			if err != nil {
 				return "", err
 			}
 		}
 	}
 	switch kind {
 	case KindMinor:
 		return findUnused(fmt.Sprintf("go1.%d.1", major))
 	case KindBeta:
 		return findUnused(fmt.Sprintf("go1.%dbeta1", major))
 	case KindRC:
 		return findUnused(fmt.Sprintf("go1.%drc1", major))
 	case KindMajor:
 		return fmt.Sprintf("go1.%d.0", major), nil
 	default:
 		return "", fmt.Errorf("unknown release kind %v", kind)
 	}
 }

 // GetDevelVersion returns the current major Go 1.x version in development.
 //
 // This value is determined by reading the value of the Version constant in
 // the internal/goversion package of the main Go repository at HEAD commit.
 func (t *VersionTasks) GetDevelVersion(ctx context.Context) (int, error) {
 	mainBranch, err := t.Gerrit.ReadBranchHead(ctx, t.GoProject, "HEAD")
 	if err != nil {
 		return 0, err
 	}
 	tipCommit, err := t.Gerrit.ReadBranchHead(ctx, t.GoProject, mainBranch)
 	if err != nil {
 		return 0, err
 	}
 	// Fetch the goversion.go file, extract the declaration from the parsed AST.
 	//
 	// This is a pragmatic approach that relies on the trajectory of the
 	// internal/goversion package being predictable and unlikely to change.
 	// If that stops being true, this implementation is easy to re-write.
 	const goversionPath = "src/internal/goversion/goversion.go"
 	b, err := t.Gerrit.ReadFile(ctx, t.GoProject, tipCommit, goversionPath)
 	if errors.Is(err, gerrit.ErrResourceNotExist) {
 		return 0, fmt.Errorf("did not find goversion.go file (%v); possibly the internal/goversion package changed (as it's permitted to)", err)
 	} else if err != nil {
 		return 0, err
 	}
 	f, err := parser.ParseFile(token.NewFileSet(), goversionPath, b, 0)
 	if err != nil {
 		return 0, err
 	}
 	for _, d := range f.Decls {
 		g, ok := d.(*ast.GenDecl)
 		if !ok {
 			continue
 		}
 		for _, s := range g.Specs {
 			v, ok := s.(*ast.ValueSpec)
 			if !ok || len(v.Names) != 1 || v.Names[0].String() != "Version" || len(v.Values) != 1 {
 				continue
 			}
 			l, ok := v.Values[0].(*ast.BasicLit)
 			if !ok || l.Kind != token.INT {
 				continue
 			}
 			return strconv.Atoi(l.Value)
 		}
 	}
 	return 0, fmt.Errorf("did not find Version declaration in %s; possibly the internal/goversion package changed (as it's permitted to)", goversionPath)
 }

 func nextVersion(version string) (string, error) {
 	lastNonDigit := strings.LastIndexFunc(version, func(r rune) bool {
 		return r < '0' || r > '9'
 	})
 	if lastNonDigit == -1 || len(version) == lastNonDigit {
 		return "", fmt.Errorf("malformatted Go version %q", version)
 	}
 	n, err := strconv.Atoi(version[lastNonDigit+1:])
 	if err != nil {
 		return "", fmt.Errorf("malformatted Go version %q (%v)", version, err)
 	}
 	return fmt.Sprintf("%s%d", version[:lastNonDigit+1], n+1), nil
 }

 func (t *VersionTasks) GenerateVersionFile(_ *workflow.TaskContext, distpack bool, version string, timestamp time.Time) (string, error) {
 	if !distpack {
 		return version, nil
 	}
 	return fmt.Sprintf("%v\ntime %v\n", version, timestamp.Format(time.RFC3339)), nil
 }

 // CreateAutoSubmitVersionCL mails an auto-submit change to update VERSION file on branch.
 func (t *VersionTasks) CreateAutoSubmitVersionCL(ctx *workflow.TaskContext, branch, version string, reviewers []string, versionFile string) (string, error) {
 	return t.Gerrit.CreateAutoSubmitChange(ctx, gerrit.ChangeInput{
 		Project: t.GoProject,
 		Branch:  branch,
 		Subject: fmt.Sprintf("[%v] %v", branch, version),
 	}, reviewers, map[string]string{
 		"VERSION": versionFile,
 	})
 }

 // AwaitCL waits for the specified CL to be submitted, and returns the new
 // branch head. Callers can pass baseCommit, the current branch head, to verify
 // that no CLs were submitted between when the CL was created and when it was
 // merged. If changeID is blank because the intended CL was a no-op, baseCommit
 // is returned immediately.
 func (t *VersionTasks) AwaitCL(ctx *workflow.TaskContext, changeID, baseCommit string) (string, error) {
 	if changeID == "" {
 		ctx.Printf("No CL was necessary")
 		return baseCommit, nil
 	}

 	ctx.Printf("Awaiting review/submit of %v", ChangeLink(changeID))
 	return AwaitCondition(ctx, 10*time.Second, func() (string, bool, error) {
 		return t.Gerrit.Submitted(ctx, changeID, baseCommit)
 	})
 }

 // ReadBranchHead returns the current HEAD revision of branch.
 func (t *VersionTasks) ReadBranchHead(ctx *workflow.TaskContext, branch string) (string, error) {
 	return t.Gerrit.ReadBranchHead(ctx, t.GoProject, branch)
 }

 // TagRelease tags commit as version.
 func (t *VersionTasks) TagRelease(ctx *workflow.TaskContext, version, commit string) error {
 	return t.Gerrit.Tag(ctx, t.GoProject, version, commit)
 }

 func (t *VersionTasks) CreateUpdateStdlibIndexCL(ctx *workflow.TaskContext, reviewers []string, version string) (string, error) {
 	build, err := t.CloudBuild.RunScript(ctx, "go generate ./internal/imports", "tools", []string{"internal/imports/zstdlib.go"})
 	if err != nil {
 		return "", err
 	}

 	files, err := buildToOutputs(ctx, t.CloudBuild, build)
 	if err != nil {
 		return "", err
 	}

 	changeInput := gerrit.ChangeInput{
 		Project: "tools",
 		Subject: fmt.Sprintf("internal/imports: update stdlib index for %s\n\nFor golang/go#38706.", strings.Replace(version, "go", "Go ", 1)),
 		Branch:  "master",
 	}
 	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{}{}, nil
 	}
 	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
 }
	// 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 (
	"context"
	"errors"
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"strconv"
	"strings"
	"time"

	"golang.org/x/build/gerrit"
	"golang.org/x/build/internal/workflow"
	)

	// VersionTasks contains tasks related to versioning the release.
	type VersionTasks struct {
	Gerrit GerritClient
	CloudBuild CloudBuildClient
	GoProject string
	UpdateProxyTestRepoTasks
	}

	// GetCurrentMajor returns the most recent major Go version, and the time at
	// which its tag was created.
	func (t *VersionTasks) GetCurrentMajor(ctx context.Context) (int, time.Time, error) {
	_, currentMajor, currentMajorTag, err := t.tagInfo(ctx)
	if err != nil {
	return 0, time.Time{}, err
	}
	info, err := t.Gerrit.GetTag(ctx, t.GoProject, currentMajorTag)
	if err != nil {
	return 0, time.Time{}, err
	}
	return currentMajor, info.Created.Time(), nil
	}

	func (t *VersionTasks) tagInfo(ctx context.Context) (tags map[string]bool, currentMajor int, currentMajorTag string, _ error) {
	tagList, err := t.Gerrit.ListTags(ctx, t.GoProject)
	if err != nil {
	return nil, 0, "", err
	}
	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.
	for currentMajor := 100; currentMajor > 0; currentMajor-- {
	base := fmt.Sprintf("go1.%d", currentMajor)
	// Handle either go1.20 or go1.21.0.
	for _, tag := range []string{base, base + ".0"} {
	if tags[tag] {
	return tags, currentMajor, tag, nil
	}
	}
	}
	return nil, 0, "", fmt.Errorf("couldn't find the most recently released major version out of %d tags", len(tagList))
	}

	// GetNextMinorVersions returns the next minor for each of the given major series.
	// It uses the same format as Go tags (for example, "go1.23.4").
	func (t *VersionTasks) GetNextMinorVersions(ctx context.Context, majors []int) ([]string, error) {
	var next []string
	for _, major := range majors {
	n, err := t.GetNextVersion(ctx, major, KindMinor)
	if err != nil {
	return nil, err
	}
	next = append(next, n)
	}
	return next, nil
	}

	// GetNextVersion returns the next for the given major series and kind of release.
	// It uses the same format as Go tags (for example, "go1.23.4").
	func (t *VersionTasks) GetNextVersion(ctx context.Context, major int, kind ReleaseKind) (string, error) {
	tags, _, _, err := t.tagInfo(ctx)
	if err != nil {
	return "", err
	}
	findUnused := func(v string) (string, error) {
	for {
	if !tags[v] {
	return v, nil
	}
	v, err = nextVersion(v)
	if err != nil {
	return "", err
	}
	}
	}
	switch kind {
	case KindMinor:
	return findUnused(fmt.Sprintf("go1.%d.1", major))
	case KindBeta:
	return findUnused(fmt.Sprintf("go1.%dbeta1", major))
	case KindRC:
	return findUnused(fmt.Sprintf("go1.%drc1", major))
	case KindMajor:
	return fmt.Sprintf("go1.%d.0", major), nil
	default:
	return "", fmt.Errorf("unknown release kind %v", kind)
	}
	}

	// GetDevelVersion returns the current major Go 1.x version in development.
	//
	// This value is determined by reading the value of the Version constant in
	// the internal/goversion package of the main Go repository at HEAD commit.
	func (t *VersionTasks) GetDevelVersion(ctx context.Context) (int, error) {
	mainBranch, err := t.Gerrit.ReadBranchHead(ctx, t.GoProject, "HEAD")
	if err != nil {
	return 0, err
	}
	tipCommit, err := t.Gerrit.ReadBranchHead(ctx, t.GoProject, mainBranch)
	if err != nil {
	return 0, err
	}
	// Fetch the goversion.go file, extract the declaration from the parsed AST.
	//
	// This is a pragmatic approach that relies on the trajectory of the
	// internal/goversion package being predictable and unlikely to change.
	// If that stops being true, this implementation is easy to re-write.
	const goversionPath = "src/internal/goversion/goversion.go"
	b, err := t.Gerrit.ReadFile(ctx, t.GoProject, tipCommit, goversionPath)
	if errors.Is(err, gerrit.ErrResourceNotExist) {
	return 0, fmt.Errorf("did not find goversion.go file (%v); possibly the internal/goversion package changed (as it's permitted to)", err)
	} else if err != nil {
	return 0, err
	}
	f, err := parser.ParseFile(token.NewFileSet(), goversionPath, b, 0)
	if err != nil {
	return 0, err
	}
	for _, d := range f.Decls {
	g, ok := d.(*ast.GenDecl)
	if !ok {
	continue
	}
	for _, s := range g.Specs {
	v, ok := s.(*ast.ValueSpec)
	if !ok \|\| len(v.Names) != 1 \|\| v.Names[0].String() != "Version" \|\| len(v.Values) != 1 {
	continue
	}
	l, ok := v.Values[0].(*ast.BasicLit)
	if !ok \|\| l.Kind != token.INT {
	continue
	}
	return strconv.Atoi(l.Value)
	}
	}
	return 0, fmt.Errorf("did not find Version declaration in %s; possibly the internal/goversion package changed (as it's permitted to)", goversionPath)
	}

	func nextVersion(version string) (string, error) {
	lastNonDigit := strings.LastIndexFunc(version, func(r rune) bool {
	return r < '0' \|\| r > '9'
	})
	if lastNonDigit == -1 \|\| len(version) == lastNonDigit {
	return "", fmt.Errorf("malformatted Go version %q", version)
	}
	n, err := strconv.Atoi(version[lastNonDigit+1:])
	if err != nil {
	return "", fmt.Errorf("malformatted Go version %q (%v)", version, err)
	}
	return fmt.Sprintf("%s%d", version[:lastNonDigit+1], n+1), nil
	}

	func (t VersionTasks) GenerateVersionFile(_ workflow.TaskContext, distpack bool, version string, timestamp time.Time) (string, error) {
	if !distpack {
	return version, nil
	}
	return fmt.Sprintf("%v\ntime %v\n", version, timestamp.Format(time.RFC3339)), nil
	}

	// CreateAutoSubmitVersionCL mails an auto-submit change to update VERSION file on branch.
	func (t VersionTasks) CreateAutoSubmitVersionCL(ctx workflow.TaskContext, branch, version string, reviewers []string, versionFile string) (string, error) {
	return t.Gerrit.CreateAutoSubmitChange(ctx, gerrit.ChangeInput{
	Project: t.GoProject,
	Branch: branch,
	Subject: fmt.Sprintf("[%v] %v", branch, version),
	}, reviewers, map[string]string{
	"VERSION": versionFile,
	})
	}

	// AwaitCL waits for the specified CL to be submitted, and returns the new
	// branch head. Callers can pass baseCommit, the current branch head, to verify
	// that no CLs were submitted between when the CL was created and when it was
	// merged. If changeID is blank because the intended CL was a no-op, baseCommit
	// is returned immediately.
	func (t VersionTasks) AwaitCL(ctx workflow.TaskContext, changeID, baseCommit string) (string, error) {
	if changeID == "" {
	ctx.Printf("No CL was necessary")
	return baseCommit, nil
	}

	ctx.Printf("Awaiting review/submit of %v", ChangeLink(changeID))
	return AwaitCondition(ctx, 10*time.Second, func() (string, bool, error) {
	return t.Gerrit.Submitted(ctx, changeID, baseCommit)
	})
	}

	// ReadBranchHead returns the current HEAD revision of branch.
	func (t VersionTasks) ReadBranchHead(ctx workflow.TaskContext, branch string) (string, error) {
	return t.Gerrit.ReadBranchHead(ctx, t.GoProject, branch)
	}

	// TagRelease tags commit as version.
	func (t VersionTasks) TagRelease(ctx workflow.TaskContext, version, commit string) error {
	return t.Gerrit.Tag(ctx, t.GoProject, version, commit)
	}

	func (t VersionTasks) CreateUpdateStdlibIndexCL(ctx workflow.TaskContext, reviewers []string, version string) (string, error) {
	build, err := t.CloudBuild.RunScript(ctx, "go generate ./internal/imports", "tools", []string{"internal/imports/zstdlib.go"})
	if err != nil {
	return "", err
	}

	files, err := buildToOutputs(ctx, t.CloudBuild, build)
	if err != nil {
	return "", err
	}

	changeInput := gerrit.ChangeInput{
	Project: "tools",
	Subject: fmt.Sprintf("internal/imports: update stdlib index for %s\n\nFor golang/go#38706.", strings.Replace(version, "go", "Go ", 1)),
	Branch: "master",
	}
	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{}{}, nil
	}
	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
	}