internal/stdlib/gorepo.go - pkgsite - Git at Google

 // Copyright 2022 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 stdlib

 import (
 	"bytes"
 	"context"
 	"fmt"
 	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"

 	"golang.org/x/pkgsite/internal/derrors"
 	"golang.org/x/pkgsite/internal/version"
 )

 // A goRepo represents a git repo holding the Go standard library.
 type goRepo interface {
 	// Clone the repo at the given version to the directory.
 	clone(ctx context.Context, version string, toDirectory string) (hash string, err error)

 	// Return all the refs of the repo.
 	refs(ctx context.Context) ([]ref, error)
 }

 type remoteGoRepo struct{}

 func (remoteGoRepo) clone(ctx context.Context, v, directory string) (hash string, err error) {
 	defer derrors.Wrap(&err, "remoteGoRepo.clone(%q)", v)

 	refName, err := refNameForVersion(v)
 	if err != nil {
 		return "", err
 	}
 	if err := os.MkdirAll(directory, 0777); err != nil {
 		return "", err
 	}
 	cmd := exec.CommandContext(ctx, "git", "init")
 	cmd.Dir = directory
 	if err := cmd.Run(); err != nil {
 		return "", err
 	}
 	cmd = exec.CommandContext(ctx, "git", "fetch", "-f", "--depth=1", "--", GoRepoURL, refName)
 	cmd.Dir = directory
 	if b, err := cmd.CombinedOutput(); err != nil {
 		return "", fmt.Errorf("running git fetch: %v: %s", err, b)
 	}
 	cmd = exec.CommandContext(ctx, "git", "rev-parse", "FETCH_HEAD")
 	cmd.Dir = directory
 	b, err := cmd.Output()
 	if err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			return "", fmt.Errorf("running git rev-parse: %v: %s", err, ee.Stderr)
 		}
 		return "", fmt.Errorf("running git rev-parse: %v", err)
 	}
 	cmd = exec.CommandContext(ctx, "git", "checkout", "FETCH_HEAD")
 	cmd.Dir = directory
 	if err := cmd.Run(); err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			return "", fmt.Errorf("running git checkout: %v: %s", err, ee.Stderr)
 		}
 		return "", fmt.Errorf("running git checkout: %v", err)
 	}
 	return strings.TrimSpace(string(b)), nil
 }

 type ref struct {
 	hash string
 	name string
 }

 func (remoteGoRepo) refs(ctx context.Context) ([]ref, error) {
 	cmd := exec.CommandContext(ctx, "git", "ls-remote", "--", GoRepoURL)
 	b, err := cmd.Output()
 	if err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			return nil, fmt.Errorf("running git ls-remote: %v: %s", err, ee.Stderr)
 		}
 		return nil, fmt.Errorf("running git ls-remote: %v", err)
 	}
 	return gitOutputToRefs(b)
 }

 func gitOutputToRefs(b []byte) ([]ref, error) {
 	var refs []ref
 	b = bytes.TrimSpace(b)
 	for _, line := range bytes.Split(b, []byte("\n")) {
 		fields := bytes.Fields(line)
 		if len(fields) != 2 {
 			return nil, fmt.Errorf("invalid line in output from git ls-remote: %q: should have two fields", line)
 		}
 		refs = append(refs, ref{hash: string(fields[0]), name: string(fields[1])})
 	}
 	return refs, nil
 }

 type localGoRepo struct {
 	path string
 }

 func newLocalGoRepo(path string) *localGoRepo {
 	return &localGoRepo{
 		path: path,
 	}
 }

 func (g *localGoRepo) refs(ctx context.Context) (refs []ref, err error) {
 	defer derrors.Wrap(&err, "localGoRepo(%s).refs", g.path)

 	cmd := exec.CommandContext(ctx, "git", "show-ref")
 	cmd.Dir = g.path
 	b, err := cmd.Output()
 	if err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			return nil, fmt.Errorf("running git show-ref: %s", ee.Stderr)
 		}
 		return nil, fmt.Errorf("running git show-ref: %v", err)
 	}
 	return gitOutputToRefs(b)
 }

 func (g *localGoRepo) clone(ctx context.Context, v, directory string) (hash string, err error) {
 	return "", nil
 }

 type testGoRepo struct {
 }

 func (t *testGoRepo) clone(ctx context.Context, v, directory string) (hash string, err error) {
 	defer derrors.Wrap(&err, "testGoRepo.clone(%q)", v)
 	if v == TestMasterVersion {
 		v = version.Master
 	}
 	cmd := exec.CommandContext(ctx, "git", "init")
 	cmd.Dir = directory
 	if err := cmd.Run(); err != nil {
 		return "", err
 	}
 	testdatadir := filepath.Join(testDataPath("testdata"), v)
 	err = filepath.Walk(testdatadir, func(path string, info fs.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
 		rel, err := filepath.Rel(testdatadir, path)
 		if err != nil {
 			return err
 		}
 		dstpath := filepath.Join(directory, rel)
 		if info.Mode().IsDir() {
 			os.MkdirAll(dstpath, 0777)
 			return nil
 		}
 		b, err := os.ReadFile(path)
 		if err != nil {
 			return fmt.Errorf("reading %q: %v", path, err)
 		}
 		os.WriteFile(dstpath, b, 0666)
 		cmd := exec.CommandContext(ctx, "git", "add", "--", dstpath)
 		cmd.Dir = directory
 		if err := cmd.Run(); err != nil {
 			return fmt.Errorf("running git add: %v", err)
 		}
 		return nil
 	})
 	if err != nil {
 		return "", err
 	}
 	cmd = exec.CommandContext(ctx, "git", "commit", "--allow-empty-message", "--author=Joe Random <joe@example.com>",
 		"--message=")
 	cmd.Dir = directory
 	commitTime := fmt.Sprintf("%v +0000", TestCommitTime.Unix())
 	name := "Joe Random"
 	email := "joe@example.com"
 	cmd.Env = append(cmd.Environ(), []string{
 		"GIT_COMMITTER_NAME=" + name, "GIT_AUTHOR_NAME=" + name,
 		"GIT_COMMITTER_EMAIL=" + email, "GIT_AUTHOR_EMAIL=" + email,
 		"GIT_COMMITTER_DATE=" + commitTime, "GIT_AUTHOR_DATE=" + commitTime}...)
 	if err := cmd.Run(); err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			return "", fmt.Errorf("running git commit: %v: %s", err, ee.Stderr)
 		}
 		return "", fmt.Errorf("running git commit: %v", err)
 	}
 	cmd = exec.CommandContext(ctx, "git", "rev-parse", "HEAD")
 	cmd.Dir = directory
 	b, err := cmd.Output()
 	if err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			return "", fmt.Errorf("running git rev-parse: %v: %s", err, ee.Stderr)
 		}
 		return "", fmt.Errorf("running git rev-parse: %v", err)
 	}
 	return strings.TrimSpace(string(b)), nil
 }

 // testDataPath returns a path corresponding to a path relative to the calling
 // test file. For convenience, rel is assumed to be "/"-delimited.
 // It is a copy of testhelper.TestDataPath, which we can't use in this
 // file because it is supposed to only be depended on by test files.
 //
 // It panics on failure.
 func testDataPath(rel string) string {
 	_, filename, _, ok := runtime.Caller(1)
 	if !ok {
 		panic("unable to determine relative path")
 	}
 	return filepath.Clean(filepath.Join(filepath.Dir(filename), filepath.FromSlash(rel)))
 }

 // References used for Versions during testing.
 var testRefs = []string{
 	// stdlib versions
 	"refs/tags/go1.2.1",
 	"refs/tags/go1.3.2",
 	"refs/tags/go1.4.2",
 	"refs/tags/go1.4.3",
 	"refs/tags/go1.6",
 	"refs/tags/go1.6.3",
 	"refs/tags/go1.6beta1",
 	"refs/tags/go1.8",
 	"refs/tags/go1.8rc2",
 	"refs/tags/go1.9rc1",
 	"refs/tags/go1.11",
 	"refs/tags/go1.12",
 	"refs/tags/go1.12.1",
 	"refs/tags/go1.12.5",
 	"refs/tags/go1.12.9",
 	"refs/tags/go1.13",
 	"refs/tags/go1.13beta1",
 	"refs/tags/go1.14.6",
 	"refs/tags/go1.21.0",
 	"refs/heads/dev.fuzz",
 	"refs/heads/master",
 	// other tags
 	"refs/changes/56/93156/13",
 	"refs/tags/release.r59",
 	"refs/tags/weekly.2011-04-13",
 }

 func (t *testGoRepo) refs(ctx context.Context) ([]ref, error) {
 	var rs []ref
 	for _, r := range testRefs {
 		// Only the name is ever used, so the referent can be empty.
 		rs = append(rs, ref{name: r})
 	}
 	return rs, nil
 }
	// Copyright 2022 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 stdlib

	import (
	"bytes"
	"context"
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"

	"golang.org/x/pkgsite/internal/derrors"
	"golang.org/x/pkgsite/internal/version"
	)

	// A goRepo represents a git repo holding the Go standard library.
	type goRepo interface {
	// Clone the repo at the given version to the directory.
	clone(ctx context.Context, version string, toDirectory string) (hash string, err error)

	// Return all the refs of the repo.
	refs(ctx context.Context) ([]ref, error)
	}

	type remoteGoRepo struct{}

	func (remoteGoRepo) clone(ctx context.Context, v, directory string) (hash string, err error) {
	defer derrors.Wrap(&err, "remoteGoRepo.clone(%q)", v)

	refName, err := refNameForVersion(v)
	if err != nil {
	return "", err
	}
	if err := os.MkdirAll(directory, 0777); err != nil {
	return "", err
	}
	cmd := exec.CommandContext(ctx, "git", "init")
	cmd.Dir = directory
	if err := cmd.Run(); err != nil {
	return "", err
	}
	cmd = exec.CommandContext(ctx, "git", "fetch", "-f", "--depth=1", "--", GoRepoURL, refName)
	cmd.Dir = directory
	if b, err := cmd.CombinedOutput(); err != nil {
	return "", fmt.Errorf("running git fetch: %v: %s", err, b)
	}
	cmd = exec.CommandContext(ctx, "git", "rev-parse", "FETCH_HEAD")
	cmd.Dir = directory
	b, err := cmd.Output()
	if err != nil {
	if ee, ok := err.(*exec.ExitError); ok {
	return "", fmt.Errorf("running git rev-parse: %v: %s", err, ee.Stderr)
	}
	return "", fmt.Errorf("running git rev-parse: %v", err)
	}
	cmd = exec.CommandContext(ctx, "git", "checkout", "FETCH_HEAD")
	cmd.Dir = directory
	if err := cmd.Run(); err != nil {
	if ee, ok := err.(*exec.ExitError); ok {
	return "", fmt.Errorf("running git checkout: %v: %s", err, ee.Stderr)
	}
	return "", fmt.Errorf("running git checkout: %v", err)
	}
	return strings.TrimSpace(string(b)), nil
	}

	type ref struct {
	hash string
	name string
	}

	func (remoteGoRepo) refs(ctx context.Context) ([]ref, error) {
	cmd := exec.CommandContext(ctx, "git", "ls-remote", "--", GoRepoURL)
	b, err := cmd.Output()
	if err != nil {
	if ee, ok := err.(*exec.ExitError); ok {
	return nil, fmt.Errorf("running git ls-remote: %v: %s", err, ee.Stderr)
	}
	return nil, fmt.Errorf("running git ls-remote: %v", err)
	}
	return gitOutputToRefs(b)
	}

	func gitOutputToRefs(b []byte) ([]ref, error) {
	var refs []ref
	b = bytes.TrimSpace(b)
	for _, line := range bytes.Split(b, []byte("\n")) {
	fields := bytes.Fields(line)
	if len(fields) != 2 {
	return nil, fmt.Errorf("invalid line in output from git ls-remote: %q: should have two fields", line)
	}
	refs = append(refs, ref{hash: string(fields[0]), name: string(fields[1])})
	}
	return refs, nil
	}

	type localGoRepo struct {
	path string
	}

	func newLocalGoRepo(path string) *localGoRepo {
	return &localGoRepo{
	path: path,
	}
	}

	func (g *localGoRepo) refs(ctx context.Context) (refs []ref, err error) {
	defer derrors.Wrap(&err, "localGoRepo(%s).refs", g.path)

	cmd := exec.CommandContext(ctx, "git", "show-ref")
	cmd.Dir = g.path
	b, err := cmd.Output()
	if err != nil {
	if ee, ok := err.(*exec.ExitError); ok {
	return nil, fmt.Errorf("running git show-ref: %s", ee.Stderr)
	}
	return nil, fmt.Errorf("running git show-ref: %v", err)
	}
	return gitOutputToRefs(b)
	}

	func (g *localGoRepo) clone(ctx context.Context, v, directory string) (hash string, err error) {
	return "", nil
	}

	type testGoRepo struct {
	}

	func (t *testGoRepo) clone(ctx context.Context, v, directory string) (hash string, err error) {
	defer derrors.Wrap(&err, "testGoRepo.clone(%q)", v)
	if v == TestMasterVersion {
	v = version.Master
	}
	cmd := exec.CommandContext(ctx, "git", "init")
	cmd.Dir = directory
	if err := cmd.Run(); err != nil {
	return "", err
	}
	testdatadir := filepath.Join(testDataPath("testdata"), v)
	err = filepath.Walk(testdatadir, func(path string, info fs.FileInfo, err error) error {
	if err != nil {
	return err
	}
	rel, err := filepath.Rel(testdatadir, path)
	if err != nil {
	return err
	}
	dstpath := filepath.Join(directory, rel)
	if info.Mode().IsDir() {
	os.MkdirAll(dstpath, 0777)
	return nil
	}
	b, err := os.ReadFile(path)
	if err != nil {
	return fmt.Errorf("reading %q: %v", path, err)
	}
	os.WriteFile(dstpath, b, 0666)
	cmd := exec.CommandContext(ctx, "git", "add", "--", dstpath)
	cmd.Dir = directory
	if err := cmd.Run(); err != nil {
	return fmt.Errorf("running git add: %v", err)
	}
	return nil
	})
	if err != nil {
	return "", err
	}
	cmd = exec.CommandContext(ctx, "git", "commit", "--allow-empty-message", "--author=Joe Random <joe@example.com>",
	"--message=")
	cmd.Dir = directory
	commitTime := fmt.Sprintf("%v +0000", TestCommitTime.Unix())
	name := "Joe Random"
	email := "joe@example.com"
	cmd.Env = append(cmd.Environ(), []string{
	"GIT_COMMITTER_NAME=" + name, "GIT_AUTHOR_NAME=" + name,
	"GIT_COMMITTER_EMAIL=" + email, "GIT_AUTHOR_EMAIL=" + email,
	"GIT_COMMITTER_DATE=" + commitTime, "GIT_AUTHOR_DATE=" + commitTime}...)
	if err := cmd.Run(); err != nil {
	if ee, ok := err.(*exec.ExitError); ok {
	return "", fmt.Errorf("running git commit: %v: %s", err, ee.Stderr)
	}
	return "", fmt.Errorf("running git commit: %v", err)
	}
	cmd = exec.CommandContext(ctx, "git", "rev-parse", "HEAD")
	cmd.Dir = directory
	b, err := cmd.Output()
	if err != nil {
	if ee, ok := err.(*exec.ExitError); ok {
	return "", fmt.Errorf("running git rev-parse: %v: %s", err, ee.Stderr)
	}
	return "", fmt.Errorf("running git rev-parse: %v", err)
	}
	return strings.TrimSpace(string(b)), nil
	}

	// testDataPath returns a path corresponding to a path relative to the calling
	// test file. For convenience, rel is assumed to be "/"-delimited.
	// It is a copy of testhelper.TestDataPath, which we can't use in this
	// file because it is supposed to only be depended on by test files.
	//
	// It panics on failure.
	func testDataPath(rel string) string {
	_, filename, _, ok := runtime.Caller(1)
	if !ok {
	panic("unable to determine relative path")
	}
	return filepath.Clean(filepath.Join(filepath.Dir(filename), filepath.FromSlash(rel)))
	}

	// References used for Versions during testing.
	var testRefs = []string{
	// stdlib versions
	"refs/tags/go1.2.1",
	"refs/tags/go1.3.2",
	"refs/tags/go1.4.2",
	"refs/tags/go1.4.3",
	"refs/tags/go1.6",
	"refs/tags/go1.6.3",
	"refs/tags/go1.6beta1",
	"refs/tags/go1.8",
	"refs/tags/go1.8rc2",
	"refs/tags/go1.9rc1",
	"refs/tags/go1.11",
	"refs/tags/go1.12",
	"refs/tags/go1.12.1",
	"refs/tags/go1.12.5",
	"refs/tags/go1.12.9",
	"refs/tags/go1.13",
	"refs/tags/go1.13beta1",
	"refs/tags/go1.14.6",
	"refs/tags/go1.21.0",
	"refs/heads/dev.fuzz",
	"refs/heads/master",
	// other tags
	"refs/changes/56/93156/13",
	"refs/tags/release.r59",
	"refs/tags/weekly.2011-04-13",
	}

	func (t *testGoRepo) refs(ctx context.Context) ([]ref, error) {
	var rs []ref
	for _, r := range testRefs {
	// Only the name is ever used, so the referent can be empty.
	rs = append(rs, ref{name: r})
	}
	return rs, nil
	}