Merge v6-transport, fix upload-requests atomic logic, and update tests

.github/workflows/git.yml

@@ -51,9 +51,6 @@ jobs:
     - name: Test
       run: make test-coverage
 
-    - name: Test SHA256
-      run: make test-sha256
-
     - name: Build go-git with CGO disabled
       run: go build ./...
       env:

CONTRIBUTING.md

@@ -35,8 +35,11 @@ In order for a PR to be accepted it needs to pass a list of requirements:
 ### Branches
 
 The development branch is `main`, where all development takes place.
-All new features and bug fixes should target it. This was formely known as `v6-exp`,
-as it contains all the changes for `v6` - the next major release.
+All new features and bug fixes should target it. This was formely known
+as `v6-exp` or `v6-transport`. This branch contains all the changes for
+`v6` - the next major release.
+From time to time this branch will contain breaking changes, as the API
+for `v6` is being refined.
 
 The `releases/v5.x` branch is the branch for changes to the `v5` version,
 which is now in maintaince mode. To avoid having to divert efforts from `v6`,

Makefile

@@ -34,12 +34,6 @@ test:
 	$(GOTEST) -race ./...
 	$(GOTEST) -v _examples/common_test.go _examples/common.go --examples
 
-TEMP_REPO := $(shell mktemp)
-test-sha256:
-	$(GOCMD) run -tags sha256 _examples/sha256/main.go $(TEMP_REPO)
-	cd $(TEMP_REPO) && git fsck
-	rm -rf $(TEMP_REPO)
-
 test-coverage:
 	@echo "running against `git version`"; \
 	echo "" > $(COVERAGE_REPORT); \

_examples/blame/main.go

@@ -10,24 +10,13 @@ import (
 
 // Basic example of how to blame a repository.
 func main() {
-	CheckArgs("<url>", "<file_to_blame>")
+	CheckArgs("<path>", "<file_to_blame>")
 	url := os.Args[1]
 	path := os.Args[2]
 
-	tmp, err := os.MkdirTemp("", "go-git-blame-*")
-	CheckIfError(err)
-
-	defer os.RemoveAll(tmp)
-
 	// Clone the given repository.
-	Info("git clone %s %s", url, tmp)
-	r, err := git.PlainClone(
-		tmp,
-		&git.CloneOptions{
-			URL:  url,
-			Tags: git.NoTags,
-		},
-	)
+	Info("git open %s", url)
+	r, err := git.PlainOpen(url)
 	CheckIfError(err)
 
 	// Retrieve the branch's HEAD, to then get the HEAD commit.

_examples/common_test.go

@@ -14,7 +14,7 @@ var examplesTest = flag.Bool("examples", false, "run the examples tests")
 var defaultURL = "https://github.com/git-fixtures/basic.git"
 
 var args = map[string][]string{
-	"blame":                      {defaultURL, "CHANGELOG"},
+	"blame":                      {cloneRepository(defaultURL, tempFolder()), "CHANGELOG"},
 	"branch":                     {defaultURL, tempFolder()},
 	"checkout":                   {defaultURL, tempFolder(), "35e85108805c84807bc66a02d91535e1e24b38b9"},
 	"checkout-branch":            {defaultURL, tempFolder(), "branch"},

_examples/remotes/main.go

@@ -20,7 +20,7 @@ import (
 func main() {
 	// Create a new repository
 	Info("git init")
-	r, err := git.Init(memory.NewStorage(), nil)
+	r, err := git.Init(memory.NewStorage())
 	CheckIfError(err)
 
 	// Add a new remote, with the default fetch refspec

_examples/sha256/main.go

@@ -23,7 +23,7 @@ func main() {
 	os.RemoveAll(directory)
 
 	// Init a new repository using the ObjectFormat SHA256.
-	r, err := git.PlainInitWithOptions(directory, &git.PlainInitOptions{ObjectFormat: config.SHA256})
+	r, err := git.PlainInit(directory, false, git.WithObjectFormat(config.SHA256))
 	CheckIfError(err)
 
 	w, err := r.Worktree()

backend/http/http.go

@@ -45,8 +45,11 @@ var services = []service{
 	{regexp.MustCompile("(.*?)/git-receive-pack$"), http.MethodPost, serviceRpc, transport.ReceivePackService},
 }
 
-// BackendOptions represents a set of options for the Git HTTP handler.
-type BackendOptions struct {
+// Backend represents a Git HTTP handler.
+type Backend struct {
+	// Loader is used to load repositories from the given endpoint. If nil,
+	// [Transport.DefaultLoader] is used.
+	Loader transport.Loader
 	// ErrorLog is the logger used to log errors. If nil, no errors are logged.
 	ErrorLog *log.Logger
 	// Prefix is a path prefix that will be stripped from the URL path before
@@ -63,55 +66,57 @@ type BackendOptions struct {
 // repositories that wish to be server using the Dumb-HTTP protocol must update
 // the server info files. This can be done by using
 // [transport.UpdateServerInfo] before serving the repository.
-func NewBackend(loader transport.Loader, opts *BackendOptions) http.HandlerFunc {
+func NewBackend(loader transport.Loader) *Backend {
 	if loader == nil {
 		loader = transport.DefaultLoader
 	}
-	if opts == nil {
-		opts = &BackendOptions{}
+	return &Backend{
+		Loader: loader,
 	}
-	return func(w http.ResponseWriter, r *http.Request) {
-		urlPath := r.URL.Path
-		urlPath = strings.TrimPrefix(urlPath, opts.Prefix)
-		for _, s := range services {
-			if m := s.pattern.FindStringSubmatch(urlPath); m != nil {
-				if r.Method != s.method {
-					renderStatusError(w, http.StatusMethodNotAllowed)
-					return
-				}
-
-				repo := strings.TrimPrefix(m[1], "/")
-				file := strings.Replace(urlPath, repo+"/", "", 1)
-				ep, err := transport.NewEndpoint(repo)
-				if err != nil {
-					logf(opts.ErrorLog, "error creating endpoint: %v", err)
-					renderStatusError(w, http.StatusBadRequest)
-					return
-				}
-
-				st, err := loader.Load(ep)
-				if err != nil {
-					logf(opts.ErrorLog, "error loading repository: %v", err)
-					renderStatusError(w, http.StatusNotFound)
-					return
-				}
-
-				ctx := r.Context()
-				ctx = context.WithValue(ctx, contextKey("errorLog"), opts.ErrorLog)
-				ctx = context.WithValue(ctx, contextKey("repo"), m[1])
-				ctx = context.WithValue(ctx, contextKey("file"), file)
-				ctx = context.WithValue(ctx, contextKey("service"), s.svc)
-				ctx = context.WithValue(ctx, contextKey("storer"), st)
-				ctx = context.WithValue(ctx, contextKey("endpoint"), ep)
-
-				s.handler(w, r.WithContext(ctx))
+}
+
+// ServeHTTP implements the [http.Handler] interface.
+func (b *Backend) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	urlPath := r.URL.Path
+	urlPath = strings.TrimPrefix(urlPath, b.Prefix)
+	for _, s := range services {
+		if m := s.pattern.FindStringSubmatch(urlPath); m != nil {
+			if r.Method != s.method {
+				renderStatusError(w, http.StatusMethodNotAllowed)
 				return
 			}
-		}
 
-		// If no service matched, return 404.
-		renderStatusError(w, http.StatusNotFound)
+			repo := strings.TrimPrefix(m[1], "/")
+			file := strings.Replace(urlPath, repo+"/", "", 1)
+			ep, err := transport.NewEndpoint(repo)
+			if err != nil {
+				logf(b.ErrorLog, "error creating endpoint: %v", err)
+				renderStatusError(w, http.StatusBadRequest)
+				return
+			}
+
+			st, err := b.Loader.Load(ep)
+			if err != nil {
+				logf(b.ErrorLog, "error loading repository: %v", err)
+				renderStatusError(w, http.StatusNotFound)
+				return
+			}
+
+			ctx := r.Context()
+			ctx = context.WithValue(ctx, contextKey("errorLog"), b.ErrorLog)
+			ctx = context.WithValue(ctx, contextKey("repo"), m[1])
+			ctx = context.WithValue(ctx, contextKey("file"), file)
+			ctx = context.WithValue(ctx, contextKey("service"), s.svc)
+			ctx = context.WithValue(ctx, contextKey("storer"), st)
+			ctx = context.WithValue(ctx, contextKey("endpoint"), ep)
+
+			s.handler(w, r.WithContext(ctx))
+			return
+		}
 	}
+
+	// If no service matched, return 404.
+	renderStatusError(w, http.StatusNotFound)
 }
 
 // logf logs the given message to the error log if it is set.

backend/http/http_test.go

@@ -30,7 +30,7 @@ func (f *fixturesLoader) Load(ep *transport.Endpoint) (storage.Storer, error) {
 }
 
 func TestNilLoaderBackend(t *testing.T) {
-	h := NewBackend(nil, nil)
+	h := NewBackend(nil)
 	req := httptest.NewRequest("GET", "/", nil)
 	w := httptest.NewRecorder()
 	h.ServeHTTP(w, req)
@@ -53,7 +53,7 @@ e8d3ffab552895c19b9fcf7aa264d277cde33881	refs/remotes/origin/branch
 00486ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/remotes/origin/master
 003e6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/tags/v1.0.0
 0000`
-	h := NewBackend(&fixturesLoader{t}, nil)
+	h := NewBackend(&fixturesLoader{t})
 
 	urlPath := "/basic.git/info/refs"
 	if isSmart {

blame_test.go

@@ -8,11 +8,10 @@ import (
 	"github.com/go-git/go-git/v6/plumbing/object"
 	"github.com/stretchr/testify/suite"
 
-	fixtures "github.com/go-git/go-git-fixtures/v4"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 )
 
 type BlameSuite struct {
-	suite.Suite
 	BaseSuite
 }
 

common_test.go

@@ -19,16 +19,11 @@ import (
 	"github.com/go-git/go-billy/v5/memfs"
 	"github.com/go-git/go-billy/v5/osfs"
 	"github.com/go-git/go-billy/v5/util"
-	fixtures "github.com/go-git/go-git-fixtures/v4"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 )
 
-type BaseFixtureSuite struct {
-	fixtures.Suite
-}
-
 type BaseSuite struct {
 	suite.Suite
-	BaseFixtureSuite
 	Repository *Repository
 
 	cache map[string]*Repository
@@ -49,25 +44,16 @@ func (s *BaseSuite) buildBasicRepository() {
 // is tagged as worktree the filesystem from fixture is used, otherwise a new
 // memfs filesystem is used as worktree.
 func (s *BaseSuite) NewRepository(f *fixtures.Fixture) *Repository {
-	var worktree, dotgit billy.Filesystem
+	dotgit := f.DotGit()
+	worktree := memfs.New()
 	if f.Is("worktree") {
-		r, err := PlainOpen(f.Worktree().Root())
-		if err != nil {
-			panic(err)
-		}
-
-		return r
+		worktree = f.Worktree()
 	}
 
-	dotgit = f.DotGit()
-	worktree = memfs.New()
-
 	st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault())
 
 	r, err := Open(st, worktree)
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(err)
 
 	return r
 }
@@ -109,19 +95,11 @@ func (s *BaseSuite) NewRepositoryFromPackfile(f *fixtures.Fixture) *Repository {
 	p := f.Packfile()
 	defer func() { _ = p.Close() }()
 
-	if err := packfile.UpdateObjectStorage(storer, p); err != nil {
-		panic(err)
-	}
-
-	err := storer.SetReference(plumbing.NewHashReference(plumbing.HEAD, plumbing.NewHash(f.Head)))
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(packfile.UpdateObjectStorage(storer, p))
+	s.Require().NoError(storer.SetReference(plumbing.NewHashReference(plumbing.HEAD, plumbing.NewHash(f.Head))))
 
 	r, err := Open(storer, memfs.New())
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(err)
 
 	s.cache[h] = r
 	return r
@@ -133,20 +111,16 @@ func (s *BaseSuite) GetBasicLocalRepositoryURL() string {
 }
 
 func (s *BaseSuite) GetLocalRepositoryURL(f *fixtures.Fixture) string {
-	return f.DotGit().Root()
+	return f.DotGit(fixtures.WithTargetDir(s.T().TempDir)).Root()
 }
 
 func (s *BaseSuite) TemporalHomeDir() (path string, clean func()) {
 	home, err := os.UserHomeDir()
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(err)
 
 	fs := osfs.New(home)
 	relPath, err := util.TempDir(fs, "", "")
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(err)
 
 	path = fs.Join(fs.Root(), relPath)
 	clean = func() {
@@ -157,23 +131,14 @@ func (s *BaseSuite) TemporalHomeDir() (path string, clean func()) {
 }
 
 func (s *BaseSuite) TemporalFilesystem() (fs billy.Filesystem) {
-	// TODO: Use s.T().TempDir() here, but it fails. Investigate why.
-	tmpDir, err := os.MkdirTemp("", "")
-	if err != nil {
-		panic(err)
-	}
-	fs = osfs.New(tmpDir)
+	fs = osfs.New(s.T().TempDir())
 	path, err := util.TempDir(fs, "", "")
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(err)
 
 	fs, err = fs.Chroot(path)
-	if err != nil {
-		panic(err)
-	}
+	s.Require().NoError(err)
 
-	return
+	return fs
 }
 
 type SuiteCommon struct {

config/config.go

@@ -490,7 +490,7 @@ func (c *Config) marshalExtensions() {
 	// ignore them otherwise.
 	if c.Core.RepositoryFormatVersion == format.Version_1 {
 		s := c.Raw.Section(extensionsSection)
-		s.SetOption(objectFormat, string(c.Extensions.ObjectFormat))
+		s.SetOption(objectFormat, c.Extensions.ObjectFormat.String())
 	}
 }
 

crypto.go

@@ -0,0 +1,7 @@
+package git
+
+import (
+	_ "crypto/sha256" // Register Go's SHA256 implementation.
+
+	_ "github.com/pjbgf/sha1cd" // Register sha1cd implementation.
+)