Remove github_host var, rename github_token to github_access_token, match the release sources to the release by org

Author: jajita

.github/workflows/create-debugging-artifact.yml

@@ -41,6 +41,7 @@ jobs:
           RELEEN_GITHUB_TOKEN: ${{ secrets.RELEEN_GITHUB_TOKEN }}
         run: |
           export GITHUB_TOKEN="${RELEEN_GITHUB_TOKEN}"
+          export GITHUB_ACCESS_TOKEN="${RELEEN_GITHUB_TOKEN}"
           go test ./...
 
       - name: Acceptance Tests

.github/workflows/release.yml

@@ -38,6 +38,7 @@ jobs:
           RELEEN_GITHUB_TOKEN: ${{ secrets.RELEEN_GITHUB_TOKEN }}
         run: |
           export GITHUB_TOKEN="${RELEEN_GITHUB_TOKEN}"
+          export GITHUB_ACCESS_TOKEN="${RELEEN_GITHUB_TOKEN}"
           go test --covermode=atomic --coverprofile=kiln-${{github.sha}}-unit-test-code-coverage.out ./...
 
       - name: Archive Unit Test Code Coverage Output
@@ -53,6 +54,7 @@ jobs:
         run: |
           set -euo pipefail
           export GITHUB_TOKEN="${RELEEN_GITHUB_TOKEN}"
+          export GITHUB_ACCESS_TOKEN="${RELEEN_GITHUB_TOKEN}"
 
           set -x
           go test -v --timeout 24h --tags acceptance github.com/pivotal-cf/kiln/internal/acceptance/workflows
@@ -80,3 +82,5 @@ jobs:
           args: release --clean
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+

.github/workflows/test.yml

@@ -51,6 +51,7 @@ jobs:
         run: |
           set -euo pipefail
           export GITHUB_TOKEN="${RELEEN_GITHUB_TOKEN}"
+          export GITHUB_ACCESS_TOKEN="${RELEEN_GITHUB_TOKEN}"
 
           set -x
           go test -v --timeout 15m --tags acceptance github.com/pivotal-cf/kiln/internal/acceptance/workflows

internal/acceptance/workflows/generating_release_notes.feature

@@ -10,7 +10,7 @@ Feature: As a robot, I want to generate release notes
       | --name=hello-release                      |
       | --version=v0.1.5                          |
       | --without-download                        |
-      | --variable=github_token="${GITHUB_TOKEN}" |
+      | --variable=github_access_token="${GITHUB_TOKEN}" |
     And I write file "version"
       | 0.1.4 |
     And I execute git add Kilnfile.lock version

internal/acceptance/workflows/scenario/step_funcs_github.go

@@ -13,7 +13,7 @@ func githubRepoHasReleaseWithTag(ctx context.Context, repoOrg, repoName, tag str
 	if err != nil {
 		return err
 	}
-	ghAPI, err := gh.Client(ctx, "", accessToken)
+	ghAPI, err := gh.Client(ctx, "", accessToken, accessToken)
 	if err != nil {
 		return fmt.Errorf("failed to setup github client: %w", err)
 	}

internal/acceptance/workflows/testdata/tiles/v1/Kilnfile

@@ -3,7 +3,7 @@ slug: crhntr-hello
 release_sources:
   - type: github
     org: crhntr
-    github_token: $(variable "github_token")
+    github_token: $(variable "github_access_token")
   - type: bosh.io
 releases:
   - name: bpm

internal/acceptance/workflows/testdata/tiles/v2/Kilnfile

@@ -3,7 +3,7 @@ slug: crhntr-hello
 release_sources:
   - type: github
     org: crhntr
-    github_token: $(variable "github_token")
+    github_token: $(variable "github_access_token")
   - type: bosh.io
 releases:
   - name: bpm

internal/commands/release_notes.go

@@ -28,15 +28,15 @@ const releaseDateFormat = "2006-01-02"
 
 type ReleaseNotes struct {
 	Options struct {
-		ReleaseDate              string   `long:"release-date"   short:"d"  description:"release date of the tile"`
-		TemplateName             string   `long:"template"       short:"t"  description:"path to template"`
-		GithubIssuesServiceToken string   `long:"github-token"   short:"g"  description:"auth token for fetching issues and milestones with labels" env:"GITHUB_TOKEN"`
-		GithubHost               string   `long:"github-host"               description:"set this when you are using GitHub enterprise to fetch issues, milestones or notes for bosh releases" env:"GITHUB_HOST"`
-		Kilnfile                 string   `long:"kilnfile"       short:"k"  description:"path to Kilnfile"`
-		DocsFile                 string   `long:"update-docs"    short:"u"  description:"path to docs file to update"`
-		Window                   string   `long:"window"         short:"w"  description:"GA window for release notes" default:"ga"`
-		VariableFiles            []string `long:"variables-file" short:"vf" description:"path to a file containing variables to interpolate"`
-		Variables                []string `long:"variable"       short:"vr" description:"key value pairs of variables to interpolate"`
+		ReleaseDate                 string   `long:"release-date"   short:"d"  description:"release date of the tile"`
+		TemplateName                string   `long:"template"       short:"t"  description:"path to template"`
+		GithubAccessToken           string   `long:"github_access_token"   short:"g"  description:"auth token for github.com" env:"GITHUB_ACCESS_TOKEN"`
+		GithubEnterpriseAccessToken string   `long:"github_enterprise_access_token"  short:"ge"   description:"auth token for github enterprise" env:"GITHUB_ENTERPRISE_ACCESS_TOKEN"`
+		Kilnfile                    string   `long:"kilnfile"       short:"k"  description:"path to Kilnfile"`
+		DocsFile                    string   `long:"update-docs"    short:"u"  description:"path to docs file to update"`
+		Window                      string   `long:"window"         short:"w"  description:"GA window for release notes" default:"ga"`
+		VariableFiles               []string `long:"variables-file" short:"vf" description:"path to a file containing variables to interpolate"`
+		Variables                   []string `long:"variable"       short:"vr" description:"key value pairs of variables to interpolate"`
 		notes.IssuesQuery
 		notes.TrainstatQuery
 	}
@@ -49,10 +49,10 @@ type ReleaseNotes struct {
 	fetchNotesData   FetchNotesData
 	variablesService baking.TemplateVariablesService
 
-	repoOwner, repoName string
+	repoHost, repoOwner, repoName string
 }
 
-type FetchNotesData func(ctx context.Context, repo *git.Repository, client *github.Client, tileRepoOwner, tileRepoName, kilnfilePath, initialRevision, finalRevision string, issuesQuery notes.IssuesQuery, trainstatClient notes.TrainstatNotesFetcher, variables map[string]any) (notes.Data, error)
+type FetchNotesData func(ctx context.Context, repo *git.Repository, client *github.Client, tileRepoHost, tileRepoOwner, tileRepoName, kilnfilePath, initialRevision, finalRevision string, issuesQuery notes.IssuesQuery, trainstatClient notes.TrainstatNotesFetcher, variables map[string]any) (notes.Data, error)
 
 func NewReleaseNotesCommand() (ReleaseNotes, error) {
 	return ReleaseNotes{
@@ -82,16 +82,16 @@ func (r ReleaseNotes) Execute(args []string) error {
 	if err != nil {
 		return fmt.Errorf("failed to parse template variables: %s", err)
 	}
-	if varValue, ok := templateVariables["github_token"]; !ok && r.Options.GithubIssuesServiceToken != "" {
-		templateVariables["github_token"] = r.Options.GithubIssuesServiceToken
-	} else if ok && r.Options.GithubIssuesServiceToken == "" {
-		r.Options.GithubIssuesServiceToken = varValue.(string)
+	if varValue, ok := templateVariables["github_access_token"]; !ok && r.Options.GithubAccessToken != "" {
+		templateVariables["github_access_token"] = r.Options.GithubAccessToken
+	} else if ok && r.Options.GithubAccessToken == "" {
+		r.Options.GithubAccessToken = varValue.(string)
 	}
 
-	if varValue, ok := templateVariables["github_host"]; !ok && r.Options.GithubHost != "" {
-		templateVariables["github_host"] = r.Options.GithubHost
-	} else if ok && r.Options.GithubHost == "" {
-		r.Options.GithubHost = varValue.(string)
+	if varValue, ok := templateVariables["github_enterprise_access_token"]; !ok && r.Options.GithubAccessToken != "" {
+		templateVariables["github_enterprise_access_token"] = r.Options.GithubEnterpriseAccessToken
+	} else if ok && r.Options.GithubEnterpriseAccessToken == "" {
+		r.Options.GithubEnterpriseAccessToken = varValue.(string)
 	}
 
 	ctx := context.Background()
@@ -106,18 +106,17 @@ func (r ReleaseNotes) Execute(args []string) error {
 	}
 
 	var client *github.Client
-	if r.Options.GithubIssuesServiceToken != "" {
-		client, err = gh.Client(ctx, r.Options.GithubHost, r.Options.GithubIssuesServiceToken)
-		if err != nil {
-			return fmt.Errorf("failed to setup github client: %w", err)
-		}
+
+	client, err = gh.Client(ctx, r.repoHost, r.Options.GithubAccessToken, r.Options.GithubEnterpriseAccessToken)
+	if err != nil {
+		return fmt.Errorf("failed to setup github client: %w", err)
 	}
 
 	trainstatClient := notes.NewTrainstatClient(r.Options.TrainstatQuery.TrainstatURL)
 
 	_ = notes.FetchData // fetchNotesData is github.com/pivotal/kiln/internal/notes.FetchData
 	data, err := r.fetchNotesData(ctx,
-		r.repository, client, r.repoOwner, r.repoName,
+		r.repository, client, r.repoHost, r.repoOwner, r.repoName,
 		r.Options.Kilnfile,
 		nonFlagArgs[0], nonFlagArgs[1],
 		r.Options.IssuesQuery,
@@ -196,12 +195,13 @@ func (r *ReleaseNotes) initRepo() error {
 		return fmt.Errorf("release-notes must be run from the root of the repository (use --kilnfile flag to specify which tile to build)")
 	}
 
-	repoOwner, repoName, err := getGithubRemoteRepoOwnerAndName(repo)
+	repoHost, repoOwner, repoName, err := getGithubRemoteHostRepoOwnerAndName(repo)
 	if err != nil {
 		return err
 	}
 
 	r.repository = repo
+	r.repoHost = repoHost
 	r.repoName = repoName
 	r.repoOwner = repoOwner
 
@@ -243,11 +243,8 @@ func (r ReleaseNotes) checkInputs(nonFlagArgs []string) error {
 		}
 	}
 
-	if r.Options.GithubIssuesServiceToken == "" &&
-		(r.Options.IssueMilestone != "" ||
-			len(r.Options.IssueIDs) > 0 ||
-			len(r.Options.IssueLabels) > 0) {
-		return errors.New("github-token (env: GITHUB_TOKEN) must be set to interact with the github api")
+	if r.Options.GithubEnterpriseAccessToken == "" && r.Options.GithubAccessToken == "" {
+		return errors.New("github_access_token(env: GITHUB_ACCESS_TOKEN) and/or github_enterprise_access_token(env: GITHUB_ENTERPRISE_ACCESS_TOKEN) must be set to interact with the github api")
 	}
 
 	if r.Options.DocsFile != "" {
@@ -279,25 +276,25 @@ func (r ReleaseNotes) parseReleaseDate() (time.Time, error) {
 	return releaseDate, nil
 }
 
-func getGithubRemoteRepoOwnerAndName(repo *git.Repository) (string, string, error) {
+func getGithubRemoteHostRepoOwnerAndName(repo *git.Repository) (string, string, string, error) {
 	var remoteURL string
 	remote, err := repo.Remote("origin")
 	if err != nil {
-		return "", "", err
+		return "", "", "", err
 	}
 	config := remote.Config()
 	for _, u := range config.URLs {
 		remoteURL = u
 		break
 	}
 	if remoteURL == "" {
-		return "", "", fmt.Errorf("remote github URL not found for repo")
+		return "", "", "", fmt.Errorf("remote github URL not found for repo")
 	}
 
-	repoOwner, repoName, err := gh.RepositoryOwnerAndNameFromPath(remoteURL)
+	repoHost, repoOwner, repoName, err := gh.RepositoryHostOwnerAndNameFromPath(remoteURL)
 	if err != nil {
-		return "", "", err
+		return "", "", "", err
 	}
 
-	return repoOwner, repoName, nil
+	return repoHost, repoOwner, repoName, nil
 }

internal/commands/release_notes_test.go

@@ -57,7 +57,7 @@ func TestReleaseNotes_Execute(t *testing.T) {
 		}
 
 		var (
-			tileRepoOwner, tileRepoName, kilnfilePath, initialRevision, finalRevision string
+			tileRepoHost, tileRepoOwner, tileRepoName, kilnfilePath, initialRevision, finalRevision string
 
 			issuesQuery notes.IssuesQuery
 			repository  *git.Repository
@@ -69,12 +69,13 @@ func TestReleaseNotes_Execute(t *testing.T) {
 		rn := ReleaseNotes{
 			Writer:     &out,
 			repository: nonNilRepo,
+			repoHost:   "github.com",
 			repoOwner:  "bunch",
 			repoName:   "banana",
 			readFile:   readFileFunc,
-			fetchNotesData: func(c context.Context, repo *git.Repository, ghc *github.Client, tro, trn, kfp, ir, fr string, iq notes.IssuesQuery, _ notes.TrainstatNotesFetcher, __ map[string]any) (notes.Data, error) {
+			fetchNotesData: func(c context.Context, repo *git.Repository, ghc *github.Client, trh, tro, trn, kfp, ir, fr string, iq notes.IssuesQuery, _ notes.TrainstatNotesFetcher, __ map[string]any) (notes.Data, error) {
 				ctx, repository, client = c, repo, ghc
-				tileRepoOwner, tileRepoName, kilnfilePath, initialRevision, finalRevision = tro, trn, kfp, ir, fr
+				tileRepoHost, tileRepoOwner, tileRepoName, kilnfilePath, initialRevision, finalRevision = trh, tro, trn, kfp, ir, fr
 				issuesQuery = iq
 				return notes.Data{
 					ReleaseDate: mustParseTime(time.Parse(releaseDateFormat, "2021-11-04")),
@@ -104,12 +105,12 @@ func TestReleaseNotes_Execute(t *testing.T) {
 			},
 		}
 
-		rn.Options.GithubIssuesServiceToken = "secret"
+		rn.Options.GithubAccessToken = "secret"
 
 		err := rn.Execute([]string{
 			"--kilnfile=tile/Kilnfile",
 			"--release-date=2021-11-04",
-			"--github-token=lemon",
+			"--github_access_token=lemon",
 			"--github-issue-milestone=smoothie",
 			"--github-issue-label=tropical",
 			"--github-issue=54000",
@@ -124,6 +125,7 @@ func TestReleaseNotes_Execute(t *testing.T) {
 		please.Expect(repository).NotTo(BeNil())
 		please.Expect(client).NotTo(BeNil())
 
+		please.Expect(tileRepoHost).To(Equal("github.com"))
 		please.Expect(tileRepoOwner).To(Equal("bunch"))
 		please.Expect(tileRepoName).To(Equal("banana"))
 		please.Expect(kilnfilePath).To(Equal("tile/Kilnfile"))
@@ -188,6 +190,7 @@ func TestReleaseNotes_checkInputs(t *testing.T) {
 
 		rn := ReleaseNotes{}
 		rn.Options.ReleaseDate = `some-date`
+		rn.Options.GithubAccessToken = "test-token"
 		err := rn.checkInputs([]string{"a", "b"})
 		please.Expect(err).To(MatchError(ContainSubstring("cannot parse")))
 	})
@@ -197,34 +200,17 @@ func TestReleaseNotes_checkInputs(t *testing.T) {
 			please := NewWithT(t)
 
 			rn := ReleaseNotes{}
-			rn.Options.IssueMilestone = "s"
 			err := rn.checkInputs([]string{"a", "b"})
-			please.Expect(err).To(MatchError(ContainSubstring("github-token")))
-		})
-
-		t.Run("ids", func(t *testing.T) {
-			please := NewWithT(t)
-
-			rn := ReleaseNotes{}
-			rn.Options.IssueIDs = []string{"s"}
-			err := rn.checkInputs([]string{"a", "b"})
-			please.Expect(err).To(MatchError(ContainSubstring("github-token")))
-		})
-
-		t.Run("labels", func(t *testing.T) {
-			please := NewWithT(t)
-
-			rn := ReleaseNotes{}
-			rn.Options.IssueLabels = []string{"s"}
-			err := rn.checkInputs([]string{"a", "b"})
-			please.Expect(err).To(MatchError(ContainSubstring("github-token")))
+			please.Expect(err).To(MatchError(ContainSubstring("github_access_token")))
+			please.Expect(err).To(MatchError(ContainSubstring("github_enterprise_access_token")))
 		})
 
 		t.Run("exp", func(t *testing.T) {
 			please := NewWithT(t)
 
 			rn := ReleaseNotes{}
 			rn.Options.IssueTitleExp = "s"
+			rn.Options.GithubEnterpriseAccessToken = "test-token"
 			err := rn.checkInputs([]string{"a", "b"})
 			please.Expect(err).NotTo(HaveOccurred())
 		})
@@ -243,8 +229,9 @@ func Test_getGithubRemoteRepoOwnerAndName(t *testing.T) {
 				"https://github.com/pivotal-cf/kiln",
 			},
 		})
-		o, r, err := getGithubRemoteRepoOwnerAndName(repo)
+		h, o, r, err := getGithubRemoteHostRepoOwnerAndName(repo)
 		please.Expect(err).NotTo(HaveOccurred())
+		please.Expect(h).To(Equal("github.com"))
 		please.Expect(o).To(Equal("pivotal-cf"))
 		please.Expect(r).To(Equal("kiln"))
 	})
@@ -259,8 +246,9 @@ func Test_getGithubRemoteRepoOwnerAndName(t *testing.T) {
 				"[email protected]:pivotal-cf/kiln.git",
 			},
 		})
-		o, r, err := getGithubRemoteRepoOwnerAndName(repo)
+		h, o, r, err := getGithubRemoteHostRepoOwnerAndName(repo)
 		please.Expect(err).NotTo(HaveOccurred())
+		please.Expect(h).To(Equal("github.com"))
 		please.Expect(o).To(Equal("pivotal-cf"))
 		please.Expect(r).To(Equal("kiln"))
 	})
@@ -269,7 +257,7 @@ func Test_getGithubRemoteRepoOwnerAndName(t *testing.T) {
 		please := NewWithT(t)
 
 		repo, _ := git.Init(memory.NewStorage(), memfs.New())
-		_, _, err := getGithubRemoteRepoOwnerAndName(repo)
+		_, _, _, err := getGithubRemoteHostRepoOwnerAndName(repo)
 		please.Expect(err).To(MatchError(ContainSubstring("not found")))
 	})
 
@@ -289,8 +277,9 @@ func Test_getGithubRemoteRepoOwnerAndName(t *testing.T) {
 				"[email protected]:pivotal-cf/kiln.git",
 			},
 		})
-		o, _, err := getGithubRemoteRepoOwnerAndName(repo)
+		h, o, _, err := getGithubRemoteHostRepoOwnerAndName(repo)
 		please.Expect(err).NotTo(HaveOccurred())
+		please.Expect(h).To(Equal("github.com"))
 		please.Expect(o).To(Equal("pivotal-cf"), "it uses the remote with name 'origin'")
 	})
 }

internal/component/github_release_source.go

@@ -43,7 +43,7 @@ func NewGithubReleaseSource(c cargo.ReleaseSourceConfig) *GithubReleaseSource {
 	if c.Org == "" {
 		panic("no github org passed for github release source")
 	}
-	githubClient, err := c.GitHubClient(context.TODO())
+	githubClient, err := gh.Client(context.TODO(), "", c.GithubToken, c.GithubToken) // host is github.com by default
 	if err != nil {
 		panic(err)
 	}