restic/helpers/prepare-release/main.go

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
	"time"

	"github.com/spf13/pflag"
)

var opts = struct {
	Version string

	IgnoreBranchName           bool
	IgnoreUncommittedChanges   bool
	IgnoreChangelogVersion     bool
	IgnoreChangelogReleaseDate bool
	IgnoreChangelogCurrent     bool
	IgnoreDockerBuildGoVersion bool

	OutputDir string
}{}

var versionRegex = regexp.MustCompile(`^\d+\.\d+\.\d+$`)

func init() {
	pflag.BoolVar(&opts.IgnoreBranchName, "ignore-branch-name", false, "allow releasing from other branches as 'master'")
	pflag.BoolVar(&opts.IgnoreUncommittedChanges, "ignore-uncommitted-changes", false, "allow uncommitted changes")
	pflag.BoolVar(&opts.IgnoreChangelogVersion, "ignore-changelog-version", false, "ignore missing entry in CHANGELOG.md")
	pflag.BoolVar(&opts.IgnoreChangelogReleaseDate, "ignore-changelog-release-date", false, "ignore missing subdir with date in changelog/")
	pflag.BoolVar(&opts.IgnoreChangelogCurrent, "ignore-changelog-current", false, "ignore check if CHANGELOG.md is up to date")
	pflag.BoolVar(&opts.IgnoreDockerBuildGoVersion, "ignore-docker-build-go-version", false, "ignore check if docker builder go version is up to date")

	pflag.StringVar(&opts.OutputDir, "output-dir", "", "use `dir` as output directory")

	pflag.Parse()
}

func die(f string, args ...interface{}) {
	if !strings.HasSuffix(f, "\n") {
		f += "\n"
	}
	f = "\x1b[31m" + f + "\x1b[0m"
	fmt.Fprintf(os.Stderr, f, args...)
	os.Exit(1)
}

func msg(f string, args ...interface{}) {
	if !strings.HasSuffix(f, "\n") {
		f += "\n"
	}
	f = "\x1b[32m" + f + "\x1b[0m"
	fmt.Printf(f, args...)
}

func run(cmd string, args ...string) {
	c := exec.Command(cmd, args...)
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr
	err := c.Run()
	if err != nil {
		die("error running %s %s: %v", cmd, args, err)
	}
}

func replace(filename, from, to string) {
	reg := regexp.MustCompile(from)

	buf, err := os.ReadFile(filename)
	if err != nil {
		die("error reading file %v: %v", filename, err)
	}

	buf = reg.ReplaceAll(buf, []byte(to))
	err = os.WriteFile(filename, buf, 0644)
	if err != nil {
		die("error writing file %v: %v", filename, err)
	}
}

func rm(file string) {
	err := os.Remove(file)
	if err != nil {
		die("error removing %v: %v", file, err)
	}
}

func rmdir(dir string) {
	err := os.RemoveAll(dir)
	if err != nil {
		die("error removing %v: %v", dir, err)
	}
}

func mkdir(dir string) {
	err := os.Mkdir(dir, 0755)
	if err != nil {
		die("mkdir %v: %v", dir, err)
	}
}

func getwd() string {
	pwd, err := os.Getwd()
	if err != nil {
		die("Getwd(): %v", err)
	}
	return pwd
}

func uncommittedChanges(dirs ...string) string {
	args := []string{"status", "--porcelain", "--untracked-files=no"}
	if len(dirs) > 0 {
		args = append(args, dirs...)
	}

	changes, err := exec.Command("git", args...).Output()
	if err != nil {
		die("unable to run command: %v", err)
	}

	return string(changes)
}

func preCheckBranchMaster() {
	if opts.IgnoreBranchName {
		return
	}

	branch, err := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD").Output()
	if err != nil {
		die("error running 'git': %v", err)
	}

	if strings.TrimSpace(string(branch)) != "master" {
		die("wrong branch: %s", branch)
	}
}

func preCheckUncommittedChanges() {
	if opts.IgnoreUncommittedChanges {
		return
	}

	changes := uncommittedChanges()
	if len(changes) > 0 {
		die("uncommitted changes found:\n%s\n", changes)
	}
}

func preCheckVersionExists() {
	buf, err := exec.Command("git", "tag", "-l").Output()
	if err != nil {
		die("error running 'git tag -l': %v", err)
	}

	sc := bufio.NewScanner(bytes.NewReader(buf))
	for sc.Scan() {
		if sc.Err() != nil {
			die("error scanning version tags: %v", sc.Err())
		}

		if strings.TrimSpace(sc.Text()) == "v"+opts.Version {
			die("tag v%v already exists", opts.Version)
		}
	}
}

func preCheckChangelogCurrent() {
	if opts.IgnoreChangelogCurrent {
		return
	}

	// regenerate changelog
	run("calens", "--output", "CHANGELOG.md")

	// check for uncommitted changes in changelog
	if len(uncommittedChanges("CHANGELOG.md")) > 0 {
		msg("committing file CHANGELOG.md")
		run("git", "commit", "-m", fmt.Sprintf("Generate CHANGELOG.md for %v", opts.Version), "CHANGELOG.md")
	}
}

func preCheckChangelogRelease() bool {
	if opts.IgnoreChangelogReleaseDate {
		return true
	}

	for _, name := range readdir("changelog") {
		if strings.HasPrefix(name, opts.Version+"_") {
			return true
		}
	}

	return false
}

func createChangelogRelease() {
	date := time.Now().Format("2006-01-02")
	targetDir := filepath.Join("changelog", fmt.Sprintf("%s_%s", opts.Version, date))
	unreleasedDir := filepath.Join("changelog", "unreleased")
	mkdir(targetDir)

	for _, name := range readdir(unreleasedDir) {
		if name == ".gitignore" {
			continue
		}

		src := filepath.Join("changelog", "unreleased", name)
		dest := filepath.Join(targetDir, name)

		err := os.Rename(src, dest)
		if err != nil {
			die("rename %v -> %v failed: %w", src, dest, err)
		}
	}

	run("git", "add", targetDir)
	run("git", "add", "-u", unreleasedDir)

	msg := fmt.Sprintf("Prepare changelog for %v", opts.Version)
	run("git", "commit", "-m", msg, targetDir, unreleasedDir)
}

func preCheckChangelogVersion() {
	if opts.IgnoreChangelogVersion {
		return
	}

	f, err := os.Open("CHANGELOG.md")
	if err != nil {
		die("unable to open CHANGELOG.md: %v", err)
	}
	defer func() {
		_ = f.Close()
	}()

	sc := bufio.NewScanner(f)
	for sc.Scan() {
		if sc.Err() != nil {
			die("error scanning: %v", sc.Err())
		}

		if strings.Contains(strings.TrimSpace(sc.Text()), fmt.Sprintf("Changelog for restic %v", opts.Version)) {
			return
		}
	}

	die("CHANGELOG.md does not contain version %v", opts.Version)
}

func preCheckDockerBuilderGoVersion() {
	if opts.IgnoreDockerBuildGoVersion {
		return
	}

	buf, err := exec.Command("go", "version").Output()
	if err != nil {
		die("unable to check local Go version: %v", err)
	}
	localVersion := strings.TrimSpace(string(buf))

	msg("update docker container restic/builder")
	run("docker", "pull", "restic/builder")
	buf, err = exec.Command("docker", "run", "--rm", "restic/builder", "go", "version").Output()
	if err != nil {
		die("unable to check Go version in docker image: %v", err)
	}
	containerVersion := strings.TrimSpace(string(buf))

	if localVersion != containerVersion {
		die("version in docker container restic/builder is different:\n  local:     %v\n  container: %v\n",
			localVersion, containerVersion)
	}
}

func generateFiles() {
	msg("generate files")
	run("go", "run", "build.go", "-o", "restic-generate.temp")

	mandir := filepath.Join("doc", "man")
	rmdir(mandir)
	mkdir(mandir)
	run("./restic-generate.temp", "generate",
		"--man", "doc/man",
		"--zsh-completion", "doc/zsh-completion.zsh",
		"--powershell-completion", "doc/powershell-completion.ps1",
		"--fish-completion", "doc/fish-completion.fish",
		"--bash-completion", "doc/bash-completion.sh")
	rm("restic-generate.temp")

	run("git", "add", "doc")
	changes := uncommittedChanges("doc")
	if len(changes) > 0 {
		msg("committing manpages and auto-completion")
		run("git", "commit", "-m", "Update manpages and auto-completion", "doc")
	}
}

var versionPattern = `var version = ".*"`

const versionCodeFile = "cmd/restic/global.go"

func updateVersion() {
	err := os.WriteFile("VERSION", []byte(opts.Version+"\n"), 0644)
	if err != nil {
		die("unable to write version to file: %v", err)
	}

	newVersion := fmt.Sprintf("var version = %q", opts.Version)
	replace(versionCodeFile, versionPattern, newVersion)

	if len(uncommittedChanges("VERSION")) > 0 || len(uncommittedChanges(versionCodeFile)) > 0 {
		msg("committing version files")
		run("git", "commit", "-m", fmt.Sprintf("Add version for %v", opts.Version), "VERSION", versionCodeFile)
	}
}

func updateVersionDev() {
	newVersion := fmt.Sprintf(`var version = "%s-dev (compiled manually)"`, opts.Version)
	replace(versionCodeFile, versionPattern, newVersion)

	msg("committing cmd/restic/global.go with dev version")
	run("git", "commit", "-m", fmt.Sprintf("Set development version for %v", opts.Version), "VERSION", versionCodeFile)
}

func addTag() {
	tagname := "v" + opts.Version
	msg("add tag %v", tagname)
	run("git", "tag", "-a", "-s", "-m", tagname, tagname)
}

func exportTar(version, tarFilename string) {
	cmd := fmt.Sprintf("git archive --format=tar --prefix=restic-%s/ v%s | gzip -n > %s",
		version, version, tarFilename)
	run("sh", "-c", cmd)
	msg("build restic-%s.tar.gz", version)
}

func extractTar(filename, outputDir string) {
	msg("extract tar into %v", outputDir)
	c := exec.Command("tar", "xz", "--strip-components=1", "-f", filename)
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr
	c.Dir = outputDir
	err := c.Run()
	if err != nil {
		die("error extracting tar: %v", err)
	}
}

func runBuild(sourceDir, outputDir, version string) {
	msg("building binaries...")
	run("docker", "run", "--rm",
		"--volume", sourceDir+":/restic",
		"--volume", outputDir+":/output",
		"restic/builder",
		"go", "run", "helpers/build-release-binaries/main.go",
		"--version", version)
}

func readdir(dir string) []string {
	fis, err := os.ReadDir(dir)
	if err != nil {
		die("readdir %v failed: %v", dir, err)
	}

	filenames := make([]string, 0, len(fis))
	for _, fi := range fis {
		filenames = append(filenames, fi.Name())
	}
	return filenames
}

func sha256sums(inputDir, outputFile string) {
	msg("runnnig sha256sum in %v", inputDir)

	filenames := readdir(inputDir)

	f, err := os.Create(outputFile)
	if err != nil {
		die("unable to create %v: %v", outputFile, err)
	}

	c := exec.Command("sha256sum", filenames...)
	c.Stdout = f
	c.Stderr = os.Stderr
	c.Dir = inputDir

	err = c.Run()
	if err != nil {
		die("error running sha256sums: %v", err)
	}

	err = f.Close()
	if err != nil {
		die("close %v: %v", outputFile, err)
	}
}

func signFiles(filenames ...string) {
	for _, filename := range filenames {
		run("gpg", "--armor", "--detach-sign", filename)
	}
}

func updateDocker(outputDir, version string) string {
	run("docker", "buildx", "create", "--name", "restic-release-builder", "--driver", "docker-container", "--bootstrap")

	cmds := ""

	for _, tag := range []string{"restic/restic:latest", "restic/restic:" + version} {
		cmd := fmt.Sprintf("docker buildx build --builder restic-release-builder --platform linux/386,linux/amd64,linux/arm,linux/arm64 --pull --tag %q -f docker/Dockerfile.release --build-arg VERSION=%q %q", tag, version, outputDir)
		run("sh", "-c", cmd)

		cmds += cmd + " --push\n"
	}

	return cmds + "\ndocker buildx rm restic-release-builder"
}

func tempdir(prefix string) string {
	dir, err := os.MkdirTemp(getwd(), prefix)
	if err != nil {
		die("unable to create temp dir %q: %v", prefix, err)
	}
	return dir
}

func main() {
	if len(pflag.Args()) == 0 {
		die("USAGE: release-version [OPTIONS] VERSION")
	}

	opts.Version = pflag.Args()[0]
	if !versionRegex.MatchString(opts.Version) {
		die("invalid new version")
	}

	preCheckBranchMaster()
	preCheckUncommittedChanges()
	preCheckVersionExists()
	preCheckDockerBuilderGoVersion()
	if !preCheckChangelogRelease() {
		createChangelogRelease()
	}
	preCheckChangelogCurrent()
	preCheckChangelogVersion()

	if opts.OutputDir == "" {
		opts.OutputDir = tempdir("build-output-")
	}
	sourceDir := tempdir("source-")

	msg("using output dir %v", opts.OutputDir)
	msg("using source dir %v", sourceDir)

	generateFiles()
	updateVersion()
	addTag()
	updateVersionDev()

	tarFilename := filepath.Join(opts.OutputDir, fmt.Sprintf("restic-%s.tar.gz", opts.Version))
	exportTar(opts.Version, tarFilename)

	extractTar(tarFilename, sourceDir)
	runBuild(sourceDir, opts.OutputDir, opts.Version)
	rmdir(sourceDir)

	sha256sums(opts.OutputDir, filepath.Join(opts.OutputDir, "SHA256SUMS"))

	signFiles(filepath.Join(opts.OutputDir, "SHA256SUMS"), tarFilename)

	dockerCmds := updateDocker(opts.OutputDir, opts.Version)

	msg("done, output dir is %v", opts.OutputDir)

	msg("now run:\n\ngit push --tags origin master\n%s\n", dockerCmds)
}