blob: 68e30a8dd4f5d2516ecba321d877ec666578c8fc [file] [log] [blame]
// 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
}