plumbing: transport, move client registry

plumbing/server/server_test.go

···
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/server"
 	"github.com/go-git/go-git/v5/plumbing/transport"
-	"github.com/go-git/go-git/v5/plumbing/transport/client"
+	"github.com/go-git/go-git/v5/plumbing/transport/file"
 	"github.com/go-git/go-git/v5/storage/filesystem"
 	"github.com/go-git/go-git/v5/storage/memory"
 
···
 		s.client = server.NewServer(s.loader)
 	}
 
-	s.clientBackup = client.Protocols["file"]
-	client.Protocols["file"] = s.client
+	s.clientBackup = file.DefaultClient
+	transport.Register("file", s.client)
 }
 
 func (s *BaseSuite) TearDownSuite(c *C) {
 	if s.clientBackup == nil {
-		delete(client.Protocols, "file")
+		transport.Unregister("file")
 	} else {
-		client.Protocols["file"] = s.clientBackup
+		transport.Register("file", s.clientBackup)
 	}
 }
 

plumbing/transport/client/client.go

···
-// Package client contains helper function to deal with the different client
-// protocols.
-package client
-
-import (
-	"fmt"
-
-	"github.com/go-git/go-git/v5/plumbing/transport"
-	"github.com/go-git/go-git/v5/plumbing/transport/file"
-	"github.com/go-git/go-git/v5/plumbing/transport/git"
-	"github.com/go-git/go-git/v5/plumbing/transport/http"
-	"github.com/go-git/go-git/v5/plumbing/transport/ssh"
-)
-
-// Protocols are the protocols supported by default.
-var Protocols = map[string]transport.Transport{
-	"http":  http.DefaultClient,
-	"https": http.DefaultClient,
-	"ssh":   ssh.DefaultClient,
-	"git":   git.DefaultClient,
-	"file":  file.DefaultClient,
-}
-
-// InstallProtocol adds or modifies an existing protocol.
-func InstallProtocol(scheme string, c transport.Transport) {
-	if c == nil {
-		delete(Protocols, scheme)
-		return
-	}
-
-	Protocols[scheme] = c
-}
-
-// NewClient returns the appropriate client among of the set of known protocols:
-// http://, https://, ssh:// and file://.
-// See `InstallProtocol` to add or modify protocols.
-func NewClient(endpoint *transport.Endpoint) (transport.Transport, error) {
-	return getTransport(endpoint)
-}
-
-func getTransport(endpoint *transport.Endpoint) (transport.Transport, error) {
-	f, ok := Protocols[endpoint.Protocol]
-	if !ok {
-		return nil, fmt.Errorf("unsupported scheme %q", endpoint.Protocol)
-	}
-
-	if f == nil {
-		return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", endpoint.Protocol)
-	}
-	return f, nil
-}

plumbing/transport/client/client_test.go plumbing/transport/registry_test.go

···
-package client
+package transport_test
 
 import (
 	"net/http"
-	"testing"
 
-	"github.com/go-git/go-git/v5/plumbing/transport"
+	_ "github.com/go-git/go-git/v5/plumbing/transport/ssh" // ssh transport
 
+	"github.com/go-git/go-git/v5/plumbing/transport"
 	. "gopkg.in/check.v1"
 )
-
-func Test(t *testing.T) { TestingT(t) }
 
 type ClientSuite struct{}
 
···
 	e, err := transport.NewEndpoint("ssh://github.com/src-d/go-git")
 	c.Assert(err, IsNil)
 
-	output, err := NewClient(e)
+	output, err := transport.Get(e.Protocol)
 	c.Assert(err, IsNil)
 	c.Assert(output, NotNil)
 }
···
 	e, err := transport.NewEndpoint("unknown://github.com/src-d/go-git")
 	c.Assert(err, IsNil)
 
-	_, err = NewClient(e)
+	_, err = transport.Get(e.Protocol)
 	c.Assert(err, NotNil)
 }
 
 func (s *ClientSuite) TestNewClientNil(c *C) {
-	Protocols["newscheme"] = nil
+	transport.Register("newscheme", nil)
 	e, err := transport.NewEndpoint("newscheme://github.com/src-d/go-git")
 	c.Assert(err, IsNil)
 
-	_, err = NewClient(e)
+	_, err = transport.Get(e.Protocol)
 	c.Assert(err, NotNil)
 }
 
 func (s *ClientSuite) TestInstallProtocol(c *C) {
-	InstallProtocol("newscheme", &dummyClient{})
-	c.Assert(Protocols["newscheme"], NotNil)
+	transport.Register("newscheme", &dummyClient{})
+	p, err := transport.Get("newscheme")
+	c.Assert(err, IsNil)
+	c.Assert(p, NotNil)
 }
 
 func (s *ClientSuite) TestInstallProtocolNilValue(c *C) {
-	InstallProtocol("newscheme", &dummyClient{})
-	InstallProtocol("newscheme", nil)
+	transport.Register("newscheme", &dummyClient{})
+	transport.Unregister("newscheme")
 
-	_, ok := Protocols["newscheme"]
-	c.Assert(ok, Equals, false)
+	_, err := transport.Get("newscheme")
+	c.Assert(err, NotNil)
 }
 
 type dummyClient struct {

plumbing/transport/client/example_test.go plumbing/transport/registry_example_test.go

···
-package client_test
+package transport_test
 
 import (
 	"crypto/tls"
 	"net/http"
 
-	"github.com/go-git/go-git/v5/plumbing/transport/client"
+	"github.com/go-git/go-git/v5/plumbing/transport"
 	githttp "github.com/go-git/go-git/v5/plumbing/transport/http"
 )
 
···
 	}
 
 	// Install it as default client for https URLs.
-	client.InstallProtocol("https", githttp.NewClient(httpClient))
+	transport.Register("https", githttp.NewClient(httpClient))
 }

plumbing/transport/file/client.go

···
 	"golang.org/x/sys/execabs"
 )
 
+func init() {
+	transport.Register("file", DefaultClient)
+}
+
 // DefaultClient is the default local client.
 var DefaultClient = NewClient(
 	transport.UploadPackServiceName,

plumbing/transport/git/common.go

···
 	"github.com/go-git/go-git/v5/utils/ioutil"
 )
 
+func init() {
+	transport.Register("git", DefaultClient)
+}
+
 // DefaultClient is the default git client.
 var DefaultClient = transport.NewClient(&runner{})
 

plumbing/transport/http/common.go

···
 	"github.com/golang/groupcache/lru"
 )
 
+func init() {
+	transport.Register("http", DefaultClient)
+	transport.Register("https", DefaultClient)
+}
+
 // it requires a bytes.Buffer, because we need to know the length
 func applyHeadersToRequest(req *http.Request, content *bytes.Buffer, host string, requestType string) {
 	req.Header.Add("User-Agent", "git/1.0")

plumbing/transport/registry.go

···
+package transport
+
+import (
+	"fmt"
+	"sync"
+)
+
+// registry are the protocols supported by default.
+var (
+	registry = map[string]Transport{}
+	mtx      sync.Mutex
+)
+
+// Register adds or modifies an existing protocol.
+func Register(protocol string, c Transport) {
+	mtx.Lock()
+	defer mtx.Unlock()
+	registry[protocol] = c
+}
+
+// Unregister removes a protocol from the list of supported protocols.
+func Unregister(scheme string) {
+	mtx.Lock()
+	defer mtx.Unlock()
+	delete(registry, scheme)
+}
+
+// Get returns the appropriate client for the given protocol.
+func Get(p string) (Transport, error) {
+	f, ok := registry[p]
+	if !ok {
+		return nil, fmt.Errorf("unsupported scheme %q", p)
+	}
+
+	if f == nil {
+		return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", p)
+	}
+	return f, nil
+}

plumbing/transport/ssh/common.go

···
 	"golang.org/x/net/proxy"
 )
 
+func init() {
+	transport.Register("ssh", DefaultClient)
+}
+
 // DefaultClient is the default SSH client.
 var DefaultClient = NewClient(nil)
 

remote.go

···
 	"github.com/go-git/go-git/v5/plumbing/revlist"
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/plumbing/transport"
-	"github.com/go-git/go-git/v5/plumbing/transport/client"
 	"github.com/go-git/go-git/v5/storage"
 	"github.com/go-git/go-git/v5/storage/filesystem"
 	"github.com/go-git/go-git/v5/storage/memory"
···
 	ep.CaBundle = cabundle
 	ep.Proxy = proxyOpts
 
-	c, err := client.NewClient(ep)
+	c, err := transport.Get(ep.Protocol)
 	if err != nil {
 		return nil, nil, err
 	}

transport.go

···
+package git
+
+// Default supported transports.
+import (
+	_ "github.com/go-git/go-git/v5/plumbing/transport/file" // file transport
+	_ "github.com/go-git/go-git/v5/plumbing/transport/git"  // git transport
+	_ "github.com/go-git/go-git/v5/plumbing/transport/http" // http transport
+	_ "github.com/go-git/go-git/v5/plumbing/transport/ssh"  // ssh transport
+)