refactor: tag-and-release does not need local clone (#2185)

Fixes #2172
Fixes #2053

Author: chingor13

internal/config/config.go

@@ -54,7 +54,8 @@ const (
 	// ReleaseInitResponse is a JSON file that describes which library to change
 	// after release.
 	ReleaseInitResponse = "release-init-response.json"
-	pipelineStateFile   = "state.yaml"
+	// LibrarianStateFile is the name of the pipeline state file.
+	LibrarianStateFile = "state.yaml"
 )
 
 // are variables so it can be replaced during testing.
@@ -294,7 +295,7 @@ func (c *Config) deriveRepo() error {
 	if err != nil {
 		return fmt.Errorf("getting working directory: %w", err)
 	}
-	stateFile := filepath.Join(wd, LibrarianDir, pipelineStateFile)
+	stateFile := filepath.Join(wd, LibrarianDir, LibrarianStateFile)
 	if _, err := os.Stat(stateFile); err != nil {
 		return fmt.Errorf("repo flag not specified and no state file found in current working directory: %w", err)
 	}

internal/config/config_test.go

@@ -364,7 +364,7 @@ func TestDeriveRepo(t *testing.T) {
 				if err := os.MkdirAll(stateDir, 0755); err != nil {
 					t.Fatal(err)
 				}
-				stateFile := filepath.Join(stateDir, pipelineStateFile)
+				stateFile := filepath.Join(stateDir, LibrarianStateFile)
 				if err := os.WriteFile(stateFile, []byte("test"), 0644); err != nil {
 					t.Fatal(err)
 				}
@@ -439,7 +439,7 @@ func TestSetDefaults(t *testing.T) {
 				if err := os.MkdirAll(stateDir, 0755); err != nil {
 					t.Fatal(err)
 				}
-				stateFile := filepath.Join(stateDir, pipelineStateFile)
+				stateFile := filepath.Join(stateDir, LibrarianStateFile)
 				if err := os.WriteFile(stateFile, []byte("test"), 0644); err != nil {
 					t.Fatal(err)
 				}
@@ -454,7 +454,7 @@ func TestSetDefaults(t *testing.T) {
 				if err := os.MkdirAll(stateDir, 0755); err != nil {
 					t.Fatal(err)
 				}
-				stateFile := filepath.Join(stateDir, pipelineStateFile)
+				stateFile := filepath.Join(stateDir, LibrarianStateFile)
 				if err := os.WriteFile(stateFile, []byte("test"), 0644); err != nil {
 					t.Fatal(err)
 				}

internal/librarian/action_test.go

@@ -35,10 +35,6 @@ func TestLibrarianAction(t *testing.T) {
 			name: "init",
 			fn:   newCmdInit,
 		},
-		{
-			name: "tag-and-release",
-			fn:   newCmdTagAndRelease,
-		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			testActionConfig(t, test.fn())

internal/librarian/commit_version_analyzer.go

@@ -30,7 +30,7 @@ const defaultTagFormat = "{id}-{version}"
 // GetConventionalCommitsSinceLastRelease returns all conventional commits for the given library since the
 // version specified in the state file.
 func GetConventionalCommitsSinceLastRelease(repo gitrepo.Repository, library *config.LibraryState) ([]*conventionalcommits.ConventionalCommit, error) {
-	tag := formatTag(library, "")
+	tag := formatTag(library.TagFormat, library.ID, library.Version)
 	commits, err := repo.GetCommitsForPathsSinceTag(library.SourceRoots, tag)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get commits for library %s: %w", library.ID, err)
@@ -101,16 +101,11 @@ func shouldExclude(files, excludePaths []string) bool {
 }
 
 // formatTag returns the git tag for a given library version.
-func formatTag(library *config.LibraryState, versionOverride string) string {
-	version := library.Version
-	if versionOverride != "" {
-		version = versionOverride
-	}
-	tagFormat := library.TagFormat
+func formatTag(tagFormat string, libraryID string, version string) string {
 	if tagFormat == "" {
 		tagFormat = defaultTagFormat
 	}
-	r := strings.NewReplacer("{id}", library.ID, "{version}", version)
+	r := strings.NewReplacer("{id}", libraryID, "{version}", version)
 	return r.Replace(tagFormat)
 }
 

internal/librarian/commit_version_analyzer_test.go

@@ -110,7 +110,7 @@ func TestFormatTag(t *testing.T) {
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			got := formatTag(test.library, "")
+			got := formatTag(test.library.TagFormat, test.library.ID, test.library.Version)
 			if got != test.want {
 				t.Errorf("formatTag() = %q, want %q", got, test.want)
 			}

internal/librarian/mocks_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/googleapis/librarian/internal/docker"
 	"github.com/googleapis/librarian/internal/github"
 	"github.com/googleapis/librarian/internal/gitrepo"
+	"gopkg.in/yaml.v3"
 )
 
 // mockGitHubClient is a mock implementation of the GitHubClient interface for testing.
@@ -54,9 +55,13 @@ type mockGitHubClient struct {
 	pullRequests            []*github.PullRequest
 	pullRequest             *github.PullRequest
 	createdRelease          *github.RepositoryRelease
+	librarianState          *config.LibrarianState
 }
 
 func (m *mockGitHubClient) GetRawContent(ctx context.Context, path, ref string) ([]byte, error) {
+	if path == ".librarian/state.yaml" && m.librarianState != nil {
+		return yaml.Marshal(m.librarianState)
+	}
 	return m.rawContent, m.rawErr
 }
 

internal/librarian/release_notes.go

@@ -277,8 +277,8 @@ func formatLibraryReleaseNotes(repo gitrepo.Repository, library *config.LibraryS
 
 	// The version should already be updated to the next version.
 	newVersion := library.Version
-	newTag := formatTag(library, newVersion)
-	previousTag := formatTag(library, library.PreviousVersion)
+	newTag := formatTag(library.TagFormat, library.ID, newVersion)
+	previousTag := formatTag(library.TagFormat, library.ID, library.PreviousVersion)
 
 	commitsByType := make(map[string][]*conventionalcommits.ConventionalCommit)
 	for _, commit := range library.Changes {

internal/librarian/state.go

@@ -16,11 +16,13 @@ package librarian
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 
@@ -47,6 +49,18 @@ func loadRepoState(repo *gitrepo.LocalRepository, source string) (*config.Librar
 	return parseLibrarianState(path, source)
 }
 
+func loadRepoStateFromGitHub(ctx context.Context, ghClient GitHubClient, branch string) (*config.LibrarianState, error) {
+	content, err := ghClient.GetRawContent(ctx, path.Join(config.LibrarianDir, config.LibrarianStateFile), branch)
+	if err != nil {
+		return nil, err
+	}
+	cfg, err := loadLibrarianStateFromBytes(content, "")
+	if err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}
+
 func loadLibrarianConfig(repo *gitrepo.LocalRepository) (*config.LibrarianConfig, error) {
 	if repo == nil {
 		slog.Info("repo is nil, skipping state loading")
@@ -61,8 +75,12 @@ func parseLibrarianState(path, source string) (*config.LibrarianState, error) {
 	if err != nil {
 		return nil, err
 	}
+	return loadLibrarianStateFromBytes(bytes, source)
+}
+
+func loadLibrarianStateFromBytes(data []byte, source string) (*config.LibrarianState, error) {
 	var s config.LibrarianState
-	if err := yaml.Unmarshal(bytes, &s); err != nil {
+	if err := yaml.Unmarshal(data, &s); err != nil {
 		return nil, fmt.Errorf("unmarshaling librarian state: %w", err)
 	}
 	if err := populateServiceConfigIfEmpty(&s, source); err != nil {

internal/librarian/state_test.go

@@ -15,12 +15,15 @@
 package librarian
 
 import (
+	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/googleapis/librarian/internal/config"
 	"gopkg.in/yaml.v3"
 )
@@ -423,3 +426,71 @@ func TestReadLibraryState(t *testing.T) {
 		})
 	}
 }
+
+func TestLoadRepoStateFromGitHub(t *testing.T) {
+	t.Parallel()
+
+	state := &config.LibrarianState{
+		Image: "gcr.io/some-project-id/some-test-image:latest",
+		Libraries: []*config.LibraryState{
+			{
+				ID:          "google-cloud-storage",
+				SourceRoots: []string{"some/path"},
+				TagFormat:   "v{version}",
+			},
+		},
+	}
+	for _, test := range []struct {
+		name       string
+		branch     string
+		ghClient   GitHubClient
+		want       *config.LibrarianState
+		wantErr    bool
+		wantErrMsg string
+	}{
+		{
+			name: "happy path",
+			ghClient: &mockGitHubClient{
+				librarianState: state,
+			},
+			want: state,
+		},
+		{
+			name: "missing file",
+			ghClient: &mockGitHubClient{
+				rawErr: fmt.Errorf("file not found"),
+			},
+			wantErr:    true,
+			wantErrMsg: "file not found",
+		},
+		{
+			name: "invalid state file",
+			ghClient: &mockGitHubClient{
+				librarianState: &config.LibrarianState{},
+			},
+			wantErr:    true,
+			wantErrMsg: "validating librarian state",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := loadRepoStateFromGitHub(context.Background(), test.ghClient, test.branch)
+			if test.wantErr {
+				if err == nil {
+					t.Fatal("loadRepoStateFromGitHub() should fail")
+				}
+				if !strings.Contains(err.Error(), test.wantErrMsg) {
+					t.Fatalf("want error message: %s, got %s", test.wantErrMsg, err.Error())
+				}
+
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("loadRepoStateFromGitHub() unexpected error: %v", err)
+			}
+			if diff := cmp.Diff(test.want, got, cmpopts.EquateEmpty()); diff != "" {
+				t.Fatalf("Response library state mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}

internal/librarian/tag_and_release.go

@@ -27,7 +27,6 @@ import (
 
 	"github.com/googleapis/librarian/internal/config"
 	"github.com/googleapis/librarian/internal/github"
-	"github.com/googleapis/librarian/internal/gitrepo"
 )
 
 const (
@@ -45,23 +44,20 @@ var (
 type tagAndReleaseRunner struct {
 	ghClient    GitHubClient
 	pullRequest string
-	repo        gitrepo.Repository
-	state       *config.LibrarianState
 }
 
 func newTagAndReleaseRunner(cfg *config.Config) (*tagAndReleaseRunner, error) {
-	runner, err := newCommandRunner(cfg)
-	if err != nil {
-		return nil, err
-	}
 	if cfg.GitHubToken == "" {
 		return nil, fmt.Errorf("`LIBRARIAN_GITHUB_TOKEN` must be set")
 	}
+	repo, err := github.ParseRemote(cfg.Repo)
+	if err != nil {
+		return nil, err
+	}
+	ghClient := github.NewClient(cfg.GitHubToken, repo)
 	return &tagAndReleaseRunner{
-		ghClient:    runner.ghClient,
+		ghClient:    ghClient,
 		pullRequest: cfg.PullRequest,
-		repo:        runner.repo,
-		state:       runner.state,
 	}, nil
 }
 
@@ -130,24 +126,30 @@ func (r *tagAndReleaseRunner) processPullRequest(ctx context.Context, p *github.
 		return nil
 	}
 
+	// Load library state from remote repo
+	libraryState, err := loadRepoStateFromGitHub(ctx, r.ghClient, *p.Base.Ref)
+	if err != nil {
+		return err
+	}
+
 	// Add a tag to the release commit to trigger louhi flow: "release-please-{pr number}"
-	//TODO: remove this logic as part of https://github.com/googleapis/librarian/issues/2044
+	// TODO: remove this logic as part of https://github.com/googleapis/librarian/issues/2044
 	commitSha := p.GetMergeCommitSHA()
 	tagName := fmt.Sprintf("release-please-%d", p.GetNumber())
 	if err := r.ghClient.CreateTag(ctx, tagName, commitSha); err != nil {
 		return fmt.Errorf("failed to create tag %s: %w", tagName, err)
 	}
-
 	for _, release := range releases {
 		slog.Info("creating release", "library", release.Library, "version", release.Version)
 
-		lib := r.state.LibraryByID(release.Library)
-		if lib == nil {
-			return fmt.Errorf("library %s not found", release.Library)
+		tagFormat, err := determineTagFormat(release.Library, libraryState)
+		if err != nil {
+			slog.Warn("could not determine tag format", "library", release.Library)
+			return err
 		}
 
 		// Create the release.
-		tagName := formatTag(lib, release.Version)
+		tagName := formatTag(tagFormat, release.Library, release.Version)
 		releaseName := fmt.Sprintf("%s %s", release.Library, release.Version)
 		if _, err := r.ghClient.CreateRelease(ctx, tagName, releaseName, release.Body, commitSha); err != nil {
 			return fmt.Errorf("failed to create release: %w", err)
@@ -157,6 +159,18 @@ func (r *tagAndReleaseRunner) processPullRequest(ctx context.Context, p *github.
 	return r.replacePendingLabel(ctx, p)
 }
 
+func determineTagFormat(libraryID string, librarianState *config.LibrarianState) (string, error) {
+	// TODO(#2177): read from LibrarianConfig
+	libraryState := librarianState.LibraryByID(libraryID)
+	if libraryState == nil {
+		return "", fmt.Errorf("library %s not found", libraryID)
+	}
+	if libraryState.TagFormat != "" {
+		return libraryState.TagFormat, nil
+	}
+	return "", fmt.Errorf("library %s did not configure tag_format", libraryID)
+}
+
 // libraryRelease holds the parsed information from a pull request body.
 type libraryRelease struct {
 	// Body contains the release notes.