cmd/releasebot/github.go - build - Git at Google

 // Copyright 2017 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 main

 import (
 	"context"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"

 	"github.com/google/go-github/github"
 	"golang.org/x/build/maintner"
 	"golang.org/x/build/maintner/godata"
 	"golang.org/x/oauth2"
 )

 const (
 	projectOwner = "golang"
 	projectRepo  = "go"
 )

 var githubClient *github.Client

 // GitHub personal access token, from https://github.com/settings/applications.
 var githubAuthToken string

 var goRepo *maintner.GitHubRepo

 func loadMaintner() {
 	corpus, err := godata.Get(context.Background())
 	if err != nil {
 		log.Fatal("failed to load maintner data:", err)
 	}
 	goRepo = corpus.GitHub().Repo(projectOwner, projectRepo)
 }

 func loadGithubAuth() {
 	const short = ".github-issue-token"
 	filename := filepath.Clean(os.Getenv("HOME") + "/" + short)
 	shortFilename := filepath.Clean("$HOME/" + short)
 	data, err := ioutil.ReadFile(filename)
 	if err != nil {
 		log.Fatal("reading token: ", err, "\n\n"+
 			"Please create a personal access token at https://github.com/settings/tokens/new\n"+
 			"and write it to ", shortFilename, " to use this program.\n"+
 			"** The token only needs the public_repo scope. **\n"+
 			"The benefit of using a personal access token over using your GitHub\n"+
 			"password directly is that you can limit its use and revoke it at any time.\n\n")
 	}
 	fi, err := os.Stat(filename)
 	if err != nil {
 		log.Fatalln("reading token:", err)
 	}
 	if fi.Mode()&0077 != 0 {
 		log.Fatalf("reading token: %s mode is %#o, want %#o", shortFilename, fi.Mode()&0777, fi.Mode()&0700)
 	}
 	githubAuthToken = strings.TrimSpace(string(data))
 	t := &oauth2.Transport{
 		Source: &tokenSource{AccessToken: githubAuthToken},
 	}
 	githubClient = github.NewClient(&http.Client{Transport: t})
 }

 // releaseStatusTitle returns the title of the release status issue
 // for the given milestone.
 // If you change this function, releasebot will not be able to find an
 // existing tracking issue using the old name and will create a new one.
 func (w *Work) releaseStatusTitle() string {
 	return "all: " + strings.Replace(w.Version, "go", "Go ", -1) + " release status"
 }

 type tokenSource oauth2.Token

 func (t *tokenSource) Token() (*oauth2.Token, error) {
 	return (*oauth2.Token)(t), nil
 }

 func (w *Work) findOrCreateReleaseIssue() {
 	w.log.Printf("Release status issue title: %q", w.releaseStatusTitle())
 	if dryRun {
 		return
 	}
 	if w.ReleaseIssue == 0 {
 		title := w.releaseStatusTitle()
 		body := fmt.Sprintf("Issue tracking the %s release by releasebot.", w.Version)
 		num, err := w.createGitHubIssue(title, body)
 		if err != nil {
 			w.log.Panic(err)
 		}
 		w.ReleaseIssue = num
 		w.log.Printf("Release status issue: https://golang.org/issue/%d", num)
 	}
 }

 // createGitHubIssue creates an issue in the release milestone and returns its number.
 func (w *Work) createGitHubIssue(title, msg string) (int, error) {
 	if dryRun {
 		return 0, errors.New("attempted write operation in dry-run mode")
 	}
 	var dup int
 	goRepo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
 		if gi.Title == title {
 			dup = int(gi.Number)
 			return errors.New("stop iteration")
 		}
 		return nil
 	})
 	if dup != 0 {
 		return dup, nil
 	}
 	opts := &github.IssueListByRepoOptions{
 		State:       "all",
 		ListOptions: github.ListOptions{PerPage: 100},
 	}
 	if !w.BetaRelease && !w.RCRelease {
 		opts.Milestone = strconv.Itoa(int(w.Milestone.Number))
 	}
 	is, _, err := githubClient.Issues.ListByRepo(context.TODO(), "golang", "go", opts)
 	if err != nil {
 		return 0, err
 	}
 	for _, i := range is {
 		if i.GetTitle() == title {
 			// Dup.
 			return i.GetNumber(), nil
 		}
 	}
 	copts := &github.IssueRequest{
 		Title: github.String(title),
 		Body:  github.String(msg),
 	}
 	if !w.BetaRelease && !w.RCRelease {
 		copts.Milestone = github.Int(int(w.Milestone.Number))
 	}
 	i, _, err := githubClient.Issues.Create(context.TODO(), "golang", "go", copts)
 	return i.GetNumber(), err
 }

 // pushIssues moves open issues to the milestone of the next release of the same kind,
 // creating the milestone if it doesn't already exist.
 // For major releases, it's the milestone of the next major release (e.g., 1.14 → 1.15).
 // For minor releases, it's the milestone of the next minor release (e.g., 1.14.1 → 1.14.2).
 // For other release types, it does nothing.
 //
 // For major releases, it also creates the first minor release milestone if it doesn't already exist.
 func (w *Work) pushIssues() {
 	if w.BetaRelease || w.RCRelease {
 		// Nothing to do.
 		return
 	}

 	// Get the milestone for the next release.
 	var nextMilestone *github.Milestone
 	nextV, err := nextVersion(w.Version)
 	if err != nil {
 		w.logError("error determining next version: %v", err)
 		return
 	}
 	nextMilestone, err = w.findOrCreateMilestone(nextV)
 	if err != nil {
 		w.logError("error finding or creating %s, the next GitHub milestone after release %s: %v", nextV, w.Version, err)
 		return
 	}

 	// For major releases (go1.X), also create the first minor release milestone (go1.X.1). See issue 44404.
 	if strings.Count(w.Version, ".") == 1 {
 		firstMinor := w.Version + ".1"
 		_, err := w.findOrCreateMilestone(firstMinor)
 		if err != nil {
 			// Log this error, but continue executing the rest of the task.
 			w.logError("error finding or creating %s, the first minor release GitHub milestone after major release %s: %v", firstMinor, w.Version, err)
 		}
 	}

 	if err := goRepo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
 		if gi.Milestone == nil || gi.Milestone.ID != w.Milestone.ID {
 			return nil
 		}
 		if gi.Number == int32(w.ReleaseIssue) {
 			return nil
 		}
 		if gi.Closed {
 			return nil
 		}
 		w.log.Printf("changing milestone of issue %d to %s", gi.Number, nextMilestone.GetTitle())
 		if dryRun {
 			return nil
 		}
 		_, _, err := githubClient.Issues.Edit(context.TODO(), projectOwner, projectRepo, int(gi.Number), &github.IssueRequest{
 			Milestone: github.Int(nextMilestone.GetNumber()),
 		})
 		if err != nil {
 			return fmt.Errorf("#%d: %s", gi.Number, err)
 		}
 		return nil
 	}); err != nil {
 		w.logError("error moving issues to the next minor release: %v", err)
 		return
 	}
 }

 // findOrCreateMilestone finds or creates a GitHub milestone corresponding
 // to the specified Go version. This is done via the GitHub API, using githubClient.
 // If the milestone exists but isn't open, an error is returned.
 func (w *Work) findOrCreateMilestone(version string) (*github.Milestone, error) {
 	// Look for an existing open milestone corresponding to version,
 	// and return it if found.
 	for opt := (&github.MilestoneListOptions{ListOptions: github.ListOptions{PerPage: 100}}); ; {
 		ms, resp, err := githubClient.Issues.ListMilestones(context.Background(), projectOwner, projectRepo, opt)
 		if err != nil {
 			return nil, err
 		}
 		for _, m := range ms {
 			if strings.ToLower(m.GetTitle()) == version {
 				// Found an existing milestone.
 				return m, nil
 			}
 		}
 		if resp.NextPage == 0 {
 			break
 		}
 		opt.Page = resp.NextPage
 	}

 	// Create a new milestone.
 	// For historical reasons, Go milestone titles use a capital "Go1.n" format,
 	// in contrast to go versions which are like "go1.n". Do the same here.
 	title := strings.Replace(version, "go", "Go", 1)
 	w.log.Printf("creating milestone titled %q", title)
 	if dryRun {
 		return &github.Milestone{Title: github.String(title)}, nil
 	}
 	m, _, err := githubClient.Issues.CreateMilestone(context.Background(), projectOwner, projectRepo, &github.Milestone{
 		Title: github.String(title),
 	})
 	if e := (*github.ErrorResponse)(nil); errors.As(err, &e) && e.Response != nil && e.Response.StatusCode == http.StatusUnprocessableEntity && len(e.Errors) == 1 && e.Errors[0].Code == "already_exists" {
 		// We'll run into an already_exists error here if the milestone exists,
 		// but it wasn't found in the loop above because the milestone isn't open.
 		// That shouldn't happen under normal circumstances, so if it does,
 		// let humans figure out how to best deal with it.
 		return nil, errors.New("a closed milestone with the same title already exists")
 	} else if err != nil {
 		return nil, err
 	}
 	return m, nil
 }

 // closeMilestone closes the milestone for the current release.
 func (w *Work) closeMilestone() {
 	w.log.Printf("closing milestone %s", w.Milestone.Title)
 	if dryRun {
 		return
 	}
 	closed := "closed"
 	_, _, err := githubClient.Issues.EditMilestone(context.TODO(), projectOwner, projectRepo, int(w.Milestone.Number), &github.Milestone{
 		State: &closed,
 	})
 	if err != nil {
 		w.logError("closing milestone: %v", err)
 	}

 }

 // removeOkayAfterBeta1 cleans up the okay-after-beta1 label after the beta1 release is out.
 func (w *Work) removeOkayAfterBeta1() {
 	if !w.BetaRelease || !strings.HasSuffix(w.Version, "beta1") {
 		// Nothing to do.
 		return
 	}

 	if err := goRepo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
 		if gi.Milestone == nil || gi.Milestone.ID != w.Milestone.ID {
 			return nil
 		}
 		if gi.Number == int32(w.ReleaseIssue) {
 			return nil
 		}
 		if gi.Closed || !gi.HasLabel("okay-after-beta1") {
 			return nil
 		}
 		w.log.Printf("removing okay-after-beta1 label in issue %d", gi.Number)
 		if dryRun {
 			return nil
 		}
 		_, err := githubClient.Issues.RemoveLabelForIssue(context.Background(),
 			projectOwner, projectRepo, int(gi.Number), "okay-after-beta1")
 		if err != nil {
 			return fmt.Errorf("#%d: %s", gi.Number, err)
 		}
 		return nil
 	}); err != nil {
 		w.logError("error removing okay-after-beta1 label from issues in current milestone: %v", err)
 		return
 	}
 }

 const githubCommentCharacterLimit = 65536 // discovered in golang.org/issue/45998

 func postGithubComment(number int, body string) error {
 	if dryRun {
 		return errors.New("attempted write operation in dry-run mode")
 	}
 	_, _, err := githubClient.Issues.CreateComment(context.TODO(), projectOwner, projectRepo, number, &github.IssueComment{
 		Body: &body,
 	})
 	return err
 }
	// Copyright 2017 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 main

	import (
	"context"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	"github.com/google/go-github/github"
	"golang.org/x/build/maintner"
	"golang.org/x/build/maintner/godata"
	"golang.org/x/oauth2"
	)

	const (
	projectOwner = "golang"
	projectRepo = "go"
	)

	var githubClient *github.Client

	// GitHub personal access token, from https://github.com/settings/applications.
	var githubAuthToken string

	var goRepo *maintner.GitHubRepo

	func loadMaintner() {
	corpus, err := godata.Get(context.Background())
	if err != nil {
	log.Fatal("failed to load maintner data:", err)
	}
	goRepo = corpus.GitHub().Repo(projectOwner, projectRepo)
	}

	func loadGithubAuth() {
	const short = ".github-issue-token"
	filename := filepath.Clean(os.Getenv("HOME") + "/" + short)
	shortFilename := filepath.Clean("$HOME/" + short)
	data, err := ioutil.ReadFile(filename)
	if err != nil {
	log.Fatal("reading token: ", err, "\n\n"+
	"Please create a personal access token at https://github.com/settings/tokens/new\n"+
	"and write it to ", shortFilename, " to use this program.\n"+
	" The token only needs the public_repo scope. \n"+
	"The benefit of using a personal access token over using your GitHub\n"+
	"password directly is that you can limit its use and revoke it at any time.\n\n")
	}
	fi, err := os.Stat(filename)
	if err != nil {
	log.Fatalln("reading token:", err)
	}
	if fi.Mode()&0077 != 0 {
	log.Fatalf("reading token: %s mode is %#o, want %#o", shortFilename, fi.Mode()&0777, fi.Mode()&0700)
	}
	githubAuthToken = strings.TrimSpace(string(data))
	t := &oauth2.Transport{
	Source: &tokenSource{AccessToken: githubAuthToken},
	}
	githubClient = github.NewClient(&http.Client{Transport: t})
	}

	// releaseStatusTitle returns the title of the release status issue
	// for the given milestone.
	// If you change this function, releasebot will not be able to find an
	// existing tracking issue using the old name and will create a new one.
	func (w *Work) releaseStatusTitle() string {
	return "all: " + strings.Replace(w.Version, "go", "Go ", -1) + " release status"
	}

	type tokenSource oauth2.Token

	func (t tokenSource) Token() (oauth2.Token, error) {
	return (*oauth2.Token)(t), nil
	}

	func (w *Work) findOrCreateReleaseIssue() {
	w.log.Printf("Release status issue title: %q", w.releaseStatusTitle())
	if dryRun {
	return
	}
	if w.ReleaseIssue == 0 {
	title := w.releaseStatusTitle()
	body := fmt.Sprintf("Issue tracking the %s release by releasebot.", w.Version)
	num, err := w.createGitHubIssue(title, body)
	if err != nil {
	w.log.Panic(err)
	}
	w.ReleaseIssue = num
	w.log.Printf("Release status issue: https://golang.org/issue/%d", num)
	}
	}

	// createGitHubIssue creates an issue in the release milestone and returns its number.
	func (w *Work) createGitHubIssue(title, msg string) (int, error) {
	if dryRun {
	return 0, errors.New("attempted write operation in dry-run mode")
	}
	var dup int
	goRepo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
	if gi.Title == title {
	dup = int(gi.Number)
	return errors.New("stop iteration")
	}
	return nil
	})
	if dup != 0 {
	return dup, nil
	}
	opts := &github.IssueListByRepoOptions{
	State: "all",
	ListOptions: github.ListOptions{PerPage: 100},
	}
	if !w.BetaRelease && !w.RCRelease {
	opts.Milestone = strconv.Itoa(int(w.Milestone.Number))
	}
	is, _, err := githubClient.Issues.ListByRepo(context.TODO(), "golang", "go", opts)
	if err != nil {
	return 0, err
	}
	for _, i := range is {
	if i.GetTitle() == title {
	// Dup.
	return i.GetNumber(), nil
	}
	}
	copts := &github.IssueRequest{
	Title: github.String(title),
	Body: github.String(msg),
	}
	if !w.BetaRelease && !w.RCRelease {
	copts.Milestone = github.Int(int(w.Milestone.Number))
	}
	i, _, err := githubClient.Issues.Create(context.TODO(), "golang", "go", copts)
	return i.GetNumber(), err
	}

	// pushIssues moves open issues to the milestone of the next release of the same kind,
	// creating the milestone if it doesn't already exist.
	// For major releases, it's the milestone of the next major release (e.g., 1.14 → 1.15).
	// For minor releases, it's the milestone of the next minor release (e.g., 1.14.1 → 1.14.2).
	// For other release types, it does nothing.
	//
	// For major releases, it also creates the first minor release milestone if it doesn't already exist.
	func (w *Work) pushIssues() {
	if w.BetaRelease \|\| w.RCRelease {
	// Nothing to do.
	return
	}

	// Get the milestone for the next release.
	var nextMilestone *github.Milestone
	nextV, err := nextVersion(w.Version)
	if err != nil {
	w.logError("error determining next version: %v", err)
	return
	}
	nextMilestone, err = w.findOrCreateMilestone(nextV)
	if err != nil {
	w.logError("error finding or creating %s, the next GitHub milestone after release %s: %v", nextV, w.Version, err)
	return
	}

	// For major releases (go1.X), also create the first minor release milestone (go1.X.1). See issue 44404.
	if strings.Count(w.Version, ".") == 1 {
	firstMinor := w.Version + ".1"
	_, err := w.findOrCreateMilestone(firstMinor)
	if err != nil {
	// Log this error, but continue executing the rest of the task.
	w.logError("error finding or creating %s, the first minor release GitHub milestone after major release %s: %v", firstMinor, w.Version, err)
	}
	}

	if err := goRepo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
	if gi.Milestone == nil \|\| gi.Milestone.ID != w.Milestone.ID {
	return nil
	}
	if gi.Number == int32(w.ReleaseIssue) {
	return nil
	}
	if gi.Closed {
	return nil
	}
	w.log.Printf("changing milestone of issue %d to %s", gi.Number, nextMilestone.GetTitle())
	if dryRun {
	return nil
	}
	_, _, err := githubClient.Issues.Edit(context.TODO(), projectOwner, projectRepo, int(gi.Number), &github.IssueRequest{
	Milestone: github.Int(nextMilestone.GetNumber()),
	})
	if err != nil {
	return fmt.Errorf("#%d: %s", gi.Number, err)
	}
	return nil
	}); err != nil {
	w.logError("error moving issues to the next minor release: %v", err)
	return
	}
	}

	// findOrCreateMilestone finds or creates a GitHub milestone corresponding
	// to the specified Go version. This is done via the GitHub API, using githubClient.
	// If the milestone exists but isn't open, an error is returned.
	func (w Work) findOrCreateMilestone(version string) (github.Milestone, error) {
	// Look for an existing open milestone corresponding to version,
	// and return it if found.
	for opt := (&github.MilestoneListOptions{ListOptions: github.ListOptions{PerPage: 100}}); ; {
	ms, resp, err := githubClient.Issues.ListMilestones(context.Background(), projectOwner, projectRepo, opt)
	if err != nil {
	return nil, err
	}
	for _, m := range ms {
	if strings.ToLower(m.GetTitle()) == version {
	// Found an existing milestone.
	return m, nil
	}
	}
	if resp.NextPage == 0 {
	break
	}
	opt.Page = resp.NextPage
	}

	// Create a new milestone.
	// For historical reasons, Go milestone titles use a capital "Go1.n" format,
	// in contrast to go versions which are like "go1.n". Do the same here.
	title := strings.Replace(version, "go", "Go", 1)
	w.log.Printf("creating milestone titled %q", title)
	if dryRun {
	return &github.Milestone{Title: github.String(title)}, nil
	}
	m, _, err := githubClient.Issues.CreateMilestone(context.Background(), projectOwner, projectRepo, &github.Milestone{
	Title: github.String(title),
	})
	if e := (*github.ErrorResponse)(nil); errors.As(err, &e) && e.Response != nil && e.Response.StatusCode == http.StatusUnprocessableEntity && len(e.Errors) == 1 && e.Errors[0].Code == "already_exists" {
	// We'll run into an already_exists error here if the milestone exists,
	// but it wasn't found in the loop above because the milestone isn't open.
	// That shouldn't happen under normal circumstances, so if it does,
	// let humans figure out how to best deal with it.
	return nil, errors.New("a closed milestone with the same title already exists")
	} else if err != nil {
	return nil, err
	}
	return m, nil
	}

	// closeMilestone closes the milestone for the current release.
	func (w *Work) closeMilestone() {
	w.log.Printf("closing milestone %s", w.Milestone.Title)
	if dryRun {
	return
	}
	closed := "closed"
	_, _, err := githubClient.Issues.EditMilestone(context.TODO(), projectOwner, projectRepo, int(w.Milestone.Number), &github.Milestone{
	State: &closed,
	})
	if err != nil {
	w.logError("closing milestone: %v", err)
	}

	}

	// removeOkayAfterBeta1 cleans up the okay-after-beta1 label after the beta1 release is out.
	func (w *Work) removeOkayAfterBeta1() {
	if !w.BetaRelease \|\| !strings.HasSuffix(w.Version, "beta1") {
	// Nothing to do.
	return
	}

	if err := goRepo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
	if gi.Milestone == nil \|\| gi.Milestone.ID != w.Milestone.ID {
	return nil
	}
	if gi.Number == int32(w.ReleaseIssue) {
	return nil
	}
	if gi.Closed \|\| !gi.HasLabel("okay-after-beta1") {
	return nil
	}
	w.log.Printf("removing okay-after-beta1 label in issue %d", gi.Number)
	if dryRun {
	return nil
	}
	_, err := githubClient.Issues.RemoveLabelForIssue(context.Background(),
	projectOwner, projectRepo, int(gi.Number), "okay-after-beta1")
	if err != nil {
	return fmt.Errorf("#%d: %s", gi.Number, err)
	}
	return nil
	}); err != nil {
	w.logError("error removing okay-after-beta1 label from issues in current milestone: %v", err)
	return
	}
	}

	const githubCommentCharacterLimit = 65536 // discovered in golang.org/issue/45998

	func postGithubComment(number int, body string) error {
	if dryRun {
	return errors.New("attempted write operation in dry-run mode")
	}
	_, _, err := githubClient.Issues.CreateComment(context.TODO(), projectOwner, projectRepo, number, &github.IssueComment{
	Body: &body,
	})
	return err
	}