blob: a7271305100b424f11788cccbf8936e186847ba7 [file] [log] [blame] [edit]
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// roll-release is a tool to roll changes in Tint release branches into Dawn,
// and create new Tint release branches.
//
// See showUsage() for more information
package main
import (
"encoding/hex"
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
"os/exec"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"dawn.googlesource.com/tint/tools/src/gerrit"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/transport"
git_http "github.com/go-git/go-git/v5/plumbing/transport/http"
"github.com/go-git/go-git/v5/storage/memory"
)
const (
toolName = "roll-release"
gitCommitMsgHookURL = "https://gerrit-review.googlesource.com/tools/hooks/commit-msg"
tintURL = "https://dawn.googlesource.com/tint"
dawnURL = "https://dawn.googlesource.com/dawn"
tintSubdirInDawn = "third_party/tint"
branchPrefix = "chromium/"
branchLegacyCutoff = 4664 // Branch numbers < than this are ignored
)
type branches = map[string]plumbing.Hash
func main() {
if err := run(); err != nil {
fmt.Println(err)
os.Exit(1)
}
}
func showUsage() {
fmt.Printf(`
%[1]v is a tool to synchronize Dawn's release branches with Tint.
%[1]v will scan the release branches of both Dawn and Tint, and will:
* Create new Gerrit changes to roll new release branch changes from Tint into
Dawn.
* Find and create missing Tint release branches, using the git hash of Tint in
the DEPS file of the Dawn release branch.
%[1]v does not depend on the current state of the Tint checkout, nor will it
make any changes to the local checkout.
usage:
%[1]v
`, toolName)
flag.PrintDefaults()
fmt.Println(``)
os.Exit(1)
}
func run() error {
dry := false
flag.BoolVar(&dry, "dry", false, "perform a dry run")
flag.Usage = showUsage
flag.Parse()
// This tool uses a mix of 'go-git' and the command line git.
// go-git has the benefit of keeping the git information entirely in-memory,
// but has issues working with chromiums tools and gerrit.
// To create new release branches in Tint, we use 'go-git', so we need to
// dig out the username and password.
var auth transport.AuthMethod
if user, pass := gerrit.LoadCredentials(); user != "" {
auth = &git_http.BasicAuth{Username: user, Password: pass}
} else {
return fmt.Errorf("failed to fetch git credentials")
}
// Using in-memory repos, find all the tint and dawn release branches
log.Println("Inspecting dawn and tint release branches...")
var tint, dawn *git.Repository
var tintBranches, dawnBranches branches
for _, r := range []struct {
name string
url string
repo **git.Repository
branches *branches
}{
{"tint", tintURL, &tint, &tintBranches},
{"dawn", dawnURL, &dawn, &dawnBranches},
} {
repo, err := git.Init(memory.NewStorage(), nil)
if err != nil {
return fmt.Errorf("failed to create %v in-memory repo: %w", r.name, err)
}
remote, err := repo.CreateRemote(&config.RemoteConfig{
Name: "origin",
URLs: []string{r.url},
})
if err != nil {
return fmt.Errorf("failed to add %v remote: %w", r.name, err)
}
refs, err := remote.List(&git.ListOptions{})
if err != nil {
return fmt.Errorf("failed to fetch %v branches: %w", r.name, err)
}
branches := branches{}
for _, ref := range refs {
if !ref.Name().IsBranch() {
continue
}
name := ref.Name().Short()
if strings.HasPrefix(name, branchPrefix) {
branches[name] = ref.Hash()
}
}
*r.repo = repo
*r.branches = branches
}
// Find the release branches found in dawn, which are missing in tint.
// Find the release branches in dawn that are behind HEAD of the
// corresponding branch in tint.
log.Println("Scanning dawn DEPS...")
type roll struct {
from, to plumbing.Hash
}
tintBranchesToCreate := branches{} // branch name -> tint hash
dawnBranchesToRoll := map[string]roll{} // branch name -> roll
for name := range dawnBranches {
if isBranchBefore(name, branchLegacyCutoff) {
continue // Branch is earlier than we're interested in
}
deps, err := getDEPS(dawn, name)
if err != nil {
return err
}
depsTintHash, err := parseTintFromDEPS(deps)
if err != nil {
return err
}
if tintBranchHash, found := tintBranches[name]; found {
if tintBranchHash != depsTintHash {
dawnBranchesToRoll[name] = roll{from: depsTintHash, to: tintBranchHash}
}
} else {
tintBranchesToCreate[name] = depsTintHash
}
}
if dry {
tasks := []string{}
for name, sha := range tintBranchesToCreate {
tasks = append(tasks, fmt.Sprintf("Create Tint release branch '%v' @ %v", name, sha))
}
for name, roll := range dawnBranchesToRoll {
tasks = append(tasks, fmt.Sprintf("Roll Dawn release branch '%v' from %v to %v", name, roll.from, roll.to))
}
sort.Strings(tasks)
fmt.Printf("%v was run with --dry. Run without --dry to:\n", toolName)
for _, task := range tasks {
fmt.Println(" >", task)
}
return nil
}
didSomething := false
if n := len(tintBranchesToCreate); n > 0 {
log.Println("Creating", n, "release branches in tint...")
// In order to create the branches, we need to know what the DEPS
// hashes are referring to. Perform an in-memory fetch of tint's main
// branch.
if _, err := fetch(tint, "main"); err != nil {
return err
}
for name, sha := range tintBranchesToCreate {
log.Println("Creating branch", name, "@", sha, "...")
// Pushing a branch by SHA does not work, so we need to create a
// local branch first. See https://github.com/go-git/go-git/issues/105
src := plumbing.NewHashReference(plumbing.NewBranchReferenceName(name), sha)
if err := tint.Storer.SetReference(src); err != nil {
return fmt.Errorf("failed to create temporary branch: %w", err)
}
dst := plumbing.NewBranchReferenceName(name)
refspec := config.RefSpec(src.Name() + ":" + dst)
err := tint.Push(&git.PushOptions{
RefSpecs: []config.RefSpec{refspec},
Progress: os.Stdout,
Auth: auth,
})
if err != nil && err != git.NoErrAlreadyUpToDate {
return fmt.Errorf("failed to push branch: %w", err)
}
}
didSomething = true
}
if n := len(dawnBranchesToRoll); n > 0 {
log.Println("Rolling", n, "release branches in dawn...")
// Fetch the change-id hook script
commitMsgHookResp, err := http.Get(gitCommitMsgHookURL)
if err != nil {
return fmt.Errorf("failed to fetch the git commit message hook from '%v': %w", gitCommitMsgHookURL, err)
}
commitMsgHook, err := ioutil.ReadAll(commitMsgHookResp.Body)
if err != nil {
return fmt.Errorf("failed to fetch the git commit message hook from '%v': %w", gitCommitMsgHookURL, err)
}
for name, roll := range dawnBranchesToRoll {
log.Println("Rolling branch", name, "from tint", roll.from, "to", roll.to, "...")
dir, err := ioutil.TempDir("", "dawn-roll")
if err != nil {
return err
}
defer os.RemoveAll(dir)
// Clone dawn into dir
if err := call(dir, "git", "clone", "--depth", "1", "-b", name, dawnURL, "."); err != nil {
return fmt.Errorf("failed to clone dawn branch %v: %w", name, err)
}
// Copy the Change-Id hook into the dawn directory
gitHooksDir := filepath.Join(dir, ".git", "hooks")
if err := os.MkdirAll(gitHooksDir, 0777); err != nil {
return fmt.Errorf("failed create commit hooks directory: %w", err)
}
if err := ioutil.WriteFile(filepath.Join(gitHooksDir, "commit-msg"), commitMsgHook, 0777); err != nil {
return fmt.Errorf("failed install commit message hook: %w", err)
}
// Clone tint into third_party directory of dawn
tintDir := filepath.Join(dir, tintSubdirInDawn)
if err := os.MkdirAll(tintDir, 0777); err != nil {
return fmt.Errorf("failed to create directory %v: %w", tintDir, err)
}
if err := call(tintDir, "git", "clone", "-b", name, tintURL, "."); err != nil {
return fmt.Errorf("failed to clone tint hash %v: %w", roll.from, err)
}
// Checkout tint at roll.from
if err := call(tintDir, "git", "checkout", roll.from); err != nil {
return fmt.Errorf("failed to checkout tint at %v: %w", roll.from, err)
}
// Use roll-dep to roll tint to roll.to
if err := call(dir, "roll-dep", "--ignore-dirty-tree", fmt.Sprintf("--roll-to=%s", roll.to), tintSubdirInDawn); err != nil {
return err
}
// Push the change to gerrit
if err := call(dir, "git", "push", "origin", "HEAD:refs/for/"+name); err != nil {
return fmt.Errorf("failed to push roll to gerrit: %w", err)
}
}
didSomething = true
}
if !didSomething {
log.Println("Everything up to date")
} else {
log.Println("Done")
}
return nil
}
// returns true if the branch name contains a branch number less than 'version'
func isBranchBefore(name string, version int) bool {
n, err := strconv.Atoi(strings.TrimPrefix(name, branchPrefix))
if err != nil {
return false
}
return n < version
}
// call invokes the executable 'exe' with the given arguments in the working
// directory 'dir'.
func call(dir, exe string, args ...interface{}) error {
s := make([]string, len(args))
for i, a := range args {
s[i] = fmt.Sprint(a)
}
cmd := exec.Command(exe, s...)
cmd.Dir = dir
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("%v returned %v", cmd, err)
}
return nil
}
// getDEPS returns the content of the DEPS file for the given branch.
func getDEPS(r *git.Repository, branch string) (string, error) {
hash, err := fetch(r, branch)
if err != nil {
return "", err
}
commit, err := r.CommitObject(hash)
if err != nil {
return "", fmt.Errorf("failed to fetch commit: %w", err)
}
tree, err := commit.Tree()
if err != nil {
return "", fmt.Errorf("failed to fetch tree: %w", err)
}
deps, err := tree.File("DEPS")
if err != nil {
return "", fmt.Errorf("failed to find DEPS: %w", err)
}
return deps.Contents()
}
// fetch performs a git-fetch of the given branch into 'r', returning the
// fetched branch's hash.
func fetch(r *git.Repository, branch string) (plumbing.Hash, error) {
src := plumbing.NewBranchReferenceName(branch)
dst := plumbing.NewRemoteReferenceName("origin", branch)
err := r.Fetch(&git.FetchOptions{
RefSpecs: []config.RefSpec{config.RefSpec("+" + src + ":" + dst)},
})
if err != nil {
return plumbing.Hash{}, fmt.Errorf("failed to fetch branch %v: %w", branch, err)
}
ref, err := r.Reference(plumbing.ReferenceName(dst), true)
if err != nil {
return plumbing.Hash{}, fmt.Errorf("failed to resolve branch %v: %w", branch, err)
}
return ref.Hash(), nil
}
var reDEPSTintVersion = regexp.MustCompile("tint@([0-9a-fA-F]*)")
// parseTintFromDEPS returns the tint hash from the DEPS file content 'deps'
func parseTintFromDEPS(deps string) (plumbing.Hash, error) {
m := reDEPSTintVersion.FindStringSubmatch(deps)
if len(m) != 2 {
return plumbing.Hash{}, fmt.Errorf("failed to find tint hash in DEPS")
}
b, err := hex.DecodeString(m[1])
if err != nil {
return plumbing.Hash{}, fmt.Errorf("failed to find parse tint hash in DEPS: %w", err)
}
var h plumbing.Hash
copy(h[:], b)
return h, nil
}