diff options
43 files changed, 1641 insertions, 308 deletions
diff --git a/cli/go-git/main.go b/cli/go-git/main.go new file mode 100644 index 0000000..97b8c3e --- /dev/null +++ b/cli/go-git/main.go @@ -0,0 +1,41 @@ +package main + +import ( + "os" + "path/filepath" + + "github.com/jessevdk/go-flags" +) + +const ( + bin = "go-git" + receivePackBin = "git-receive-pack" + uploadPackBin = "git-upload-pack" +) + +func main() { + switch filepath.Base(os.Args[0]) { + case receivePackBin: + os.Args = append([]string{"git", "receive-pack"}, os.Args[1:]...) + case uploadPackBin: + os.Args = append([]string{"git", "upload-pack"}, os.Args[1:]...) + } + + parser := flags.NewNamedParser(bin, flags.Default) + parser.AddCommand("receive-pack", "", "", &CmdReceivePack{}) + parser.AddCommand("upload-pack", "", "", &CmdUploadPack{}) + parser.AddCommand("version", "Show the version information.", "", &CmdVersion{}) + + _, err := parser.Parse() + if err != nil { + if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrCommandRequired { + parser.WriteHelp(os.Stdout) + } + + os.Exit(1) + } +} + +type cmd struct { + Verbose bool `short:"v" description:"Activates the verbose mode"` +} diff --git a/cli/go-git/receive_pack.go b/cli/go-git/receive_pack.go new file mode 100644 index 0000000..0f96a28 --- /dev/null +++ b/cli/go-git/receive_pack.go @@ -0,0 +1,36 @@ +package main + +import ( + "fmt" + "os" + "path/filepath" + + "gopkg.in/src-d/go-git.v4/plumbing/transport/file" +) + +type CmdReceivePack struct { + cmd + + Args struct { + GitDir string `positional-arg-name:"git-dir" required:"true"` + } `positional-args:"yes"` +} + +func (CmdReceivePack) Usage() string { + //TODO: git-receive-pack returns error code 129 if arguments are invalid. + return fmt.Sprintf("usage: %s <git-dir>", os.Args[0]) +} + +func (c *CmdReceivePack) Execute(args []string) error { + gitDir, err := filepath.Abs(c.Args.GitDir) + if err != nil { + return err + } + + if err := file.ServeReceivePack(gitDir); err != nil { + fmt.Fprintln(os.Stderr, "ERR:", err) + os.Exit(128) + } + + return nil +} diff --git a/cli/go-git/upload_pack.go b/cli/go-git/upload_pack.go new file mode 100644 index 0000000..c45fe48 --- /dev/null +++ b/cli/go-git/upload_pack.go @@ -0,0 +1,37 @@ +package main + +import ( + "fmt" + "os" + "path/filepath" + + "gopkg.in/src-d/go-git.v4/plumbing/transport/file" +) + +//TODO: usage: git upload-pack [--strict] [--timeout=<n>] <dir> +type CmdUploadPack struct { + cmd + + Args struct { + GitDir string `positional-arg-name:"git-dir" required:"true"` + } `positional-args:"yes"` +} + +func (CmdUploadPack) Usage() string { + //TODO: git-upload-pack returns error code 129 if arguments are invalid. + return fmt.Sprintf("usage: %s <git-dir>", os.Args[0]) +} + +func (c *CmdUploadPack) Execute(args []string) error { + gitDir, err := filepath.Abs(c.Args.GitDir) + if err != nil { + return err + } + + if err := file.ServeUploadPack(gitDir); err != nil { + fmt.Fprintln(os.Stderr, "ERR:", err) + os.Exit(128) + } + + return nil +} diff --git a/cli/go-git/version.go b/cli/go-git/version.go new file mode 100644 index 0000000..b0e773d --- /dev/null +++ b/cli/go-git/version.go @@ -0,0 +1,14 @@ +package main + +import "fmt" + +var version string +var build string + +type CmdVersion struct{} + +func (c *CmdVersion) Execute(args []string) error { + fmt.Printf("%s (%s) - build %s\n", bin, version, build) + + return nil +} diff --git a/plumbing/format/packfile/common.go b/plumbing/format/packfile/common.go index 1656551..7da2b33 100644 --- a/plumbing/format/packfile/common.go +++ b/plumbing/format/packfile/common.go @@ -1,5 +1,11 @@ package packfile +import ( + "io" + + "gopkg.in/src-d/go-git.v4/plumbing/storer" +) + var signature = []byte{'P', 'A', 'C', 'K'} const ( @@ -13,3 +19,27 @@ const ( maskLength = uint8(127) // 0111 1111 maskType = uint8(112) // 0111 0000 ) + +// UpdateObjectStorage updates the given ObjectStorer with the contents of the +// packfile. +func UpdateObjectStorage(s storer.EncodedObjectStorer, packfile io.Reader) error { + if sw, ok := s.(storer.PackfileWriter); ok { + w, err := sw.PackfileWriter() + if err != nil { + return err + } + + defer w.Close() + _, err = io.Copy(w, packfile) + return err + } + + stream := NewScanner(packfile) + d, err := NewDecoder(stream, s) + if err != nil { + return err + } + + _, err = d.Decode() + return err +} diff --git a/plumbing/protocol/packp/capability/list.go b/plumbing/protocol/packp/capability/list.go index 2847580..69fdb51 100644 --- a/plumbing/protocol/packp/capability/list.go +++ b/plumbing/protocol/packp/capability/list.go @@ -167,6 +167,16 @@ func (l *List) Delete(capability Capability) { } } +// All returns a slice with all defined capabilities. +func (l *List) All() []Capability { + var cs []Capability + for _, key := range l.sort { + cs = append(cs, Capability(key)) + } + + return cs +} + // String generates the capabilities strings, the capabilities are sorted in // insertion order func (l *List) String() string { diff --git a/plumbing/protocol/packp/capability/list_test.go b/plumbing/protocol/packp/capability/list_test.go index 42f0179..0a0ad26 100644 --- a/plumbing/protocol/packp/capability/list_test.go +++ b/plumbing/protocol/packp/capability/list_test.go @@ -171,3 +171,14 @@ func (s *SuiteCapabilities) TestAddErrMultipleArgumentsAtTheSameTime(c *check.C) err := cap.Add(Agent, "foo", "bar") c.Assert(err, check.Equals, ErrMultipleArguments) } + +func (s *SuiteCapabilities) TestAll(c *check.C) { + cap := NewList() + c.Assert(NewList().All(), check.IsNil) + + cap.Add(Agent, "foo") + c.Assert(cap.All(), check.DeepEquals, []Capability{Agent}) + + cap.Add(OFSDelta) + c.Assert(cap.All(), check.DeepEquals, []Capability{Agent, OFSDelta}) +} diff --git a/plumbing/protocol/packp/shallowupd.go b/plumbing/protocol/packp/shallowupd.go index 89063de..40f58e8 100644 --- a/plumbing/protocol/packp/shallowupd.go +++ b/plumbing/protocol/packp/shallowupd.go @@ -24,6 +24,7 @@ func (r *ShallowUpdate) Decode(reader io.Reader) error { for s.Scan() { line := s.Bytes() + line = bytes.TrimSpace(line) var err error switch { @@ -71,3 +72,21 @@ func (r *ShallowUpdate) decodeLine(line, prefix []byte, expLen int) (plumbing.Ha raw := string(line[expLen-40 : expLen]) return plumbing.NewHash(raw), nil } + +func (r *ShallowUpdate) Encode(w io.Writer) error { + e := pktline.NewEncoder(w) + + for _, h := range r.Shallows { + if err := e.Encodef("%s%s\n", shallow, h.String()); err != nil { + return err + } + } + + for _, h := range r.Unshallows { + if err := e.Encodef("%s%s\n", unshallow, h.String()); err != nil { + return err + } + } + + return e.Flush() +} diff --git a/plumbing/protocol/packp/shallowupd_test.go b/plumbing/protocol/packp/shallowupd_test.go index d64fb5d..97a13fc 100644 --- a/plumbing/protocol/packp/shallowupd_test.go +++ b/plumbing/protocol/packp/shallowupd_test.go @@ -12,6 +12,26 @@ type ShallowUpdateSuite struct{} var _ = Suite(&ShallowUpdateSuite{}) +func (s *ShallowUpdateSuite) TestDecodeWithLF(c *C) { + raw := "" + + "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + + "0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + + "0000" + + su := &ShallowUpdate{} + err := su.Decode(bytes.NewBufferString(raw)) + c.Assert(err, IsNil) + + plumbing.HashesSort(su.Shallows) + + c.Assert(su.Unshallows, HasLen, 0) + c.Assert(su.Shallows, HasLen, 2) + c.Assert(su.Shallows, DeepEquals, []plumbing.Hash{ + plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), + plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), + }) +} + func (s *ShallowUpdateSuite) TestDecode(c *C) { raw := "" + "0034shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + @@ -61,3 +81,70 @@ func (s *ShallowUpdateSuite) TestDecodeMalformed(c *C) { err := su.Decode(bytes.NewBufferString(raw)) c.Assert(err, NotNil) } + +func (s *ShallowUpdateSuite) TestEncodeEmpty(c *C) { + su := &ShallowUpdate{} + buf := bytes.NewBuffer(nil) + c.Assert(su.Encode(buf), IsNil) + c.Assert(buf.String(), Equals, "0000") +} + +func (s *ShallowUpdateSuite) TestEncode(c *C) { + su := &ShallowUpdate{ + Shallows: []plumbing.Hash{ + plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), + plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), + }, + Unshallows: []plumbing.Hash{ + plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), + plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), + }, + } + buf := bytes.NewBuffer(nil) + c.Assert(su.Encode(buf), IsNil) + + expected := "" + + "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + + "0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + + "0037unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + + "0037unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + + "0000" + + c.Assert(buf.String(), Equals, expected) +} + +func (s *ShallowUpdateSuite) TestEncodeShallow(c *C) { + su := &ShallowUpdate{ + Shallows: []plumbing.Hash{ + plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), + plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), + }, + } + buf := bytes.NewBuffer(nil) + c.Assert(su.Encode(buf), IsNil) + + expected := "" + + "0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + + "0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + + "0000" + + c.Assert(buf.String(), Equals, expected) +} + +func (s *ShallowUpdateSuite) TestEncodeUnshallow(c *C) { + su := &ShallowUpdate{ + Unshallows: []plumbing.Hash{ + plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), + plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), + }, + } + buf := bytes.NewBuffer(nil) + c.Assert(su.Encode(buf), IsNil) + + expected := "" + + "0037unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + + "0037unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + + "0000" + + c.Assert(buf.String(), Equals, expected) +} diff --git a/plumbing/protocol/packp/srvresp.go b/plumbing/protocol/packp/srvresp.go index 3284fa2..d41b50d 100644 --- a/plumbing/protocol/packp/srvresp.go +++ b/plumbing/protocol/packp/srvresp.go @@ -68,3 +68,17 @@ func (r *ServerResponse) decodeACKLine(line []byte) error { r.ACKs = append(r.ACKs, h) return nil } + +// Encode encodes the ServerResponse into a writer. +func (r *ServerResponse) Encode(w io.Writer) error { + if len(r.ACKs) > 1 { + return errors.New("multi_ack and multi_ack_detailed are not supported") + } + + e := pktline.NewEncoder(w) + if len(r.ACKs) == 0 { + return e.Encodef("%s\n", nak) + } + + return e.Encodef("%s %s\n", ack, r.ACKs[0].String()) +} diff --git a/plumbing/protocol/packp/updreq_decode.go b/plumbing/protocol/packp/updreq_decode.go index 51e8183..c15d49c 100644 --- a/plumbing/protocol/packp/updreq_decode.go +++ b/plumbing/protocol/packp/updreq_decode.go @@ -225,7 +225,7 @@ func parseCommand(b []byte) (*Command, error) { return nil, errInvalidNewObjId(err) } - return &Command{Old: oh, New: nh, Name: n}, nil + return &Command{Old: oh, New: nh, Name: plumbing.ReferenceName(n)}, nil } func parseHash(s string) (plumbing.Hash, error) { diff --git a/plumbing/protocol/packp/uppackresp.go b/plumbing/protocol/packp/uppackresp.go index a117956..ac456f3 100644 --- a/plumbing/protocol/packp/uppackresp.go +++ b/plumbing/protocol/packp/uppackresp.go @@ -5,6 +5,7 @@ import ( "io" "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability" + "gopkg.in/src-d/go-git.v4/utils/ioutil" ) // ErrUploadPackResponseNotDecoded is returned if Read is called without @@ -17,8 +18,8 @@ var ErrUploadPackResponseNotDecoded = errors.New("upload-pack-response should be type UploadPackResponse struct { ShallowUpdate ServerResponse - r io.ReadCloser + r io.ReadCloser isShallow bool isMultiACK bool isOk bool @@ -37,6 +38,16 @@ func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse { } } +// NewUploadPackResponseWithPackfile creates a new UploadPackResponse instance, +// and sets its packfile reader. +func NewUploadPackResponseWithPackfile(req *UploadPackRequest, + pf io.ReadCloser) *UploadPackResponse { + + r := NewUploadPackResponse(req) + r.r = pf + return r +} + // Decode decodes all the responses sent by upload-pack service into the struct // and prepares it to read the packfile using the Read method func (r *UploadPackResponse) Decode(reader io.ReadCloser) error { @@ -56,6 +67,23 @@ func (r *UploadPackResponse) Decode(reader io.ReadCloser) error { return nil } +// Encode encodes an UploadPackResponse. +func (r *UploadPackResponse) Encode(w io.Writer) (err error) { + if r.isShallow { + if err := r.ShallowUpdate.Encode(w); err != nil { + return err + } + } + + if err := r.ServerResponse.Encode(w); err != nil { + return err + } + + defer ioutil.CheckClose(r.r, &err) + _, err = io.Copy(w, r.r) + return err +} + // Read reads the packfile data, if the request was done with any Sideband // capability the content read should be demultiplexed. If the methods wasn't // called before the ErrUploadPackResponseNotDecoded will be return diff --git a/plumbing/protocol/packp/uppackresp_test.go b/plumbing/protocol/packp/uppackresp_test.go index c81bb76..c27fdda 100644 --- a/plumbing/protocol/packp/uppackresp_test.go +++ b/plumbing/protocol/packp/uppackresp_test.go @@ -7,6 +7,7 @@ import ( "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability" . "gopkg.in/check.v1" + "gopkg.in/src-d/go-git.v4/plumbing" ) type UploadPackResponseSuite struct{} @@ -80,3 +81,46 @@ func (s *UploadPackResponseSuite) TestReadNoDecode(c *C) { c.Assert(err, Equals, ErrUploadPackResponseNotDecoded) c.Assert(n, Equals, 0) } + +func (s *UploadPackResponseSuite) TestEncodeNAK(c *C) { + pf := ioutil.NopCloser(bytes.NewBuffer([]byte("[PACK]"))) + req := NewUploadPackRequest() + res := NewUploadPackResponseWithPackfile(req, pf) + defer func() { c.Assert(res.Close(), IsNil) }() + + b := bytes.NewBuffer(nil) + c.Assert(res.Encode(b), IsNil) + + expected := "0008NAK\n[PACK]" + c.Assert(string(b.Bytes()), Equals, expected) +} + +func (s *UploadPackResponseSuite) TestEncodeDepth(c *C) { + pf := ioutil.NopCloser(bytes.NewBuffer([]byte("[PACK]"))) + req := NewUploadPackRequest() + req.Depth = DepthCommits(1) + + res := NewUploadPackResponseWithPackfile(req, pf) + defer func() { c.Assert(res.Close(), IsNil) }() + + b := bytes.NewBuffer(nil) + c.Assert(res.Encode(b), IsNil) + + expected := "00000008NAK\n[PACK]" + c.Assert(string(b.Bytes()), Equals, expected) +} + +func (s *UploadPackResponseSuite) TestEncodeMultiACK(c *C) { + pf := ioutil.NopCloser(bytes.NewBuffer([]byte("[PACK]"))) + req := NewUploadPackRequest() + + res := NewUploadPackResponseWithPackfile(req, pf) + defer func() { c.Assert(res.Close(), IsNil) }() + res.ACKs = []plumbing.Hash{ + plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f81"), + plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82"), + } + + b := bytes.NewBuffer(nil) + c.Assert(res.Encode(b), NotNil) +} diff --git a/plumbing/storer/storer.go b/plumbing/storer/storer.go new file mode 100644 index 0000000..0b96c0e --- /dev/null +++ b/plumbing/storer/storer.go @@ -0,0 +1,7 @@ +package storer + +// Storer is a basic storer for encoded objects and references. +type Storer interface { + EncodedObjectStorer + ReferenceStorer +} diff --git a/plumbing/transport/client/client.go b/plumbing/transport/client/client.go index 095c51d..4615368 100644 --- a/plumbing/transport/client/client.go +++ b/plumbing/transport/client/client.go @@ -11,7 +11,7 @@ import ( ) // Protocols are the protocols supported by default. -var Protocols = map[string]transport.Client{ +var Protocols = map[string]transport.Transport{ "http": http.DefaultClient, "https": http.DefaultClient, "ssh": ssh.DefaultClient, @@ -20,14 +20,14 @@ var Protocols = map[string]transport.Client{ } // InstallProtocol adds or modifies an existing protocol. -func InstallProtocol(scheme string, c transport.Client) { +func InstallProtocol(scheme string, c transport.Transport) { 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.Client, error) { +func NewClient(endpoint transport.Endpoint) (transport.Transport, error) { f, ok := Protocols[endpoint.Scheme] if !ok { return nil, fmt.Errorf("unsupported scheme %q", endpoint.Scheme) diff --git a/plumbing/transport/client/client_test.go b/plumbing/transport/client/client_test.go index a0c8208..9af70b1 100644 --- a/plumbing/transport/client/client_test.go +++ b/plumbing/transport/client/client_test.go @@ -58,13 +58,13 @@ type dummyClient struct { *http.Client } -func (*dummyClient) NewFetchPackSession(transport.Endpoint) ( - transport.FetchPackSession, error) { +func (*dummyClient) NewUploadPackSession(transport.Endpoint) ( + transport.UploadPackSession, error) { return nil, nil } -func (*dummyClient) NewSendPackSession(transport.Endpoint) ( - transport.SendPackSession, error) { +func (*dummyClient) NewReceivePackSession(transport.Endpoint) ( + transport.ReceivePackSession, error) { return nil, nil } diff --git a/plumbing/transport/common.go b/plumbing/transport/common.go index 83fd5a3..00e8a30 100644 --- a/plumbing/transport/common.go +++ b/plumbing/transport/common.go @@ -37,21 +37,23 @@ const ( ReceivePackServiceName = "git-receive-pack" ) -// Client can initiate git-fetch-pack and git-send-pack processes. -type Client interface { - // NewFetchPackSession starts a git-fetch-pack session for an endpoint. - NewFetchPackSession(Endpoint) (FetchPackSession, error) - // NewSendPackSession starts a git-send-pack session for an endpoint. - NewSendPackSession(Endpoint) (SendPackSession, error) +// Transport can initiate git-upload-pack and git-receive-pack processes. +// It is implemented both by the client and the server, making this a RPC. +type Transport interface { + // NewUploadPackSession starts a git-upload-pack session for an endpoint. + NewUploadPackSession(Endpoint) (UploadPackSession, error) + // NewReceivePackSession starts a git-receive-pack session for an endpoint. + NewReceivePackSession(Endpoint) (ReceivePackSession, error) } type Session interface { - SetAuth(auth AuthMethod) error // AdvertisedReferences retrieves the advertised references for a // repository. // If the repository does not exist, returns ErrRepositoryNotFound. // If the repository exists, but is empty, returns ErrEmptyRemoteRepository. AdvertisedReferences() (*packp.AdvRefs, error) + //TODO: Move to Client level. + SetAuth(auth AuthMethod) error io.Closer } @@ -60,26 +62,30 @@ type AuthMethod interface { Name() string } -// FetchPackSession represents a git-fetch-pack session. -// A git-fetch-pack session has two steps: reference discovery -// (`AdvertisedReferences` function) and fetching pack (`FetchPack` function). -// In that order. -type FetchPackSession interface { +// UploadPackSession represents a git-upload-pack session. +// A git-upload-pack session has two steps: reference discovery +// (AdvertisedReferences) and uploading pack (UploadPack). +type UploadPackSession interface { Session - // FetchPack takes a request and returns a reader for the packfile - // received from the server. - FetchPack(*packp.UploadPackRequest) (*packp.UploadPackResponse, error) + // UploadPack takes a git-upload-pack request and returns a response, + // including a packfile. Don't be confused by terminology, the client + // side of a git-upload-pack is called git-fetch-pack, although here + // the same interface is used to make it RPC-like. + UploadPack(*packp.UploadPackRequest) (*packp.UploadPackResponse, error) } -// SendPackSession represents a git-send-pack session. -// A git-send-pack session has two steps: reference discovery -// (`AdvertisedReferences` function) and sending pack (`SendPack` function). +// ReceivePackSession represents a git-receive-pack session. +// A git-receive-pack session has two steps: reference discovery +// (AdvertisedReferences) and receiving pack (ReceivePack). // In that order. -type SendPackSession interface { +type ReceivePackSession interface { Session - // UpdateReferences sends an update references request and a packfile - // reader and returns a ReportStatus and error. - SendPack(*packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) + // ReceivePack sends an update references request and a packfile + // reader and returns a ReportStatus and error. Don't be confused by + // terminology, the client side of a git-receive-pack is called + // git-send-pack, although here the same interface is used to make it + // RPC-like. + ReceivePack(*packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) } type Endpoint url.URL diff --git a/plumbing/transport/file/common.go b/plumbing/transport/file/client.go index e7d18b2..5484009 100644 --- a/plumbing/transport/file/common.go +++ b/plumbing/transport/file/client.go @@ -21,7 +21,7 @@ type runner struct { // NewClient returns a new local client using the given git-upload-pack and // git-receive-pack binaries. -func NewClient(uploadPackBin, receivePackBin string) transport.Client { +func NewClient(uploadPackBin, receivePackBin string) transport.Transport { return common.NewClient(&runner{ UploadPackBin: uploadPackBin, ReceivePackBin: receivePackBin, diff --git a/plumbing/transport/file/client_test.go b/plumbing/transport/file/client_test.go new file mode 100644 index 0000000..220df3d --- /dev/null +++ b/plumbing/transport/file/client_test.go @@ -0,0 +1,40 @@ +package file + +import ( + "fmt" + "io" + "os" + "strings" + "testing" + + "gopkg.in/src-d/go-git.v4/plumbing/transport" + + . "gopkg.in/check.v1" +) + +func Test(t *testing.T) { TestingT(t) } + +const bareConfig = `[core] +repositoryformatversion = 0 +filemode = true +bare = true` + +func prepareRepo(c *C, path string) transport.Endpoint { + url := fmt.Sprintf("file://%s", path) + ep, err := transport.NewEndpoint(url) + c.Assert(err, IsNil) + + // git-receive-pack refuses to update refs/heads/master on non-bare repo + // so we ensure bare repo config. + config := fmt.Sprintf("%s/config", path) + if _, err := os.Stat(config); err == nil { + f, err := os.OpenFile(config, os.O_TRUNC|os.O_WRONLY, 0) + c.Assert(err, IsNil) + content := strings.NewReader(bareConfig) + _, err = io.Copy(f, content) + c.Assert(err, IsNil) + c.Assert(f.Close(), IsNil) + } + + return ep +} diff --git a/plumbing/transport/file/common_test.go b/plumbing/transport/file/common_test.go index 220df3d..cd7c400 100644 --- a/plumbing/transport/file/common_test.go +++ b/plumbing/transport/file/common_test.go @@ -1,40 +1,39 @@ package file import ( - "fmt" - "io" "os" - "strings" - "testing" + "os/exec" + "path/filepath" - "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/fixtures" . "gopkg.in/check.v1" + "io/ioutil" ) -func Test(t *testing.T) { TestingT(t) } +type CommonSuite struct { + fixtures.Suite + ReceivePackBin string + UploadPackBin string +} -const bareConfig = `[core] -repositoryformatversion = 0 -filemode = true -bare = true` +var _ = Suite(&CommonSuite{}) -func prepareRepo(c *C, path string) transport.Endpoint { - url := fmt.Sprintf("file://%s", path) - ep, err := transport.NewEndpoint(url) - c.Assert(err, IsNil) +func (s *CommonSuite) SetUpSuite(c *C) { + s.Suite.SetUpSuite(c) - // git-receive-pack refuses to update refs/heads/master on non-bare repo - // so we ensure bare repo config. - config := fmt.Sprintf("%s/config", path) - if _, err := os.Stat(config); err == nil { - f, err := os.OpenFile(config, os.O_TRUNC|os.O_WRONLY, 0) - c.Assert(err, IsNil) - content := strings.NewReader(bareConfig) - _, err = io.Copy(f, content) - c.Assert(err, IsNil) - c.Assert(f.Close(), IsNil) + if err := exec.Command("git", "--version").Run(); err != nil { + c.Skip("git command not found") } - return ep + binDir, err := ioutil.TempDir(os.TempDir(), "") + c.Assert(err, IsNil) + s.ReceivePackBin = filepath.Join(binDir, "git-receive-pack") + s.UploadPackBin = filepath.Join(binDir, "git-upload-pack") + bin := filepath.Join(binDir, "go-git") + cmd := exec.Command("go", "build", "-o", bin, + "../../../cli/go-git/...") + c.Assert(cmd.Run(), IsNil) + c.Assert(os.Symlink(bin, s.ReceivePackBin), IsNil) + c.Assert(os.Symlink(bin, s.UploadPackBin), IsNil) } diff --git a/plumbing/transport/file/send_pack_test.go b/plumbing/transport/file/receive_pack_test.go index fc7ea35..c07d4ed 100644 --- a/plumbing/transport/file/send_pack_test.go +++ b/plumbing/transport/file/receive_pack_test.go @@ -2,7 +2,6 @@ package file import ( "os" - "os/exec" "gopkg.in/src-d/go-git.v4/fixtures" "gopkg.in/src-d/go-git.v4/plumbing/transport/test" @@ -10,24 +9,19 @@ import ( . "gopkg.in/check.v1" ) -type SendPackSuite struct { - fixtures.Suite - test.SendPackSuite +type ReceivePackSuite struct { + CommonSuite + test.ReceivePackSuite } -var _ = Suite(&SendPackSuite{}) +var _ = Suite(&ReceivePackSuite{}) -func (s *SendPackSuite) SetUpSuite(c *C) { - s.Suite.SetUpSuite(c) - - if err := exec.Command("git", "--version").Run(); err != nil { - c.Skip("git command not found") - } - - s.SendPackSuite.Client = DefaultClient +func (s *ReceivePackSuite) SetUpSuite(c *C) { + s.CommonSuite.SetUpSuite(c) + s.ReceivePackSuite.Client = DefaultClient } -func (s *SendPackSuite) SetUpTest(c *C) { +func (s *ReceivePackSuite) SetUpTest(c *C) { fixture := fixtures.Basic().One() path := fixture.DotGit().Base() s.Endpoint = prepareRepo(c, path) @@ -39,12 +33,12 @@ func (s *SendPackSuite) SetUpTest(c *C) { s.NonExistentEndpoint = prepareRepo(c, "/non-existent") } -func (s *SendPackSuite) TearDownTest(c *C) { +func (s *ReceivePackSuite) TearDownTest(c *C) { s.Suite.TearDownSuite(c) } // TODO: fix test -func (s *SendPackSuite) TestCommandNoOutput(c *C) { +func (s *ReceivePackSuite) TestCommandNoOutput(c *C) { c.Skip("failing test") if _, err := os.Stat("/bin/true"); os.IsNotExist(err) { @@ -52,30 +46,30 @@ func (s *SendPackSuite) TestCommandNoOutput(c *C) { } client := NewClient("true", "true") - session, err := client.NewSendPackSession(s.Endpoint) + session, err := client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) ar, err := session.AdvertisedReferences() c.Assert(err, IsNil) c.Assert(ar, IsNil) } -func (s *SendPackSuite) TestMalformedInputNoErrors(c *C) { +func (s *ReceivePackSuite) TestMalformedInputNoErrors(c *C) { if _, err := os.Stat("/usr/bin/yes"); os.IsNotExist(err) { c.Skip("/usr/bin/yes not found") } client := NewClient("yes", "yes") - session, err := client.NewSendPackSession(s.Endpoint) + session, err := client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) ar, err := session.AdvertisedReferences() c.Assert(err, NotNil) c.Assert(ar, IsNil) } -func (s *SendPackSuite) TestNonExistentCommand(c *C) { +func (s *ReceivePackSuite) TestNonExistentCommand(c *C) { cmd := "/non-existent-git" client := NewClient(cmd, cmd) - session, err := client.NewSendPackSession(s.Endpoint) + session, err := client.NewReceivePackSession(s.Endpoint) c.Assert(err, ErrorMatches, ".*no such file or directory.*") c.Assert(session, IsNil) } diff --git a/plumbing/transport/file/server.go b/plumbing/transport/file/server.go new file mode 100644 index 0000000..d83d5d9 --- /dev/null +++ b/plumbing/transport/file/server.go @@ -0,0 +1,51 @@ +package file + +import ( + "fmt" + "os" + + "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common" + "gopkg.in/src-d/go-git.v4/plumbing/transport/server" + "gopkg.in/src-d/go-git.v4/utils/ioutil" +) + +// ServeUploadPack serves a git-upload-pack request using standard output, input +// and error. This is meant to be used when implementing a git-upload-pack +// command. +func ServeUploadPack(path string) error { + ep, err := transport.NewEndpoint(fmt.Sprintf("file://%s", path)) + if err != nil { + return err + } + + s, err := server.DefaultServer.NewUploadPackSession(ep) + if err != nil { + return fmt.Errorf("error creating session: %s", err) + } + + return common.ServeUploadPack(srvCmd, s) +} + +// ServeReceivePack serves a git-receive-pack request using standard output, +// input and error. This is meant to be used when implementing a +// git-receive-pack command. +func ServeReceivePack(path string) error { + ep, err := transport.NewEndpoint(fmt.Sprintf("file://%s", path)) + if err != nil { + return err + } + + s, err := server.DefaultServer.NewReceivePackSession(ep) + if err != nil { + return fmt.Errorf("error creating session: %s", err) + } + + return common.ServeReceivePack(srvCmd, s) +} + +var srvCmd = common.ServerCommand{ + Stdin: os.Stdin, + Stdout: ioutil.WriteNopCloser(os.Stdout), + Stderr: os.Stderr, +} diff --git a/plumbing/transport/file/server_test.go b/plumbing/transport/file/server_test.go new file mode 100644 index 0000000..ff462e2 --- /dev/null +++ b/plumbing/transport/file/server_test.go @@ -0,0 +1,105 @@ +package file + +import ( + "fmt" + "io" + "io/ioutil" + "os" + "os/exec" + + "gopkg.in/src-d/go-git.v4/fixtures" + + . "gopkg.in/check.v1" +) + +type ServerSuite struct { + CommonSuite + RemoteName string + SrcPath string + DstPath string + DstURL string +} + +var _ = Suite(&ServerSuite{}) + +func (s *ServerSuite) SetUpSuite(c *C) { + s.CommonSuite.SetUpSuite(c) + + s.RemoteName = "test" + + fixture := fixtures.Basic().One() + s.SrcPath = fixture.DotGit().Base() + + fixture = fixtures.ByTag("empty").One() + s.DstPath = fixture.DotGit().Base() + s.DstURL = fmt.Sprintf("file://%s", s.DstPath) + + cmd := exec.Command("git", "remote", "add", s.RemoteName, s.DstURL) + cmd.Dir = s.SrcPath + c.Assert(cmd.Run(), IsNil) +} + +func (s *ServerSuite) TestPush(c *C) { + // git <2.0 cannot push to an empty repository without a refspec. + cmd := exec.Command("git", "push", + "--receive-pack", s.ReceivePackBin, + s.RemoteName, "refs/heads/*:refs/heads/*", + ) + cmd.Dir = s.SrcPath + cmd.Env = os.Environ() + cmd.Env = append(cmd.Env, "GIT_TRACE=true", "GIT_TRACE_PACKET=true") + stdout, stderr, err := execAndGetOutput(c, cmd) + c.Assert(err, IsNil, Commentf("STDOUT:\n%s\nSTDERR:\n%s\n", stdout, stderr)) +} + +func (s *ServerSuite) TestClone(c *C) { + pathToClone := c.MkDir() + + cmd := exec.Command("git", "clone", + "--upload-pack", s.UploadPackBin, + s.SrcPath, pathToClone, + ) + cmd.Env = os.Environ() + cmd.Env = append(cmd.Env, "GIT_TRACE=true", "GIT_TRACE_PACKET=true") + stdout, stderr, err := execAndGetOutput(c, cmd) + c.Assert(err, IsNil, Commentf("STDOUT:\n%s\nSTDERR:\n%s\n", stdout, stderr)) +} + +func execAndGetOutput(c *C, cmd *exec.Cmd) (stdout, stderr string, err error) { + sout, err := cmd.StdoutPipe() + c.Assert(err, IsNil) + serr, err := cmd.StderrPipe() + c.Assert(err, IsNil) + + outChan, outErr := readAllAsync(sout) + errChan, errErr := readAllAsync(serr) + + c.Assert(cmd.Start(), IsNil) + + if err = cmd.Wait(); err != nil { + return <-outChan, <-errChan, err + } + + if err := <-outErr; err != nil { + return <-outChan, <-errChan, err + } + + return <-outChan, <-errChan, <-errErr +} + +func readAllAsync(r io.Reader) (out chan string, err chan error) { + out = make(chan string, 1) + err = make(chan error, 1) + go func() { + b, e := ioutil.ReadAll(r) + if e != nil { + err <- e + } else { + err <- nil + } + + out <- string(b) + }() + + return out, err +} diff --git a/plumbing/transport/file/fetch_pack_test.go b/plumbing/transport/file/upload_pack_test.go index 25e3fef..de232c4 100644 --- a/plumbing/transport/file/fetch_pack_test.go +++ b/plumbing/transport/file/upload_pack_test.go @@ -3,7 +3,6 @@ package file import ( "fmt" "os" - "os/exec" "gopkg.in/src-d/go-git.v4/fixtures" "gopkg.in/src-d/go-git.v4/plumbing/transport" @@ -12,21 +11,17 @@ import ( . "gopkg.in/check.v1" ) -type FetchPackSuite struct { - fixtures.Suite - test.FetchPackSuite +type UploadPackSuite struct { + CommonSuite + test.UploadPackSuite } -var _ = Suite(&FetchPackSuite{}) +var _ = Suite(&UploadPackSuite{}) -func (s *FetchPackSuite) SetUpSuite(c *C) { - s.Suite.SetUpSuite(c) +func (s *UploadPackSuite) SetUpSuite(c *C) { + s.CommonSuite.SetUpSuite(c) - if err := exec.Command("git", "--version").Run(); err != nil { - c.Skip("git command not found") - } - - s.FetchPackSuite.Client = DefaultClient + s.UploadPackSuite.Client = DefaultClient fixture := fixtures.Basic().One() path := fixture.DotGit().Base() @@ -49,7 +44,7 @@ func (s *FetchPackSuite) SetUpSuite(c *C) { } // TODO: fix test -func (s *FetchPackSuite) TestCommandNoOutput(c *C) { +func (s *UploadPackSuite) TestCommandNoOutput(c *C) { c.Skip("failing test") if _, err := os.Stat("/bin/true"); os.IsNotExist(err) { @@ -57,30 +52,30 @@ func (s *FetchPackSuite) TestCommandNoOutput(c *C) { } client := NewClient("true", "true") - session, err := client.NewFetchPackSession(s.Endpoint) + session, err := client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) ar, err := session.AdvertisedReferences() c.Assert(err, IsNil) c.Assert(ar, IsNil) } -func (s *FetchPackSuite) TestMalformedInputNoErrors(c *C) { +func (s *UploadPackSuite) TestMalformedInputNoErrors(c *C) { if _, err := os.Stat("/usr/bin/yes"); os.IsNotExist(err) { c.Skip("/usr/bin/yes not found") } client := NewClient("yes", "yes") - session, err := client.NewFetchPackSession(s.Endpoint) + session, err := client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) ar, err := session.AdvertisedReferences() c.Assert(err, NotNil) c.Assert(ar, IsNil) } -func (s *FetchPackSuite) TestNonExistentCommand(c *C) { +func (s *UploadPackSuite) TestNonExistentCommand(c *C) { cmd := "/non-existent-git" client := NewClient(cmd, cmd) - session, err := client.NewFetchPackSession(s.Endpoint) + session, err := client.NewUploadPackSession(s.Endpoint) c.Assert(err, ErrorMatches, ".*no such file or directory.*") c.Assert(session, IsNil) } diff --git a/plumbing/transport/git/fetch_pack_test.go b/plumbing/transport/git/upload_pack_test.go index dc40240..d506075 100644 --- a/plumbing/transport/git/fetch_pack_test.go +++ b/plumbing/transport/git/upload_pack_test.go @@ -8,28 +8,28 @@ import ( . "gopkg.in/check.v1" ) -type FetchPackSuite struct { - test.FetchPackSuite +type UploadPackSuite struct { + test.UploadPackSuite fixtures.Suite } -var _ = Suite(&FetchPackSuite{}) +var _ = Suite(&UploadPackSuite{}) -func (s *FetchPackSuite) SetUpSuite(c *C) { +func (s *UploadPackSuite) SetUpSuite(c *C) { s.Suite.SetUpSuite(c) - s.FetchPackSuite.Client = DefaultClient + s.UploadPackSuite.Client = DefaultClient ep, err := transport.NewEndpoint("git://github.com/git-fixtures/basic.git") c.Assert(err, IsNil) - s.FetchPackSuite.Endpoint = ep + s.UploadPackSuite.Endpoint = ep ep, err = transport.NewEndpoint("git://github.com/git-fixtures/empty.git") c.Assert(err, IsNil) - s.FetchPackSuite.EmptyEndpoint = ep + s.UploadPackSuite.EmptyEndpoint = ep ep, err = transport.NewEndpoint("git://github.com/git-fixtures/non-existent.git") c.Assert(err, IsNil) - s.FetchPackSuite.NonExistentEndpoint = ep + s.UploadPackSuite.NonExistentEndpoint = ep } diff --git a/plumbing/transport/http/common.go b/plumbing/transport/http/common.go index aa3425e..957fd07 100644 --- a/plumbing/transport/http/common.go +++ b/plumbing/transport/http/common.go @@ -25,7 +25,7 @@ var DefaultClient = NewClient(nil) // Note that for HTTP client cannot distinguist between private repositories and // unexistent repositories on GitHub. So it returns `ErrAuthorizationRequired` // for both. -func NewClient(c *http.Client) transport.Client { +func NewClient(c *http.Client) transport.Transport { if c == nil { return &client{http.DefaultClient} } @@ -35,16 +35,16 @@ func NewClient(c *http.Client) transport.Client { } } -func (c *client) NewFetchPackSession(ep transport.Endpoint) ( - transport.FetchPackSession, error) { +func (c *client) NewUploadPackSession(ep transport.Endpoint) ( + transport.UploadPackSession, error) { - return newFetchPackSession(c.c, ep), nil + return newUploadPackSession(c.c, ep), nil } -func (c *client) NewSendPackSession(ep transport.Endpoint) ( - transport.SendPackSession, error) { +func (c *client) NewReceivePackSession(ep transport.Endpoint) ( + transport.ReceivePackSession, error) { - return newSendPackSession(c.c, ep), nil + return newReceivePackSession(c.c, ep), nil } type session struct { diff --git a/plumbing/transport/http/common_test.go b/plumbing/transport/http/common_test.go index 432bd07..217999d 100644 --- a/plumbing/transport/http/common_test.go +++ b/plumbing/transport/http/common_test.go @@ -26,7 +26,7 @@ func (s *ClientSuite) SetUpSuite(c *C) { c.Assert(err, IsNil) } -func (s *FetchPackSuite) TestNewClient(c *C) { +func (s *UploadPackSuite) TestNewClient(c *C) { roundTripper := &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } @@ -76,10 +76,10 @@ func (s *ClientSuite) testNewHTTPError(c *C, code int, msg string) { func (s *ClientSuite) TestSetAuth(c *C) { auth := &BasicAuth{} - r, err := DefaultClient.NewFetchPackSession(s.Endpoint) + r, err := DefaultClient.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) r.SetAuth(auth) - c.Assert(auth, Equals, r.(*fetchPackSession).auth) + c.Assert(auth, Equals, r.(*upSession).auth) } type mockAuth struct{} @@ -88,7 +88,7 @@ func (*mockAuth) Name() string { return "" } func (*mockAuth) String() string { return "" } func (s *ClientSuite) TestSetAuthWrongType(c *C) { - r, err := DefaultClient.NewFetchPackSession(s.Endpoint) + r, err := DefaultClient.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) c.Assert(r.SetAuth(&mockAuth{}), Equals, transport.ErrInvalidAuthMethod) } diff --git a/plumbing/transport/http/receive_pack.go b/plumbing/transport/http/receive_pack.go new file mode 100644 index 0000000..a8384c7 --- /dev/null +++ b/plumbing/transport/http/receive_pack.go @@ -0,0 +1,30 @@ +package http + +import ( + "errors" + "net/http" + + "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp" + "gopkg.in/src-d/go-git.v4/plumbing/transport" +) + +var errReceivePackNotSupported = errors.New("receive-pack not supported yet") + +type rpSession struct { + *session +} + +func newReceivePackSession(c *http.Client, ep transport.Endpoint) transport.ReceivePackSession { + return &rpSession{&session{}} +} + +func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) { + + return nil, errReceivePackNotSupported +} + +func (s *rpSession) ReceivePack(*packp.ReferenceUpdateRequest) ( + *packp.ReportStatus, error) { + + return nil, errReceivePackNotSupported +} diff --git a/plumbing/transport/http/send_pack.go b/plumbing/transport/http/send_pack.go deleted file mode 100644 index 43464ae..0000000 --- a/plumbing/transport/http/send_pack.go +++ /dev/null @@ -1,30 +0,0 @@ -package http - -import ( - "errors" - "net/http" - - "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp" - "gopkg.in/src-d/go-git.v4/plumbing/transport" -) - -var errSendPackNotSupported = errors.New("send-pack not supported yet") - -type sendPackSession struct { - *session -} - -func newSendPackSession(c *http.Client, ep transport.Endpoint) transport.SendPackSession { - return &sendPackSession{&session{}} -} - -func (s *sendPackSession) AdvertisedReferences() (*packp.AdvRefs, error) { - - return nil, errSendPackNotSupported -} - -func (s *sendPackSession) SendPack(*packp.ReferenceUpdateRequest) ( - *packp.ReportStatus, error) { - - return nil, errSendPackNotSupported -} diff --git a/plumbing/transport/http/fetch_pack.go b/plumbing/transport/http/upload_pack.go index 0c85be4..26257f5 100644 --- a/plumbing/transport/http/fetch_pack.go +++ b/plumbing/transport/http/upload_pack.go @@ -15,14 +15,14 @@ import ( "gopkg.in/src-d/go-git.v4/utils/ioutil" ) -type fetchPackSession struct { +type upSession struct { *session } -func newFetchPackSession(c *http.Client, - ep transport.Endpoint) transport.FetchPackSession { +func newUploadPackSession(c *http.Client, + ep transport.Endpoint) transport.UploadPackSession { - return &fetchPackSession{ + return &upSession{ session: &session{ auth: basicAuthFromEndpoint(ep), client: c, @@ -31,7 +31,7 @@ func newFetchPackSession(c *http.Client, } } -func (s *fetchPackSession) AdvertisedReferences() (*packp.AdvRefs, error) { +func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) { if s.advRefs != nil { return s.advRefs, nil } @@ -73,7 +73,7 @@ func (s *fetchPackSession) AdvertisedReferences() (*packp.AdvRefs, error) { return ar, nil } -func (s *fetchPackSession) FetchPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { +func (s *upSession) UploadPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { if req.IsEmpty() { return nil, transport.ErrEmptyUploadPackRequest } @@ -111,11 +111,11 @@ func (s *fetchPackSession) FetchPack(req *packp.UploadPackRequest) (*packp.Uploa } // Close does nothing. -func (s *fetchPackSession) Close() error { +func (s *upSession) Close() error { return nil } -func (s *fetchPackSession) doRequest(method, url string, content *bytes.Buffer) (*http.Response, error) { +func (s *upSession) doRequest(method, url string, content *bytes.Buffer) (*http.Response, error) { var body io.Reader if content != nil { body = content @@ -143,7 +143,7 @@ func (s *fetchPackSession) doRequest(method, url string, content *bytes.Buffer) } // it requires a bytes.Buffer, because we need to know the length -func (s *fetchPackSession) applyHeadersToRequest(req *http.Request, content *bytes.Buffer) { +func (s *upSession) applyHeadersToRequest(req *http.Request, content *bytes.Buffer) { req.Header.Add("User-Agent", "git/1.0") req.Header.Add("Host", s.endpoint.Host) diff --git a/plumbing/transport/http/fetch_pack_test.go b/plumbing/transport/http/upload_pack_test.go index 6c40e60..d3e4989 100644 --- a/plumbing/transport/http/fetch_pack_test.go +++ b/plumbing/transport/http/upload_pack_test.go @@ -11,37 +11,38 @@ import ( . "gopkg.in/check.v1" ) -type FetchPackSuite struct { - test.FetchPackSuite +type UploadPackSuite struct { + test.UploadPackSuite } -var _ = Suite(&FetchPackSuite{}) +var _ = Suite(&UploadPackSuite{}) -func (s *FetchPackSuite) SetUpSuite(c *C) { - s.FetchPackSuite.Client = DefaultClient +func (s *UploadPackSuite) SetUpSuite(c *C) { + s.UploadPackSuite.Client = DefaultClient ep, err := transport.NewEndpoint("https://github.com/git-fixtures/basic.git") c.Assert(err, IsNil) - s.FetchPackSuite.Endpoint = ep + s.UploadPackSuite.Endpoint = ep ep, err = transport.NewEndpoint("https://github.com/git-fixtures/empty.git") c.Assert(err, IsNil) - s.FetchPackSuite.EmptyEndpoint = ep + s.UploadPackSuite.EmptyEndpoint = ep ep, err = transport.NewEndpoint("https://github.com/git-fixtures/non-existent.git") c.Assert(err, IsNil) - s.FetchPackSuite.NonExistentEndpoint = ep + s.UploadPackSuite.NonExistentEndpoint = ep } -func (s *FetchPackSuite) TestInfoNotExists(c *C) { - r, err := s.Client.NewFetchPackSession(s.NonExistentEndpoint) +// Overwritten, different behaviour for HTTP. +func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { + r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint) c.Assert(err, IsNil) info, err := r.AdvertisedReferences() c.Assert(err, Equals, transport.ErrAuthorizationRequired) c.Assert(info, IsNil) } -func (s *FetchPackSuite) TestuploadPackRequestToReader(c *C) { +func (s *UploadPackSuite) TestuploadPackRequestToReader(c *C) { r := packp.NewUploadPackRequest() r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c")) r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989")) diff --git a/plumbing/transport/internal/common/common.go b/plumbing/transport/internal/common/common.go index 17c473e..831c4d7 100644 --- a/plumbing/transport/internal/common/common.go +++ b/plumbing/transport/internal/common/common.go @@ -77,20 +77,20 @@ type client struct { } // NewClient creates a new client using the given Commander. -func NewClient(runner Commander) transport.Client { +func NewClient(runner Commander) transport.Transport { return &client{runner} } -// NewFetchPackSession creates a new FetchPackSession. -func (c *client) NewFetchPackSession(ep transport.Endpoint) ( - transport.FetchPackSession, error) { +// NewUploadPackSession creates a new UploadPackSession. +func (c *client) NewUploadPackSession(ep transport.Endpoint) ( + transport.UploadPackSession, error) { return c.newSession(transport.UploadPackServiceName, ep) } -// NewSendPackSession creates a new SendPackSession. -func (c *client) NewSendPackSession(ep transport.Endpoint) ( - transport.SendPackSession, error) { +// NewReceivePackSession creates a new ReceivePackSession. +func (c *client) NewReceivePackSession(ep transport.Endpoint) ( + transport.ReceivePackSession, error) { return c.newSession(transport.ReceivePackServiceName, ep) } @@ -219,9 +219,9 @@ func (s *session) handleAdvRefDecodeError(err error) error { return err } -// FetchPack performs a request to the server to fetch a packfile. A reader is +// UploadPack performs a request to the server to fetch a packfile. A reader is // returned with the packfile content. The reader must be closed after reading. -func (s *session) FetchPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { +func (s *session) UploadPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { if req.IsEmpty() { return nil, transport.ErrEmptyUploadPackRequest } @@ -236,7 +236,7 @@ func (s *session) FetchPack(req *packp.UploadPackRequest) (*packp.UploadPackResp s.packRun = true - if err := fetchPack(s.Stdin, s.Stdout, req); err != nil { + if err := uploadPack(s.Stdin, s.Stdout, req); err != nil { return nil, err } @@ -259,7 +259,7 @@ func (s *session) FetchPack(req *packp.UploadPackRequest) (*packp.UploadPackResp return DecodeUploadPackResponse(rc, req) } -func (s *session) SendPack(req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { +func (s *session) ReceivePack(req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { if _, err := s.AdvertisedReferences(); err != nil { return nil, err } @@ -295,7 +295,7 @@ func (s *session) finish() error { s.finished = true - // If we did not run fetch-pack or send-pack, we close the connection + // If we did not run a upload/receive-pack, we close the connection // gracefully by sending a flush packet to the server. If the server // operates correctly, it will exit with status 0. if !s.packRun { @@ -367,13 +367,13 @@ var ( eol = []byte("\n") ) -// fetchPack implements the git-fetch-pack protocol. +// uploadPack implements the git-upload-pack protocol. // // TODO support multi_ack mode // TODO support multi_ack_detailed mode // TODO support acks for common objects // TODO build a proper state machine for all these processing options -func fetchPack(w io.WriteCloser, r io.Reader, req *packp.UploadPackRequest) error { +func uploadPack(w io.WriteCloser, r io.Reader, req *packp.UploadPackRequest) error { if err := req.UploadRequest.Encode(w); err != nil { return fmt.Errorf("sending upload-req message: %s", err) } diff --git a/plumbing/transport/internal/common/server.go b/plumbing/transport/internal/common/server.go new file mode 100644 index 0000000..dd6cfbe --- /dev/null +++ b/plumbing/transport/internal/common/server.go @@ -0,0 +1,72 @@ +package common + +import ( + "fmt" + "io" + + "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp" + "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/utils/ioutil" +) + +// ServerCommand is used for a single server command execution. +type ServerCommand struct { + Stderr io.Writer + Stdout io.WriteCloser + Stdin io.Reader +} + +func ServeUploadPack(cmd ServerCommand, s transport.UploadPackSession) (err error) { + ioutil.CheckClose(cmd.Stdout, &err) + + ar, err := s.AdvertisedReferences() + if err != nil { + return err + } + + if err := ar.Encode(cmd.Stdout); err != nil { + return err + } + + req := packp.NewUploadPackRequest() + if err := req.Decode(cmd.Stdin); err != nil { + return err + } + + var resp *packp.UploadPackResponse + resp, err = s.UploadPack(req) + if err != nil { + return err + } + + return resp.Encode(cmd.Stdout) +} + +func ServeReceivePack(cmd ServerCommand, s transport.ReceivePackSession) error { + ar, err := s.AdvertisedReferences() + if err != nil { + return fmt.Errorf("internal error in advertised references: %s", err) + } + + if err := ar.Encode(cmd.Stdout); err != nil { + return fmt.Errorf("error in advertised references encoding: %s", err) + } + + req := packp.NewReferenceUpdateRequest() + if err := req.Decode(cmd.Stdin); err != nil { + return fmt.Errorf("error decoding: %s", err) + } + + rs, err := s.ReceivePack(req) + if rs != nil { + if err := rs.Encode(cmd.Stdout); err != nil { + return fmt.Errorf("error in encoding report status %s", err) + } + } + + if err != nil { + return fmt.Errorf("error in receive pack: %s", err) + } + + return nil +} diff --git a/plumbing/transport/server/loader.go b/plumbing/transport/server/loader.go new file mode 100644 index 0000000..55bcf1d --- /dev/null +++ b/plumbing/transport/server/loader.go @@ -0,0 +1,59 @@ +package server + +import ( + "gopkg.in/src-d/go-git.v4/plumbing/storer" + "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/storage/filesystem" + + "srcd.works/go-billy.v1" + "srcd.works/go-billy.v1/os" +) + +// DefaultLoader is a filesystem loader ignoring host and resolving paths to /. +var DefaultLoader = NewFilesystemLoader(os.New("/")) + +// Loader loads repository's storer.Storer based on an optional host and a path. +type Loader interface { + // Load loads a storer.Storer given a transport.Endpoint. + // Returns transport.ErrRepositoryNotFound if the repository does not + // exist. + Load(ep transport.Endpoint) (storer.Storer, error) +} + +type fsLoader struct { + base billy.Filesystem +} + +// NewFilesystemLoader creates a Loader that ignores host and resolves paths +// with a given base filesystem. +func NewFilesystemLoader(base billy.Filesystem) Loader { + return &fsLoader{base} +} + +// Load looks up the endpoint's path in the base file system and returns a +// storer for it. Returns transport.ErrRepositoryNotFound if a repository does +// not exist in the given path. +func (l *fsLoader) Load(ep transport.Endpoint) (storer.Storer, error) { + fs := l.base.Dir(ep.Path) + if _, err := fs.Stat("config"); err != nil { + return nil, transport.ErrRepositoryNotFound + } + + return filesystem.NewStorage(fs) +} + +// MapLoader is a Loader that uses a lookup map of storer.Storer by +// transport.Endpoint. +type MapLoader map[transport.Endpoint]storer.Storer + +// Load returns a storer.Storer for given a transport.Endpoint by looking it up +// in the map. Returns transport.ErrRepositoryNotFound if the endpoint does not +// exist. +func (l MapLoader) Load(ep transport.Endpoint) (storer.Storer, error) { + s, ok := l[ep] + if !ok { + return nil, transport.ErrRepositoryNotFound + } + + return s, nil +} diff --git a/plumbing/transport/server/loader_test.go b/plumbing/transport/server/loader_test.go new file mode 100644 index 0000000..b4a8c37 --- /dev/null +++ b/plumbing/transport/server/loader_test.go @@ -0,0 +1,57 @@ +package server + +import ( + "fmt" + "os/exec" + "path/filepath" + + "gopkg.in/src-d/go-git.v4/plumbing/transport" + + . "gopkg.in/check.v1" +) + +type LoaderSuite struct { + RepoPath string +} + +var _ = Suite(&LoaderSuite{}) + +func (s *LoaderSuite) SetUpSuite(c *C) { + if err := exec.Command("git", "--version").Run(); err != nil { + c.Skip("git command not found") + } + + dir := c.MkDir() + s.RepoPath = filepath.Join(dir, "repo.git") + c.Assert(exec.Command("git", "init", "--bare", s.RepoPath).Run(), IsNil) +} + +func (s *LoaderSuite) endpoint(c *C, url string) transport.Endpoint { + ep, err := transport.NewEndpoint(url) + c.Assert(err, IsNil) + return ep +} + +func (s *LoaderSuite) TestLoadNonExistent(c *C) { + sto, err := DefaultLoader.Load(s.endpoint(c, "file:///does-not-exist")) + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(sto, IsNil) +} + +func (s *LoaderSuite) TestLoadNonExistentIgnoreHost(c *C) { + sto, err := DefaultLoader.Load(s.endpoint(c, "https://github.com/does-not-exist")) + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(sto, IsNil) +} + +func (s *LoaderSuite) TestLoad(c *C) { + sto, err := DefaultLoader.Load(s.endpoint(c, fmt.Sprintf("file://%s", s.RepoPath))) + c.Assert(err, IsNil) + c.Assert(sto, NotNil) +} + +func (s *LoaderSuite) TestLoadIgnoreHost(c *C) { + sto, err := DefaultLoader.Load(s.endpoint(c, fmt.Sprintf("file://%s", s.RepoPath))) + c.Assert(err, IsNil) + c.Assert(sto, NotNil) +} diff --git a/plumbing/transport/server/receive_pack_test.go b/plumbing/transport/server/receive_pack_test.go new file mode 100644 index 0000000..2c4036a --- /dev/null +++ b/plumbing/transport/server/receive_pack_test.go @@ -0,0 +1,40 @@ +package server_test + +import ( + "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/plumbing/transport/test" + + . "gopkg.in/check.v1" +) + +type ReceivePackSuite struct { + BaseSuite + test.ReceivePackSuite +} + +var _ = Suite(&ReceivePackSuite{}) + +func (s *ReceivePackSuite) SetUpSuite(c *C) { + s.BaseSuite.SetUpSuite(c) + s.ReceivePackSuite.Client = s.client +} + +func (s *ReceivePackSuite) SetUpTest(c *C) { + s.prepareRepositories(c, &s.Endpoint, &s.EmptyEndpoint, &s.NonExistentEndpoint) +} + +func (s *ReceivePackSuite) TearDownTest(c *C) { + s.Suite.TearDownSuite(c) +} + +// TODO +func (s *ReceivePackSuite) TestSendPackAddDeleteReference(c *C) { + c.Skip("delete reference not supported yet") +} + +// Overwritten, server returns error earlier. +func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) { + r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint) + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(r, IsNil) +} diff --git a/plumbing/transport/server/server.go b/plumbing/transport/server/server.go new file mode 100644 index 0000000..6787e9d --- /dev/null +++ b/plumbing/transport/server/server.go @@ -0,0 +1,448 @@ +// Package server implements the git server protocol. For most use cases, the +// transport-specific implementations should be used. +package server + +import ( + "errors" + "fmt" + "io" + + "gopkg.in/src-d/go-git.v4/plumbing" + "gopkg.in/src-d/go-git.v4/plumbing/format/packfile" + "gopkg.in/src-d/go-git.v4/plumbing/object" + "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp" + "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability" + "gopkg.in/src-d/go-git.v4/plumbing/revlist" + "gopkg.in/src-d/go-git.v4/plumbing/storer" + "gopkg.in/src-d/go-git.v4/plumbing/transport" +) + +var DefaultServer = NewServer(DefaultLoader) + +type server struct { + loader Loader + handler *handler +} + +// NewServer returns a transport.Transport implementing a git server, +// independent of transport. Each transport must wrap this. +func NewServer(loader Loader) transport.Transport { + return &server{loader, &handler{}} +} + +func (s *server) NewUploadPackSession(ep transport.Endpoint) (transport.UploadPackSession, error) { + sto, err := s.loader.Load(ep) + if err != nil { + return nil, err + } + + return s.handler.NewUploadPackSession(sto) +} + +func (s *server) NewReceivePackSession(ep transport.Endpoint) (transport.ReceivePackSession, error) { + sto, err := s.loader.Load(ep) + if err != nil { + return nil, err + } + + return s.handler.NewReceivePackSession(sto) +} + +type handler struct{} + +func (h *handler) NewUploadPackSession(s storer.Storer) (transport.UploadPackSession, error) { + return &upSession{ + session: session{storer: s}, + }, nil +} + +func (h *handler) NewReceivePackSession(s storer.Storer) (transport.ReceivePackSession, error) { + return &rpSession{ + session: session{storer: s}, + cmdStatus: map[plumbing.ReferenceName]error{}, + }, nil +} + +type session struct { + storer storer.Storer + caps *capability.List +} + +func (s *session) Close() error { + return nil +} + +//TODO: deprecate +func (s *session) SetAuth(transport.AuthMethod) error { + return nil +} + +func (s *session) checkSupportedCapabilities(cl *capability.List) error { + for _, c := range cl.All() { + if !s.caps.Supports(c) { + return fmt.Errorf("unsupported capability: %s", c) + } + } + + return nil +} + +type upSession struct { + session +} + +func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) { + ar := packp.NewAdvRefs() + + if err := s.setSupportedCapabilities(ar.Capabilities); err != nil { + return nil, err + } + + s.caps = ar.Capabilities + + if err := setReferences(s.storer, ar); err != nil { + return nil, err + } + + if err := setHEAD(s.storer, ar); err != nil { + return nil, err + } + + return ar, nil +} + +func (s *upSession) UploadPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { + if req.IsEmpty() { + return nil, transport.ErrEmptyUploadPackRequest + } + + if err := req.Validate(); err != nil { + return nil, err + } + + if s.caps == nil { + s.caps = capability.NewList() + if err := s.setSupportedCapabilities(s.caps); err != nil { + return nil, err + } + } + + if err := s.checkSupportedCapabilities(req.Capabilities); err != nil { + return nil, err + } + + s.caps = req.Capabilities + + if len(req.Shallows) > 0 { + return nil, fmt.Errorf("shallow not supported") + } + + objs, err := s.objectsToUpload(req) + if err != nil { + return nil, err + } + + pr, pw := io.Pipe() + e := packfile.NewEncoder(pw, s.storer, false) + go func() { + _, err := e.Encode(objs) + pw.CloseWithError(err) + }() + + return packp.NewUploadPackResponseWithPackfile(req, pr), nil +} + +func (s *upSession) objectsToUpload(req *packp.UploadPackRequest) ([]plumbing.Hash, error) { + commits, err := s.commitsToUpload(req.Wants) + if err != nil { + return nil, err + } + + return revlist.Objects(s.storer, commits, req.Haves) +} + +func (s *upSession) commitsToUpload(wants []plumbing.Hash) ([]*object.Commit, error) { + var commits []*object.Commit + for _, h := range wants { + c, err := object.GetCommit(s.storer, h) + if err != nil { + return nil, err + } + + commits = append(commits, c) + } + + return commits, nil +} + +func (*upSession) setSupportedCapabilities(c *capability.List) error { + if err := c.Set(capability.Agent, capability.DefaultAgent); err != nil { + return err + } + + if err := c.Set(capability.OFSDelta); err != nil { + return err + } + + return nil +} + +type rpSession struct { + session + cmdStatus map[plumbing.ReferenceName]error + firstErr error + unpackErr error +} + +func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) { + ar := packp.NewAdvRefs() + + if err := s.setSupportedCapabilities(ar.Capabilities); err != nil { + return nil, err + } + + s.caps = ar.Capabilities + + if err := setReferences(s.storer, ar); err != nil { + return nil, err + } + + if err := setHEAD(s.storer, ar); err != nil { + return nil, err + } + + return ar, nil +} + +var ( + ErrUpdateReference = errors.New("failed to update ref") +) + +func (s *rpSession) ReceivePack(req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { + if s.caps == nil { + s.caps = capability.NewList() + if err := s.setSupportedCapabilities(s.caps); err != nil { + return nil, err + } + } + + if err := s.checkSupportedCapabilities(req.Capabilities); err != nil { + return nil, err + } + + s.caps = req.Capabilities + + //TODO: Implement 'atomic' update of references. + + if err := s.writePackfile(req.Packfile); err != nil { + s.unpackErr = err + s.firstErr = err + return s.reportStatus(), err + } + + updatedRefs := s.updatedReferences(req) + + if s.caps.Supports(capability.Atomic) && s.firstErr != nil { + //TODO: add support for 'atomic' once we have reference + // transactions, currently we do not announce it. + rs := s.reportStatus() + for _, cs := range rs.CommandStatuses { + if cs.Error() == nil { + cs.Status = "" + } + } + } + + for name, ref := range updatedRefs { + //TODO: add support for 'delete-refs' once we can delete + // references, currently we do not announce it. + err := s.storer.SetReference(ref) + s.setStatus(name, err) + } + + return s.reportStatus(), s.firstErr +} + +func (s *rpSession) updatedReferences(req *packp.ReferenceUpdateRequest) map[plumbing.ReferenceName]*plumbing.Reference { + refs := map[plumbing.ReferenceName]*plumbing.Reference{} + for _, cmd := range req.Commands { + exists, err := referenceExists(s.storer, cmd.Name) + if err != nil { + s.setStatus(cmd.Name, err) + continue + } + + switch cmd.Action() { + case packp.Create: + if exists { + s.setStatus(cmd.Name, ErrUpdateReference) + continue + } + + ref := plumbing.NewHashReference(cmd.Name, cmd.New) + refs[ref.Name()] = ref + case packp.Delete: + if !exists { + s.setStatus(cmd.Name, ErrUpdateReference) + continue + } + + if !s.caps.Supports(capability.DeleteRefs) { + s.setStatus(cmd.Name, fmt.Errorf("delete not supported")) + continue + } + + refs[cmd.Name] = nil + case packp.Update: + if !exists { + s.setStatus(cmd.Name, ErrUpdateReference) + continue + } + + if err != nil { + s.setStatus(cmd.Name, err) + continue + } + + ref := plumbing.NewHashReference(cmd.Name, cmd.New) + refs[ref.Name()] = ref + } + } + + return refs +} + +func (s *rpSession) failAtomicUpdate() (*packp.ReportStatus, error) { + rs := s.reportStatus() + for _, cs := range rs.CommandStatuses { + if cs.Error() == nil { + cs.Status = "atomic updated" + } + } + + return rs, s.firstErr +} + +func (s *rpSession) writePackfile(r io.ReadCloser) error { + if r == nil { + return nil + } + + if err := packfile.UpdateObjectStorage(s.storer, r); err != nil { + _ = r.Close() + return err + } + + return r.Close() +} + +func (s *rpSession) setStatus(ref plumbing.ReferenceName, err error) { + s.cmdStatus[ref] = err + if s.firstErr == nil && err != nil { + s.firstErr = err + } +} + +func (s *rpSession) reportStatus() *packp.ReportStatus { + if !s.caps.Supports(capability.ReportStatus) { + return nil + } + + rs := packp.NewReportStatus() + rs.UnpackStatus = "ok" + + if s.unpackErr != nil { + rs.UnpackStatus = s.unpackErr.Error() + } + + if s.cmdStatus == nil { + return rs + } + + for ref, err := range s.cmdStatus { + msg := "ok" + if err != nil { + msg = err.Error() + } + status := &packp.CommandStatus{ + ReferenceName: ref, + Status: msg, + } + rs.CommandStatuses = append(rs.CommandStatuses, status) + } + + return rs +} + +func (*rpSession) setSupportedCapabilities(c *capability.List) error { + if err := c.Set(capability.Agent, capability.DefaultAgent); err != nil { + return err + } + + if err := c.Set(capability.OFSDelta); err != nil { + return err + } + + return c.Set(capability.ReportStatus) +} + +func setHEAD(s storer.Storer, ar *packp.AdvRefs) error { + ref, err := s.Reference(plumbing.HEAD) + if err == plumbing.ErrReferenceNotFound { + return nil + } + + if err != nil { + return err + } + + if ref.Type() == plumbing.SymbolicReference { + if err := ar.AddReference(ref); err != nil { + return nil + } + + ref, err = storer.ResolveReference(s, ref.Target()) + if err == plumbing.ErrReferenceNotFound { + return nil + } + + if err != nil { + return err + } + } + + if ref.Type() != plumbing.HashReference { + return plumbing.ErrInvalidType + } + + h := ref.Hash() + ar.Head = &h + + return nil +} + +//TODO: add peeled references. +func setReferences(s storer.Storer, ar *packp.AdvRefs) error { + iter, err := s.IterReferences() + if err != nil { + return err + } + + return iter.ForEach(func(ref *plumbing.Reference) error { + if ref.Type() != plumbing.HashReference { + return nil + } + + ar.References[ref.Name().String()] = ref.Hash() + return nil + }) +} + +func referenceExists(s storer.ReferenceStorer, n plumbing.ReferenceName) (bool, error) { + _, err := s.Reference(n) + if err == plumbing.ErrReferenceNotFound { + return false, nil + } + + return err == nil, err +} diff --git a/plumbing/transport/server/server_test.go b/plumbing/transport/server/server_test.go new file mode 100644 index 0000000..2020fe3 --- /dev/null +++ b/plumbing/transport/server/server_test.go @@ -0,0 +1,70 @@ +package server_test + +import ( + "fmt" + "testing" + + "gopkg.in/src-d/go-git.v4/fixtures" + "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/plumbing/transport/client" + "gopkg.in/src-d/go-git.v4/plumbing/transport/server" + "gopkg.in/src-d/go-git.v4/storage/filesystem" + "gopkg.in/src-d/go-git.v4/storage/memory" + + . "gopkg.in/check.v1" +) + +func Test(t *testing.T) { TestingT(t) } + +const inprocScheme = "inproc" + +type BaseSuite struct { + fixtures.Suite + loader server.MapLoader + client transport.Transport + clientBackup transport.Transport +} + +func (s *BaseSuite) SetUpSuite(c *C) { + s.Suite.SetUpSuite(c) + s.loader = server.MapLoader{} + s.client = server.NewServer(s.loader) + s.clientBackup = client.Protocols[inprocScheme] + client.Protocols[inprocScheme] = s.client +} + +func (s *BaseSuite) TearDownSuite(c *C) { + if s.clientBackup == nil { + delete(client.Protocols, inprocScheme) + } else { + client.Protocols[inprocScheme] = s.clientBackup + } +} + +func (s *BaseSuite) prepareRepositories(c *C, basic *transport.Endpoint, + empty *transport.Endpoint, nonExistent *transport.Endpoint) { + + f := fixtures.Basic().One() + fs := f.DotGit() + path := fs.Base() + url := fmt.Sprintf("%s://%s", inprocScheme, path) + ep, err := transport.NewEndpoint(url) + c.Assert(err, IsNil) + *basic = ep + sto, err := filesystem.NewStorage(fs) + c.Assert(err, IsNil) + s.loader[ep] = sto + + path = "/empty.git" + url = fmt.Sprintf("%s://%s", inprocScheme, path) + ep, err = transport.NewEndpoint(url) + c.Assert(err, IsNil) + *empty = ep + s.loader[ep] = memory.NewStorage() + + path = "/non-existent.git" + url = fmt.Sprintf("%s://%s", inprocScheme, path) + ep, err = transport.NewEndpoint(url) + c.Assert(err, IsNil) + *nonExistent = ep +} diff --git a/plumbing/transport/server/upload_pack_test.go b/plumbing/transport/server/upload_pack_test.go new file mode 100644 index 0000000..8919e8e --- /dev/null +++ b/plumbing/transport/server/upload_pack_test.go @@ -0,0 +1,40 @@ +package server_test + +import ( + "gopkg.in/src-d/go-git.v4/plumbing/transport" + "gopkg.in/src-d/go-git.v4/plumbing/transport/test" + + . "gopkg.in/check.v1" +) + +type UploadPackSuite struct { + BaseSuite + test.UploadPackSuite +} + +var _ = Suite(&UploadPackSuite{}) + +func (s *UploadPackSuite) SetUpSuite(c *C) { + s.BaseSuite.SetUpSuite(c) + s.UploadPackSuite.Client = s.client +} + +func (s *UploadPackSuite) SetUpTest(c *C) { + s.prepareRepositories(c, &s.Endpoint, &s.EmptyEndpoint, &s.NonExistentEndpoint) +} + +// Overwritten, it's not an error in server-side. +func (s *UploadPackSuite) TestAdvertisedReferencesEmpty(c *C) { + r, err := s.Client.NewUploadPackSession(s.EmptyEndpoint) + c.Assert(err, IsNil) + ar, err := r.AdvertisedReferences() + c.Assert(err, IsNil) + c.Assert(len(ar.References), Equals, 0) +} + +// Overwritten, server returns error earlier. +func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { + r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint) + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(r, IsNil) +} diff --git a/plumbing/transport/ssh/fetch_pack_test.go b/plumbing/transport/ssh/upload_pack_test.go index 927e9a8..8194770 100644 --- a/plumbing/transport/ssh/fetch_pack_test.go +++ b/plumbing/transport/ssh/upload_pack_test.go @@ -9,29 +9,29 @@ import ( . "gopkg.in/check.v1" ) -type FetchPackSuite struct { - test.FetchPackSuite +type UploadPackSuite struct { + test.UploadPackSuite } -var _ = Suite(&FetchPackSuite{}) +var _ = Suite(&UploadPackSuite{}) -func (s *FetchPackSuite) SetUpSuite(c *C) { +func (s *UploadPackSuite) SetUpSuite(c *C) { if os.Getenv("SSH_AUTH_SOCK") == "" { c.Skip("SSH_AUTH_SOCK is not set") } - s.FetchPackSuite.Client = DefaultClient + s.UploadPackSuite.Client = DefaultClient ep, err := transport.NewEndpoint("git@github.com:git-fixtures/basic.git") c.Assert(err, IsNil) - s.FetchPackSuite.Endpoint = ep + s.UploadPackSuite.Endpoint = ep ep, err = transport.NewEndpoint("git@github.com:git-fixtures/empty.git") c.Assert(err, IsNil) - s.FetchPackSuite.EmptyEndpoint = ep + s.UploadPackSuite.EmptyEndpoint = ep ep, err = transport.NewEndpoint("git@github.com:git-fixtures/non-existent.git") c.Assert(err, IsNil) - s.FetchPackSuite.NonExistentEndpoint = ep + s.UploadPackSuite.NonExistentEndpoint = ep } diff --git a/plumbing/transport/test/send_pack.go b/plumbing/transport/test/receive_pack.go index f880588..e798154 100644 --- a/plumbing/transport/test/send_pack.go +++ b/plumbing/transport/test/receive_pack.go @@ -19,44 +19,44 @@ import ( . "gopkg.in/check.v1" ) -type SendPackSuite struct { +type ReceivePackSuite struct { Endpoint transport.Endpoint EmptyEndpoint transport.Endpoint NonExistentEndpoint transport.Endpoint - Client transport.Client + Client transport.Transport } -func (s *SendPackSuite) TestInfoEmpty(c *C) { - r, err := s.Client.NewSendPackSession(s.EmptyEndpoint) +func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty(c *C) { + r, err := s.Client.NewReceivePackSession(s.EmptyEndpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() - info, err := r.AdvertisedReferences() + ar, err := r.AdvertisedReferences() c.Assert(err, IsNil) - c.Assert(info.Head, IsNil) + c.Assert(ar.Head, IsNil) } -func (s *SendPackSuite) TestInfoNotExists(c *C) { - r, err := s.Client.NewSendPackSession(s.NonExistentEndpoint) +func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) { + r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() - info, err := r.AdvertisedReferences() + ar, err := r.AdvertisedReferences() c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(info, IsNil) + c.Assert(ar, IsNil) - r, err = s.Client.NewSendPackSession(s.NonExistentEndpoint) + r, err = s.Client.NewReceivePackSession(s.NonExistentEndpoint) c.Assert(err, IsNil) req := packp.NewReferenceUpdateRequest() req.Commands = []*packp.Command{ {"master", plumbing.ZeroHash, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")}, } - writer, err := r.SendPack(req) + writer, err := r.ReceivePack(req) c.Assert(err, Equals, transport.ErrRepositoryNotFound) c.Assert(writer, IsNil) } -func (s *SendPackSuite) TestCallAdvertisedReferenceTwice(c *C) { - r, err := s.Client.NewSendPackSession(s.Endpoint) +func (s *ReceivePackSuite) TestCallAdvertisedReferenceTwice(c *C) { + r, err := s.Client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) ar1, err := r.AdvertisedReferences() c.Assert(err, IsNil) @@ -66,8 +66,8 @@ func (s *SendPackSuite) TestCallAdvertisedReferenceTwice(c *C) { c.Assert(ar2, DeepEquals, ar1) } -func (s *SendPackSuite) TestDefaultBranch(c *C) { - r, err := s.Client.NewSendPackSession(s.Endpoint) +func (s *ReceivePackSuite) TestDefaultBranch(c *C) { + r, err := s.Client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -78,8 +78,8 @@ func (s *SendPackSuite) TestDefaultBranch(c *C) { c.Assert(ref, Equals, fixtures.Basic().One().Head) } -func (s *SendPackSuite) TestCapabilities(c *C) { - r, err := s.Client.NewSendPackSession(s.Endpoint) +func (s *ReceivePackSuite) TestCapabilities(c *C) { + r, err := s.Client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -88,7 +88,7 @@ func (s *SendPackSuite) TestCapabilities(c *C) { c.Assert(info.Capabilities.Get("agent"), HasLen, 1) } -func (s *SendPackSuite) TestFullSendPackOnEmpty(c *C) { +func (s *ReceivePackSuite) TestFullSendPackOnEmpty(c *C) { endpoint := s.EmptyEndpoint full := true fixture := fixtures.Basic().ByTag("packfile").One() @@ -96,11 +96,11 @@ func (s *SendPackSuite) TestFullSendPackOnEmpty(c *C) { req.Commands = []*packp.Command{ {"refs/heads/master", plumbing.ZeroHash, fixture.Head}, } - s.sendPack(c, endpoint, req, fixture, full) + s.receivePack(c, endpoint, req, fixture, full) s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) TestSendPackOnEmpty(c *C) { +func (s *ReceivePackSuite) TestSendPackOnEmpty(c *C) { endpoint := s.EmptyEndpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -108,11 +108,11 @@ func (s *SendPackSuite) TestSendPackOnEmpty(c *C) { req.Commands = []*packp.Command{ {"refs/heads/master", plumbing.ZeroHash, fixture.Head}, } - s.sendPack(c, endpoint, req, fixture, full) + s.receivePack(c, endpoint, req, fixture, full) s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) TestSendPackOnEmptyWithReportStatus(c *C) { +func (s *ReceivePackSuite) TestSendPackOnEmptyWithReportStatus(c *C) { endpoint := s.EmptyEndpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -121,11 +121,11 @@ func (s *SendPackSuite) TestSendPackOnEmptyWithReportStatus(c *C) { {"refs/heads/master", plumbing.ZeroHash, fixture.Head}, } req.Capabilities.Set(capability.ReportStatus) - s.sendPack(c, endpoint, req, fixture, full) + s.receivePack(c, endpoint, req, fixture, full) s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) TestFullSendPackOnNonEmpty(c *C) { +func (s *ReceivePackSuite) TestFullSendPackOnNonEmpty(c *C) { endpoint := s.Endpoint full := true fixture := fixtures.Basic().ByTag("packfile").One() @@ -133,11 +133,11 @@ func (s *SendPackSuite) TestFullSendPackOnNonEmpty(c *C) { req.Commands = []*packp.Command{ {"refs/heads/master", fixture.Head, fixture.Head}, } - s.sendPack(c, endpoint, req, fixture, full) + s.receivePack(c, endpoint, req, fixture, full) s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) TestSendPackOnNonEmpty(c *C) { +func (s *ReceivePackSuite) TestSendPackOnNonEmpty(c *C) { endpoint := s.Endpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -145,11 +145,11 @@ func (s *SendPackSuite) TestSendPackOnNonEmpty(c *C) { req.Commands = []*packp.Command{ {"refs/heads/master", fixture.Head, fixture.Head}, } - s.sendPack(c, endpoint, req, fixture, full) + s.receivePack(c, endpoint, req, fixture, full) s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) { +func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) { endpoint := s.Endpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -159,11 +159,11 @@ func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) { } req.Capabilities.Set(capability.ReportStatus) - s.sendPack(c, endpoint, req, fixture, full) + s.receivePack(c, endpoint, req, fixture, full) s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) { +func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) { endpoint := s.Endpoint full := false fixture := fixtures.Basic().ByTag("packfile").One() @@ -173,7 +173,7 @@ func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) { } req.Capabilities.Set(capability.ReportStatus) - report, err := s.sendPackNoCheck(c, endpoint, req, fixture, full) + report, err := s.receivePackNoCheck(c, endpoint, req, fixture, full) //XXX: Recent git versions return "failed to update ref", while older // (>=1.9) return "failed to lock". c.Assert(err, ErrorMatches, ".*(failed to update ref|failed to lock).*") @@ -184,7 +184,7 @@ func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) { s.checkRemoteHead(c, endpoint, fixture.Head) } -func (s *SendPackSuite) sendPackNoCheck(c *C, ep transport.Endpoint, +func (s *ReceivePackSuite) receivePackNoCheck(c *C, ep transport.Endpoint, req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture, callAdvertisedReferences bool) (*packp.ReportStatus, error) { url := "" @@ -196,7 +196,7 @@ func (s *SendPackSuite) sendPackNoCheck(c *C, ep transport.Endpoint, ep.String(), url, callAdvertisedReferences, ) - r, err := s.Client.NewSendPackSession(ep) + r, err := s.Client.NewReceivePackSession(ep) c.Assert(err, IsNil, comment) defer func() { c.Assert(r.Close(), IsNil, comment) }() @@ -213,10 +213,10 @@ func (s *SendPackSuite) sendPackNoCheck(c *C, ep transport.Endpoint, req.Packfile = s.emptyPackfile() } - return r.SendPack(req) + return r.ReceivePack(req) } -func (s *SendPackSuite) sendPack(c *C, ep transport.Endpoint, +func (s *ReceivePackSuite) receivePack(c *C, ep transport.Endpoint, req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture, callAdvertisedReferences bool) { @@ -229,7 +229,7 @@ func (s *SendPackSuite) sendPack(c *C, ep transport.Endpoint, "failed with ep=%s fixture=%s callAdvertisedReferences=%s", ep.String(), url, callAdvertisedReferences, ) - report, err := s.sendPackNoCheck(c, ep, req, fixture, callAdvertisedReferences) + report, err := s.receivePackNoCheck(c, ep, req, fixture, callAdvertisedReferences) c.Assert(err, IsNil, comment) if req.Capabilities.Supports(capability.ReportStatus) { @@ -240,14 +240,14 @@ func (s *SendPackSuite) sendPack(c *C, ep transport.Endpoint, } } -func (s *SendPackSuite) checkRemoteHead(c *C, ep transport.Endpoint, head plumbing.Hash) { +func (s *ReceivePackSuite) checkRemoteHead(c *C, ep transport.Endpoint, head plumbing.Hash) { s.checkRemoteReference(c, ep, "refs/heads/master", head) } -func (s *SendPackSuite) checkRemoteReference(c *C, ep transport.Endpoint, +func (s *ReceivePackSuite) checkRemoteReference(c *C, ep transport.Endpoint, refName string, head plumbing.Hash) { - r, err := s.Client.NewFetchPackSession(ep) + r, err := s.Client.NewUploadPackSession(ep) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() ar, err := r.AdvertisedReferences() @@ -261,13 +261,13 @@ func (s *SendPackSuite) checkRemoteReference(c *C, ep transport.Endpoint, } } -func (s *SendPackSuite) TestSendPackAddDeleteReference(c *C) { +func (s *ReceivePackSuite) TestSendPackAddDeleteReference(c *C) { s.testSendPackAddReference(c) s.testSendPackDeleteReference(c) } -func (s *SendPackSuite) testSendPackAddReference(c *C) { - r, err := s.Client.NewSendPackSession(s.Endpoint) +func (s *ReceivePackSuite) testSendPackAddReference(c *C) { + r, err := s.Client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -284,12 +284,12 @@ func (s *SendPackSuite) testSendPackAddReference(c *C) { req.Capabilities.Set(capability.ReportStatus) } - s.sendPack(c, s.Endpoint, req, nil, false) + s.receivePack(c, s.Endpoint, req, nil, false) s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", fixture.Head) } -func (s *SendPackSuite) testSendPackDeleteReference(c *C) { - r, err := s.Client.NewSendPackSession(s.Endpoint) +func (s *ReceivePackSuite) testSendPackDeleteReference(c *C) { + r, err := s.Client.NewReceivePackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -306,11 +306,11 @@ func (s *SendPackSuite) testSendPackDeleteReference(c *C) { req.Capabilities.Set(capability.ReportStatus) } - s.sendPack(c, s.Endpoint, req, nil, false) + s.receivePack(c, s.Endpoint, req, nil, false) s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.ZeroHash) } -func (s *SendPackSuite) emptyPackfile() io.ReadCloser { +func (s *ReceivePackSuite) emptyPackfile() io.ReadCloser { var buf bytes.Buffer e := packfile.NewEncoder(&buf, memory.NewStorage(), false) _, err := e.Encode(nil) diff --git a/plumbing/transport/test/fetch_pack.go b/plumbing/transport/test/upload_pack.go index 2984154..5af4b29 100644 --- a/plumbing/transport/test/fetch_pack.go +++ b/plumbing/transport/test/upload_pack.go @@ -18,39 +18,39 @@ import ( "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability" ) -type FetchPackSuite struct { +type UploadPackSuite struct { Endpoint transport.Endpoint EmptyEndpoint transport.Endpoint NonExistentEndpoint transport.Endpoint - Client transport.Client + Client transport.Transport } -func (s *FetchPackSuite) TestInfoEmpty(c *C) { - r, err := s.Client.NewFetchPackSession(s.EmptyEndpoint) +func (s *UploadPackSuite) TestAdvertisedReferencesEmpty(c *C) { + r, err := s.Client.NewUploadPackSession(s.EmptyEndpoint) c.Assert(err, IsNil) - info, err := r.AdvertisedReferences() + ar, err := r.AdvertisedReferences() c.Assert(err, Equals, transport.ErrEmptyRemoteRepository) - c.Assert(info, IsNil) + c.Assert(ar, IsNil) } -func (s *FetchPackSuite) TestInfoNotExists(c *C) { - r, err := s.Client.NewFetchPackSession(s.NonExistentEndpoint) +func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { + r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint) c.Assert(err, IsNil) - info, err := r.AdvertisedReferences() + ar, err := r.AdvertisedReferences() c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(info, IsNil) + c.Assert(ar, IsNil) - r, err = s.Client.NewFetchPackSession(s.NonExistentEndpoint) + r, err = s.Client.NewUploadPackSession(s.NonExistentEndpoint) c.Assert(err, IsNil) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - reader, err := r.FetchPack(req) + reader, err := r.UploadPack(req) c.Assert(err, Equals, transport.ErrRepositoryNotFound) c.Assert(reader, IsNil) } -func (s *FetchPackSuite) TestCallAdvertisedReferenceTwice(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestCallAdvertisedReferenceTwice(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) ar1, err := r.AdvertisedReferences() c.Assert(err, IsNil) @@ -60,8 +60,8 @@ func (s *FetchPackSuite) TestCallAdvertisedReferenceTwice(c *C) { c.Assert(ar2, DeepEquals, ar1) } -func (s *FetchPackSuite) TestDefaultBranch(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestDefaultBranch(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -72,8 +72,8 @@ func (s *FetchPackSuite) TestDefaultBranch(c *C) { c.Assert(symrefs[0], Equals, "HEAD:refs/heads/master") } -func (s *FetchPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -82,8 +82,8 @@ func (s *FetchPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) { c.Assert(info.Capabilities.Supports(capability.MultiACK), Equals, false) } -func (s *FetchPackSuite) TestCapabilities(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestCapabilities(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -92,8 +92,8 @@ func (s *FetchPackSuite) TestCapabilities(c *C) { c.Assert(info.Capabilities.Get(capability.Agent), HasLen, 1) } -func (s *FetchPackSuite) TestFullFetchPack(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestFullUploadPack(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -104,28 +104,28 @@ func (s *FetchPackSuite) TestFullFetchPack(c *C) { req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - reader, err := r.FetchPack(req) + reader, err := r.UploadPack(req) c.Assert(err, IsNil) s.checkObjectNumber(c, reader, 28) } -func (s *FetchPackSuite) TestFetchPack(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestUploadPack(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - reader, err := r.FetchPack(req) + reader, err := r.UploadPack(req) c.Assert(err, IsNil) s.checkObjectNumber(c, reader, 28) } -func (s *FetchPackSuite) TestFetchPackInvalidReq(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestUploadPackInvalidReq(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -134,12 +134,12 @@ func (s *FetchPackSuite) TestFetchPackInvalidReq(c *C) { req.Capabilities.Set(capability.Sideband) req.Capabilities.Set(capability.Sideband64k) - _, err = r.FetchPack(req) + _, err = r.UploadPack(req) c.Assert(err, NotNil) } -func (s *FetchPackSuite) TestFetchPackNoChanges(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestUploadPackNoChanges(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -147,13 +147,13 @@ func (s *FetchPackSuite) TestFetchPackNoChanges(c *C) { req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) req.Haves = append(req.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - reader, err := r.FetchPack(req) + reader, err := r.UploadPack(req) c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest) c.Assert(reader, IsNil) } -func (s *FetchPackSuite) TestFetchPackMulti(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestUploadPackMulti(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) defer func() { c.Assert(r.Close(), IsNil) }() @@ -161,28 +161,28 @@ func (s *FetchPackSuite) TestFetchPackMulti(c *C) { req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) req.Wants = append(req.Wants, plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")) - reader, err := r.FetchPack(req) + reader, err := r.UploadPack(req) c.Assert(err, IsNil) s.checkObjectNumber(c, reader, 31) } -func (s *FetchPackSuite) TestFetchError(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) +func (s *UploadPackSuite) TestFetchError(c *C) { + r, err := s.Client.NewUploadPackSession(s.Endpoint) c.Assert(err, IsNil) req := packp.NewUploadPackRequest() req.Wants = append(req.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) - reader, err := r.FetchPack(req) - c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest) + reader, err := r.UploadPack(req) + c.Assert(err, NotNil) c.Assert(reader, IsNil) //XXX: We do not test Close error, since implementations might return // different errors if a previous error was found. } -func (s *FetchPackSuite) checkObjectNumber(c *C, r io.Reader, n int) { +func (s *UploadPackSuite) checkObjectNumber(c *C, r io.Reader, n int) { b, err := ioutil.ReadAll(r) c.Assert(err, IsNil) buf := bytes.NewBuffer(b) @@ -130,7 +130,7 @@ func (r *Remote) fetch(o *FetchOptions) (refs storer.ReferenceStorer, err error) o.RefSpecs = r.c.Fetch } - s, err := newFetchPackSession(r.c.URL) + s, err := newUploadPackSession(r.c.URL) if err != nil { return nil, err } @@ -173,25 +173,25 @@ func (r *Remote) fetch(o *FetchOptions) (refs storer.ReferenceStorer, err error) return remoteRefs, err } -func newFetchPackSession(url string) (transport.FetchPackSession, error) { +func newUploadPackSession(url string) (transport.UploadPackSession, error) { c, ep, err := newClient(url) if err != nil { return nil, err } - return c.NewFetchPackSession(ep) + return c.NewUploadPackSession(ep) } -func newSendPackSession(url string) (transport.SendPackSession, error) { +func newSendPackSession(url string) (transport.ReceivePackSession, error) { c, ep, err := newClient(url) if err != nil { return nil, err } - return c.NewSendPackSession(ep) + return c.NewReceivePackSession(ep) } -func newClient(url string) (transport.Client, transport.Endpoint, error) { +func newClient(url string) (transport.Transport, transport.Endpoint, error) { ep, err := transport.NewEndpoint(url) if err != nil { return nil, transport.Endpoint{}, err @@ -205,10 +205,10 @@ func newClient(url string) (transport.Client, transport.Endpoint, error) { return c, ep, err } -func (r *Remote) fetchPack(o *FetchOptions, s transport.FetchPackSession, +func (r *Remote) fetchPack(o *FetchOptions, s transport.UploadPackSession, req *packp.UploadPackRequest) (err error) { - reader, err := s.FetchPack(req) + reader, err := s.UploadPack(req) if err != nil { return err } @@ -219,7 +219,7 @@ func (r *Remote) fetchPack(o *FetchOptions, s transport.FetchPackSession, return err } - if err = r.updateObjectStorage( + if err = packfile.UpdateObjectStorage(r.s, buildSidebandIfSupported(req.Capabilities, reader, r.p), ); err != nil { return err @@ -406,28 +406,6 @@ func (r *Remote) newUploadPackRequest(o *FetchOptions, return req, nil } -func (r *Remote) updateObjectStorage(reader io.Reader) error { - if sw, ok := r.s.(storer.PackfileWriter); ok { - w, err := sw.PackfileWriter() - if err != nil { - return err - } - - defer w.Close() - _, err = io.Copy(w, reader) - return err - } - - stream := packfile.NewScanner(reader) - d, err := packfile.NewDecoder(stream, r.s) - if err != nil { - return err - } - - _, err = d.Decode() - return err -} - func buildSidebandIfSupported(l *capability.List, reader io.Reader, p sideband.Progress) io.Reader { var t sideband.Type @@ -532,7 +510,7 @@ func referencesToHashes(refs storer.ReferenceStorer) ([]plumbing.Hash, error) { return hs, nil } -func pushHashes(sess transport.SendPackSession, sto storer.EncodedObjectStorer, +func pushHashes(sess transport.ReceivePackSession, sto storer.EncodedObjectStorer, req *packp.ReferenceUpdateRequest, hs []plumbing.Hash) (*packp.ReportStatus, error) { rd, wr := io.Pipe() @@ -548,7 +526,7 @@ func pushHashes(sess transport.SendPackSession, sto storer.EncodedObjectStorer, done <- wr.Close() }() - rs, err := sess.SendPack(req) + rs, err := sess.ReceivePack(req) if err != nil { return nil, err } |