Merge branch 'new-gitaly-repo-fields' into 'master'

Pass full Gitaly 'Repository' message on from Rails

See merge request !147

internal/api/api.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	"github.com/prometheus/client_golang/prometheus"
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 
 	"gitlab.com/gitlab-org/gitlab-workhorse/internal/badgateway"
 	"gitlab.com/gitlab-org/gitlab-workhorse/internal/helper"
@@ -90,8 +91,9 @@ type Response struct {
 	Terminal *TerminalSettings
 	// Path to Gitaly Socket
 	GitalySocketPath string
-	// Path to Gitaly HTTP resource
-	GitalyResourcePath string
+	// Repository object for making gRPC requests to Gitaly. This will
+	// eventually replace the RepoPath field.
+	Repository pb.Repository
 }
 
 // singleJoiningSlash is taken from reverseproxy.go:NewSingleHostReverseProxy
@@ -211,6 +213,14 @@ func (api *API) PreAuthorize(suffix string, r *http.Request) (httpResponse *http
 		return httpResponse, nil, fmt.Errorf("preAuthorizeHandler: decode authorization response: %v", err)
 	}
 
+	// This is for backwards compatiblity, can be depracated when Rails
+	// always sends a 'Repository' message. For the time being we cannot
+	// count on this, so we put some minimal data in the Repository struct.
+
+	if authResponse.Repository.Path == "" {
+		authResponse.Repository.Path = authResponse.RepoPath
+	}
+
 	return httpResponse, authResponse, nil
 }
 

internal/git/info-refs.go

@@ -67,7 +67,7 @@ func handleGetInfoRefsWithGitaly(w http.ResponseWriter, a *api.Response, rpc str
 		return fmt.Errorf("GetInfoRefsHandler: %v", err)
 	}
 
-	infoRefsResponseWriter, err := smarthttp.InfoRefsResponseWriterTo(a.RepoPath, rpc)
+	infoRefsResponseWriter, err := smarthttp.InfoRefsResponseWriterTo(&a.Repository, rpc)
 	if err != nil {
 		return fmt.Errorf("GetInfoRefsHandler: %v", err)
 	}

internal/gitaly/smarthttp.go

@@ -13,8 +13,7 @@ type SmartHTTPClient struct {
 	pb.SmartHTTPClient
 }
 
-func (client *SmartHTTPClient) InfoRefsResponseWriterTo(repoPath, rpc string) (io.WriterTo, error) {
-	repo := &pb.Repository{Path: repoPath}
+func (client *SmartHTTPClient) InfoRefsResponseWriterTo(repo *pb.Repository, rpc string) (io.WriterTo, error) {
 	rpcRequest := &pb.InfoRefsRequest{Repository: repo}
 	var c pbhelper.InfoRefsClient
 	var err error

internal/testhelper/gitaly.go

@@ -25,3 +25,7 @@ func (s *GitalyTestServer) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb
 	}
 	return stream.Send(response)
 }
+
+// TODO replace these empty implementations
+func (*GitalyTestServer) PostUploadPack(pb.SmartHTTP_PostUploadPackServer) error   { return nil }
+func (*GitalyTestServer) PostReceivePack(pb.SmartHTTP_PostReceivePackServer) error { return nil }

main_test.go

@@ -594,36 +594,48 @@ func TestApiContentTypeBlock(t *testing.T) {
 }
 
 func TestGetInfoRefsProxiedToGitalySuccessfully(t *testing.T) {
-	apiResponse := gitOkBody(t)
-	apiResponse.GitalyResourcePath = "/projects/1/git-http/info-refs"
-
 	gitalyServer := startGitalyServer(t)
 	defer func() {
 		gitalyServer.Stop()
 		gitaly.CloseConnections()
 	}()
 
-	apiResponse.GitalySocketPath = gitalySocketPath
-	ts := testAuthServer(nil, 200, apiResponse)
-	defer ts.Close()
-
-	ws := startWorkhorseServer(ts.URL)
-	defer ws.Close()
+	apiResponse := gitOkBody(t)
+	repoPath := apiResponse.RepoPath
 
-	resource := "/gitlab-org/gitlab-test.git/info/refs?service=git-upload-pack"
-	resp, err := http.Get(ws.URL + resource)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer resp.Body.Close()
-	responseBody, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		t.Error(err)
-	}
+	for _, testCase := range []struct {
+		repoPath   string
+		repository pb.Repository
+	}{
+		{repoPath: repoPath},
+		{repoPath: repoPath, repository: pb.Repository{Path: repoPath, StorageName: "foobar", RelativePath: "baz.git"}},
+	} {
+		func() {
+			apiResponse.RepoPath = testCase.repoPath
+			apiResponse.Repository = testCase.repository
+			apiResponse.GitalySocketPath = gitalySocketPath
+			ts := testAuthServer(nil, 200, apiResponse)
+			defer ts.Close()
+
+			ws := startWorkhorseServer(ts.URL)
+			defer ws.Close()
+
+			resource := "/gitlab-org/gitlab-test.git/info/refs?service=git-upload-pack"
+			resp, err := http.Get(ws.URL + resource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer resp.Body.Close()
+			responseBody, err := ioutil.ReadAll(resp.Body)
+			if err != nil {
+				t.Error(err)
+			}
 
-	expectedContent := testhelper.GitalyInfoRefsResponseMock
-	if !bytes.Equal(responseBody, []byte(expectedContent)) {
-		t.Errorf("GET %q: Expected %q, got %q", resource, expectedContent, responseBody)
+			expectedContent := testhelper.GitalyInfoRefsResponseMock
+			if !bytes.Equal(responseBody, []byte(expectedContent)) {
+				t.Errorf("GET %q: Expected %q, got %q", resource, expectedContent, responseBody)
+			}
+		}()
 	}
 }
 

vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go

+// Code generated by protoc-gen-go.
+// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+// DO NOT EDIT!
+
+/*
+Package timestamp is a generated protocol buffer package.
+
+It is generated from these files:
+	github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+
+It has these top-level messages:
+	Timestamp
+*/
+package timestamp
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+type Timestamp struct {
+	// Represents seconds of UTC time since Unix epoch
+	// 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+	// 9999-12-31T23:59:59Z inclusive.
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
+	// Non-negative fractions of a second at nanosecond resolution. Negative
+	// second values with fractions must still have non-negative nanos values
+	// that count forward in time. Must be from 0 to 999,999,999
+	// inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
+}
+
+func (m *Timestamp) Reset()                    { *m = Timestamp{} }
+func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage()               {}
+func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Timestamp) XXX_WellKnownType() string   { return "Timestamp" }
+
+func init() {
+	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
+}
+
+func init() {
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/timestamp/timestamp.proto", fileDescriptor0)
+}
+
+var fileDescriptor0 = []byte{
+	// 194 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9,
+	0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28,
+	0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2f, 0xc9,
+	0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x40, 0xb0, 0xf4, 0xc0, 0x6a, 0x84, 0xf8, 0xd3, 0xf3,
+	0xf3, 0xd3, 0x73, 0x52, 0xf5, 0x60, 0x3a, 0x94, 0xac, 0xb9, 0x38, 0x43, 0x60, 0x6a, 0x84, 0x24,
+	0xb8, 0xd8, 0x8b, 0x53, 0x93, 0xf3, 0xf3, 0x52, 0x8a, 0x25, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83,
+	0x60, 0x5c, 0x21, 0x11, 0x2e, 0xd6, 0xbc, 0xc4, 0xbc, 0xfc, 0x62, 0x09, 0x26, 0x05, 0x46, 0x0d,
+	0xd6, 0x20, 0x08, 0xc7, 0xa9, 0x91, 0x91, 0x4b, 0x38, 0x39, 0x3f, 0x57, 0x0f, 0xcd, 0x50, 0x27,
+	0x3e, 0xb8, 0x91, 0x01, 0x20, 0xa1, 0x00, 0xc6, 0x28, 0x6d, 0x12, 0x1c, 0xbd, 0x80, 0x91, 0xf1,
+	0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10, 0xc3, 0x03,
+	0xa0, 0xca, 0xf5, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40, 0xda, 0x92,
+	0xd8, 0xc0, 0xe6, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x17, 0x5f, 0xb7, 0xdc, 0x17, 0x01,
+	0x00, 0x00,
+}

vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto

+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/timestamp";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option java_generate_equals_and_hash = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+message Timestamp {
+
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION

-0.3.0
+0.5.0

vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go

+// Code generated by protoc-gen-go.
+// source: commit.proto
+// DO NOT EDIT!
+
+/*
+Package gitaly is a generated protocol buffer package.
+
+It is generated from these files:
+	commit.proto
+	diff.proto
+	notifications.proto
+	ref.proto
+	shared.proto
+	smarthttp.proto
+	ssh.proto
+
+It has these top-level messages:
+	CommitIsAncestorRequest
+	CommitIsAncestorResponse
+	CommitDiffRequest
+	CommitDiffResponse
+	PostReceiveRequest
+	PostReceiveResponse
+	FindDefaultBranchNameRequest
+	FindDefaultBranchNameResponse
+	FindAllBranchNamesRequest
+	FindAllBranchNamesResponse
+	FindAllTagNamesRequest
+	FindAllTagNamesResponse
+	FindRefNameRequest
+	FindRefNameResponse
+	FindLocalBranchesRequest
+	FindLocalBranchesResponse
+	FindLocalBranchResponse
+	FindLocalBranchCommitAuthor
+	Repository
+	ExitStatus
+	InfoRefsRequest
+	InfoRefsResponse
+	PostUploadPackRequest
+	PostUploadPackResponse
+	PostReceivePackRequest
+	PostReceivePackResponse
+	SSHUploadPackRequest
+	SSHUploadPackResponse
+	SSHReceivePackRequest
+	SSHReceivePackResponse
+*/
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type CommitIsAncestorRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	AncestorId string      `protobuf:"bytes,2,opt,name=ancestor_id,json=ancestorId" json:"ancestor_id,omitempty"`
+	ChildId    string      `protobuf:"bytes,3,opt,name=child_id,json=childId" json:"child_id,omitempty"`
+}
+
+func (m *CommitIsAncestorRequest) Reset()                    { *m = CommitIsAncestorRequest{} }
+func (m *CommitIsAncestorRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitIsAncestorRequest) ProtoMessage()               {}
+func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *CommitIsAncestorRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitIsAncestorRequest) GetAncestorId() string {
+	if m != nil {
+		return m.AncestorId
+	}
+	return ""
+}
+
+func (m *CommitIsAncestorRequest) GetChildId() string {
+	if m != nil {
+		return m.ChildId
+	}
+	return ""
+}
+
+type CommitIsAncestorResponse struct {
+	Value bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *CommitIsAncestorResponse) Reset()                    { *m = CommitIsAncestorResponse{} }
+func (m *CommitIsAncestorResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitIsAncestorResponse) ProtoMessage()               {}
+func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *CommitIsAncestorResponse) GetValue() bool {
+	if m != nil {
+		return m.Value
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
+	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Commit service
+
+type CommitClient interface {
+	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
+}
+
+type commitClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewCommitClient(cc *grpc.ClientConn) CommitClient {
+	return &commitClient{cc}
+}
+
+func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
+	out := new(CommitIsAncestorResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Commit/CommitIsAncestor", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Commit service
+
+type CommitServer interface {
+	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
+}
+
+func RegisterCommitServer(s *grpc.Server, srv CommitServer) {
+	s.RegisterService(&_Commit_serviceDesc, srv)
+}
+
+func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CommitIsAncestorRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CommitServer).CommitIsAncestor(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Commit/CommitIsAncestor",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Commit_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Commit",
+	HandlerType: (*CommitServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CommitIsAncestor",
+			Handler:    _Commit_CommitIsAncestor_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "commit.proto",
+}
+
+func init() { proto.RegisterFile("commit.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 213 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x50, 0xbf, 0x4e, 0x84, 0x30,
+	0x18, 0xb7, 0x1a, 0x11, 0x3f, 0x18, 0xcc, 0x17, 0x13, 0x91, 0x05, 0xc2, 0xc4, 0x44, 0x0c, 0x3e,
+	0x81, 0x71, 0x62, 0xed, 0xe2, 0x68, 0x2a, 0x6d, 0xa4, 0x09, 0x50, 0x6c, 0x8b, 0x09, 0x8f, 0x70,
+	0x6f, 0x7d, 0xb9, 0xf6, 0xb8, 0x5c, 0xee, 0xc2, 0xf8, 0xfb, 0xdb, 0x5f, 0x3f, 0x88, 0x5b, 0x35,
+	0x0c, 0xd2, 0x56, 0x93, 0x56, 0x56, 0x61, 0xf0, 0x2b, 0x2d, 0xeb, 0x97, 0x34, 0x36, 0x1d, 0xd3,
+	0x82, 0x7b, 0xb6, 0xd8, 0x11, 0x78, 0xf9, 0x74, 0xb6, 0xc6, 0x7c, 0x8c, 0xad, 0x30, 0x56, 0x69,
+	0x2a, 0xfe, 0x66, 0x61, 0x2c, 0xd6, 0x00, 0x5a, 0x4c, 0xca, 0x48, 0xab, 0xf4, 0x92, 0x90, 0x9c,
+	0x94, 0x51, 0x8d, 0x95, 0xaf, 0xa9, 0xe8, 0x49, 0xa1, 0x67, 0x2e, 0xcc, 0x20, 0x62, 0xc7, 0x9a,
+	0x6f, 0xc9, 0x93, 0xdb, 0x9c, 0x94, 0x8f, 0x14, 0x56, 0xaa, 0xe1, 0xf8, 0x0a, 0x61, 0xdb, 0xc9,
+	0x9e, 0x1f, 0xd4, 0x3b, 0xa7, 0x3e, 0x38, 0xdc, 0xf0, 0xe2, 0x0d, 0x92, 0xeb, 0x29, 0x66, 0x52,
+	0xa3, 0x11, 0xf8, 0x0c, 0xf7, 0xff, 0xac, 0x9f, 0x85, 0x9b, 0x11, 0x52, 0x0f, 0x6a, 0x06, 0x81,
+	0x4f, 0xe0, 0x17, 0x3c, 0x5d, 0x66, 0x31, 0x5b, 0xb7, 0x6e, 0x7c, 0x30, 0xcd, 0xb7, 0x0d, 0xfe,
+	0xd9, 0xe2, 0xe6, 0x27, 0x70, 0x77, 0x7a, 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x48, 0xb7,
+	0xcb, 0x4d, 0x01, 0x00, 0x00,
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go

+// Code generated by protoc-gen-go.
+// source: diff.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type CommitDiffRequest struct {
+	Repository    *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	LeftCommitId  string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId" json:"left_commit_id,omitempty"`
+	RightCommitId string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId" json:"right_commit_id,omitempty"`
+}
+
+func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
+func (m *CommitDiffRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitDiffRequest) ProtoMessage()               {}
+func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+
+func (m *CommitDiffRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitDiffRequest) GetLeftCommitId() string {
+	if m != nil {
+		return m.LeftCommitId
+	}
+	return ""
+}
+
+func (m *CommitDiffRequest) GetRightCommitId() string {
+	if m != nil {
+		return m.RightCommitId
+	}
+	return ""
+}
+
+// A CommitDiffResponse corresponds to a single changed file in a commit.
+type CommitDiffResponse struct {
+	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
+	ToPath   []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
+	// Blob ID as returned via `git diff --full-index`
+	FromId    string   `protobuf:"bytes,3,opt,name=from_id,json=fromId" json:"from_id,omitempty"`
+	ToId      string   `protobuf:"bytes,4,opt,name=to_id,json=toId" json:"to_id,omitempty"`
+	OldMode   int32    `protobuf:"varint,5,opt,name=old_mode,json=oldMode" json:"old_mode,omitempty"`
+	NewMode   int32    `protobuf:"varint,6,opt,name=new_mode,json=newMode" json:"new_mode,omitempty"`
+	Binary    bool     `protobuf:"varint,7,opt,name=binary" json:"binary,omitempty"`
+	RawChunks [][]byte `protobuf:"bytes,8,rep,name=raw_chunks,json=rawChunks,proto3" json:"raw_chunks,omitempty"`
+}
+
+func (m *CommitDiffResponse) Reset()                    { *m = CommitDiffResponse{} }
+func (m *CommitDiffResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitDiffResponse) ProtoMessage()               {}
+func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+
+func (m *CommitDiffResponse) GetFromPath() []byte {
+	if m != nil {
+		return m.FromPath
+	}
+	return nil
+}
+
+func (m *CommitDiffResponse) GetToPath() []byte {
+	if m != nil {
+		return m.ToPath
+	}
+	return nil
+}
+
+func (m *CommitDiffResponse) GetFromId() string {
+	if m != nil {
+		return m.FromId
+	}
+	return ""
+}
+
+func (m *CommitDiffResponse) GetToId() string {
+	if m != nil {
+		return m.ToId
+	}
+	return ""
+}
+
+func (m *CommitDiffResponse) GetOldMode() int32 {
+	if m != nil {
+		return m.OldMode
+	}
+	return 0
+}
+
+func (m *CommitDiffResponse) GetNewMode() int32 {
+	if m != nil {
+		return m.NewMode
+	}
+	return 0
+}
+
+func (m *CommitDiffResponse) GetBinary() bool {
+	if m != nil {
+		return m.Binary
+	}
+	return false
+}
+
+func (m *CommitDiffResponse) GetRawChunks() [][]byte {
+	if m != nil {
+		return m.RawChunks
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CommitDiffRequest)(nil), "gitaly.CommitDiffRequest")
+	proto.RegisterType((*CommitDiffResponse)(nil), "gitaly.CommitDiffResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Diff service
+
+type DiffClient interface {
+	// Returns stream of CommitDiffResponse: 1 per changed file
+	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
+}
+
+type diffClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewDiffClient(cc *grpc.ClientConn) DiffClient {
+	return &diffClient{cc}
+}
+
+func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[0], c.cc, "/gitaly.Diff/CommitDiff", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &diffCommitDiffClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Diff_CommitDiffClient interface {
+	Recv() (*CommitDiffResponse, error)
+	grpc.ClientStream
+}
+
+type diffCommitDiffClient struct {
+	grpc.ClientStream
+}
+
+func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) {
+	m := new(CommitDiffResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Diff service
+
+type DiffServer interface {
+	// Returns stream of CommitDiffResponse: 1 per changed file
+	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
+}
+
+func RegisterDiffServer(s *grpc.Server, srv DiffServer) {
+	s.RegisterService(&_Diff_serviceDesc, srv)
+}
+
+func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CommitDiffRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DiffServer).CommitDiff(m, &diffCommitDiffServer{stream})
+}
+
+type Diff_CommitDiffServer interface {
+	Send(*CommitDiffResponse) error
+	grpc.ServerStream
+}
+
+type diffCommitDiffServer struct {
+	grpc.ServerStream
+}
+
+func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _Diff_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Diff",
+	HandlerType: (*DiffServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "CommitDiff",
+			Handler:       _Diff_CommitDiff_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "diff.proto",
+}
+
+func init() { proto.RegisterFile("diff.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 328 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xdd, 0x4a, 0xf3, 0x30,
+	0x18, 0xc7, 0xdf, 0xec, 0xa3, 0xeb, 0x9e, 0xb7, 0x2a, 0x46, 0xd0, 0x6e, 0x22, 0x94, 0x21, 0xd2,
+	0xa3, 0x21, 0xf3, 0x12, 0x26, 0xc8, 0x0e, 0x44, 0xc9, 0x0d, 0x94, 0x6c, 0x49, 0xd7, 0x60, 0xdb,
+	0xa7, 0xa6, 0x19, 0x65, 0x17, 0xe2, 0x25, 0x7a, 0x1f, 0xd2, 0xc4, 0xcd, 0x82, 0x1e, 0xe6, 0xf7,
+	0xfb, 0x27, 0x79, 0x3e, 0x00, 0x84, 0x4a, 0xd3, 0x79, 0xa5, 0xd1, 0x20, 0xf5, 0xb6, 0xca, 0xf0,
+	0x7c, 0x3f, 0x0d, 0xea, 0x8c, 0x6b, 0x29, 0x1c, 0x9d, 0x7d, 0x10, 0x38, 0x5f, 0x62, 0x51, 0x28,
+	0xf3, 0xa8, 0xd2, 0x94, 0xc9, 0xf7, 0x9d, 0xac, 0x0d, 0x5d, 0x00, 0x68, 0x59, 0x61, 0xad, 0x0c,
+	0xea, 0x7d, 0x48, 0x22, 0x12, 0xff, 0x5f, 0xd0, 0xb9, 0x7b, 0x60, 0xce, 0x8e, 0x86, 0x75, 0x52,
+	0xf4, 0x16, 0x4e, 0x73, 0x99, 0x9a, 0x64, 0x63, 0x5f, 0x4b, 0x94, 0x08, 0x7b, 0x11, 0x89, 0xc7,
+	0x2c, 0x68, 0xa9, 0xfb, 0x62, 0x25, 0xe8, 0x1d, 0x9c, 0x69, 0xb5, 0xcd, 0xba, 0xb1, 0xbe, 0x8d,
+	0x9d, 0x58, 0x7c, 0xc8, 0xcd, 0x3e, 0x09, 0xd0, 0x6e, 0x5d, 0x75, 0x85, 0x65, 0x2d, 0xe9, 0x35,
+	0x8c, 0x53, 0x8d, 0x45, 0x52, 0x71, 0x93, 0xd9, 0xba, 0x02, 0xe6, 0xb7, 0xe0, 0x95, 0x9b, 0x8c,
+	0x5e, 0xc1, 0xc8, 0xa0, 0x53, 0x3d, 0xab, 0x3c, 0x83, 0x07, 0x61, 0x6f, 0x1d, 0x3f, 0xf3, 0xda,
+	0xe3, 0x4a, 0xd0, 0x0b, 0x18, 0x1a, 0x6c, 0xf1, 0xc0, 0xe2, 0x81, 0xc1, 0x95, 0xa0, 0x13, 0xf0,
+	0x31, 0x17, 0x49, 0x81, 0x42, 0x86, 0xc3, 0x88, 0xc4, 0x43, 0x36, 0xc2, 0x5c, 0x3c, 0xa3, 0x90,
+	0xad, 0x2a, 0x65, 0xe3, 0x94, 0xe7, 0x54, 0x29, 0x1b, 0xab, 0x2e, 0xc1, 0x5b, 0xab, 0x92, 0xeb,
+	0x7d, 0x38, 0x8a, 0x48, 0xec, 0xb3, 0xef, 0x13, 0xbd, 0x01, 0xd0, 0xbc, 0x49, 0x36, 0xd9, 0xae,
+	0x7c, 0xab, 0x43, 0x3f, 0xea, 0xc7, 0x01, 0x1b, 0x6b, 0xde, 0x2c, 0x2d, 0x58, 0xbc, 0xc0, 0xa0,
+	0x6d, 0x90, 0x3e, 0x01, 0xfc, 0xb4, 0x4b, 0x27, 0x87, 0x59, 0xff, 0x5a, 0xcd, 0x74, 0xfa, 0x97,
+	0x72, 0xd3, 0x99, 0xfd, 0xbb, 0x27, 0x6b, 0xcf, 0xee, 0xf5, 0xe1, 0x2b, 0x00, 0x00, 0xff, 0xff,
+	0xca, 0xe9, 0x71, 0x86, 0xfb, 0x01, 0x00, 0x00,
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go

+// Code generated by protoc-gen-go.
+// source: notifications.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type PostReceiveRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
+func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostReceiveRequest) ProtoMessage()               {}
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+
+func (m *PostReceiveRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type PostReceiveResponse struct {
+}
+
+func (m *PostReceiveResponse) Reset()                    { *m = PostReceiveResponse{} }
+func (m *PostReceiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostReceiveResponse) ProtoMessage()               {}
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+
+func init() {
+	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
+	proto.RegisterType((*PostReceiveResponse)(nil), "gitaly.PostReceiveResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Notifications service
+
+type NotificationsClient interface {
+	PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error)
+}
+
+type notificationsClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient {
+	return &notificationsClient{cc}
+}
+
+func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
+	out := new(PostReceiveResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Notifications service
+
+type NotificationsServer interface {
+	PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error)
+}
+
+func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) {
+	s.RegisterService(&_Notifications_serviceDesc, srv)
+}
+
+func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PostReceiveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NotificationsServer).PostReceive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Notifications/PostReceive",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Notifications_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Notifications",
+	HandlerType: (*NotificationsServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "PostReceive",
+			Handler:    _Notifications_PostReceive_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "notifications.proto",
+}
+
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor2) }
+
+var fileDescriptor2 = []byte{
+	// 163 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9,
+	0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
+	0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81,
+	0x88, 0x2a, 0x79, 0x70, 0x09, 0x05, 0xe4, 0x17, 0x97, 0x04, 0xa5, 0x26, 0xa7, 0x66, 0x96, 0xa5,
+	0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
+	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x0c,
+	0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x52, 0x12, 0xe5, 0x12, 0x46, 0x31, 0xa9, 0xb8, 0x20,
+	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x92, 0x8b, 0xd7, 0x0f, 0xd9, 0x35, 0x42, 0x1e, 0x5c, 0xdc, 0x48,
+	0xea, 0x84, 0xa4, 0x60, 0xc6, 0x62, 0x3a, 0x43, 0x4a, 0x1a, 0xab, 0x1c, 0xc4, 0x60, 0x25, 0x86,
+	0x24, 0x36, 0xb0, 0x17, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x5e, 0x1f, 0x64, 0xef,
+	0x00, 0x00, 0x00,
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitaly.pb.go → vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go

 // Code generated by protoc-gen-go.
-// source: gitaly.proto
+// source: ref.proto
 // DO NOT EDIT!
 
-/*
-Package gitaly is a generated protocol buffer package.
-
-It is generated from these files:
-	gitaly.proto
-	shared.proto
-	smarthttp.proto
-	ssh.proto
-
-It has these top-level messages:
-	CommitIsAncestorResponse
-	PostReceiveRequest
-	PostReceiveResponse
-	FindRefNameRequest
-	FindRefNameResponse
-	CommitIsAncestorRequest
-	FindDefaultBranchNameRequest
-	FindAllBranchNamesRequest
-	FindAllTagNamesRequest
-	FindDefaultBranchNameResponse
-	FindAllBranchNamesResponse
-	FindAllTagNamesResponse
-	CommitDiffRequest
-	CommitDiffResponse
-	Repository
-	ExitStatus
-	InfoRefsRequest
-	InfoRefsResponse
-	SSHUploadPackRequest
-	SSHUploadPackResponse
-	SSHReceivePackRequest
-	SSHReceivePackResponse
-*/
 package gitaly
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/timestamp"
 
 import (
 	context "golang.org/x/net/context"
@@ -51,352 +19,313 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type CommitIsAncestorResponse struct {
-	Value bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
-}
+type FindLocalBranchesRequest_SortBy int32
 
-func (m *CommitIsAncestorResponse) Reset()                    { *m = CommitIsAncestorResponse{} }
-func (m *CommitIsAncestorResponse) String() string            { return proto.CompactTextString(m) }
-func (*CommitIsAncestorResponse) ProtoMessage()               {}
-func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+const (
+	FindLocalBranchesRequest_NAME         FindLocalBranchesRequest_SortBy = 0
+	FindLocalBranchesRequest_UPDATED_ASC  FindLocalBranchesRequest_SortBy = 1
+	FindLocalBranchesRequest_UPDATED_DESC FindLocalBranchesRequest_SortBy = 2
+)
 
-func (m *CommitIsAncestorResponse) GetValue() bool {
-	if m != nil {
-		return m.Value
-	}
-	return false
+var FindLocalBranchesRequest_SortBy_name = map[int32]string{
+	0: "NAME",
+	1: "UPDATED_ASC",
+	2: "UPDATED_DESC",
 }
-
-type PostReceiveRequest struct {
-	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+var FindLocalBranchesRequest_SortBy_value = map[string]int32{
+	"NAME":         0,
+	"UPDATED_ASC":  1,
+	"UPDATED_DESC": 2,
 }
 
-func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
-func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
-func (*PostReceiveRequest) ProtoMessage()               {}
-func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
-
-func (m *PostReceiveRequest) GetRepository() *Repository {
-	if m != nil {
-		return m.Repository
-	}
-	return nil
+func (x FindLocalBranchesRequest_SortBy) String() string {
+	return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
 }
-
-type PostReceiveResponse struct {
+func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor3, []int{8, 0}
 }
 
-func (m *PostReceiveResponse) Reset()                    { *m = PostReceiveResponse{} }
-func (m *PostReceiveResponse) String() string            { return proto.CompactTextString(m) }
-func (*PostReceiveResponse) ProtoMessage()               {}
-func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
-
-type FindRefNameRequest struct {
+type FindDefaultBranchNameRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-	// Require that the resulting ref contains this commit as an ancestor
-	CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
-	// Example prefix: "refs/heads/". Type bytes because that is the type of ref names.
-	Prefix []byte `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
 }
 
-func (m *FindRefNameRequest) Reset()                    { *m = FindRefNameRequest{} }
-func (m *FindRefNameRequest) String() string            { return proto.CompactTextString(m) }
-func (*FindRefNameRequest) ProtoMessage()               {}
-func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+func (m *FindDefaultBranchNameRequest) Reset()                    { *m = FindDefaultBranchNameRequest{} }
+func (m *FindDefaultBranchNameRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindDefaultBranchNameRequest) ProtoMessage()               {}
+func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
 
-func (m *FindRefNameRequest) GetRepository() *Repository {
+func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
 	if m != nil {
 		return m.Repository
 	}
 	return nil
 }
 
-func (m *FindRefNameRequest) GetCommitId() string {
-	if m != nil {
-		return m.CommitId
-	}
-	return ""
-}
-
-func (m *FindRefNameRequest) GetPrefix() []byte {
-	if m != nil {
-		return m.Prefix
-	}
-	return nil
-}
-
-type FindRefNameResponse struct {
-	// Example name: "refs/heads/master". Cannot assume UTF8, so the type is bytes.
+type FindDefaultBranchNameResponse struct {
 	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 }
 
-func (m *FindRefNameResponse) Reset()                    { *m = FindRefNameResponse{} }
-func (m *FindRefNameResponse) String() string            { return proto.CompactTextString(m) }
-func (*FindRefNameResponse) ProtoMessage()               {}
-func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+func (m *FindDefaultBranchNameResponse) Reset()                    { *m = FindDefaultBranchNameResponse{} }
+func (m *FindDefaultBranchNameResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindDefaultBranchNameResponse) ProtoMessage()               {}
+func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
 
-func (m *FindRefNameResponse) GetName() []byte {
+func (m *FindDefaultBranchNameResponse) GetName() []byte {
 	if m != nil {
 		return m.Name
 	}
 	return nil
 }
 
-type CommitIsAncestorRequest struct {
+type FindAllBranchNamesRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-	AncestorId string      `protobuf:"bytes,2,opt,name=ancestor_id,json=ancestorId" json:"ancestor_id,omitempty"`
-	ChildId    string      `protobuf:"bytes,3,opt,name=child_id,json=childId" json:"child_id,omitempty"`
 }
 
-func (m *CommitIsAncestorRequest) Reset()                    { *m = CommitIsAncestorRequest{} }
-func (m *CommitIsAncestorRequest) String() string            { return proto.CompactTextString(m) }
-func (*CommitIsAncestorRequest) ProtoMessage()               {}
-func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+func (m *FindAllBranchNamesRequest) Reset()                    { *m = FindAllBranchNamesRequest{} }
+func (m *FindAllBranchNamesRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindAllBranchNamesRequest) ProtoMessage()               {}
+func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
 
-func (m *CommitIsAncestorRequest) GetRepository() *Repository {
+func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
 	if m != nil {
 		return m.Repository
 	}
 	return nil
 }
 
-func (m *CommitIsAncestorRequest) GetAncestorId() string {
-	if m != nil {
-		return m.AncestorId
-	}
-	return ""
+type FindAllBranchNamesResponse struct {
+	Names [][]byte `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
 }
 
-func (m *CommitIsAncestorRequest) GetChildId() string {
+func (m *FindAllBranchNamesResponse) Reset()                    { *m = FindAllBranchNamesResponse{} }
+func (m *FindAllBranchNamesResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindAllBranchNamesResponse) ProtoMessage()               {}
+func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
+
+func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
 	if m != nil {
-		return m.ChildId
+		return m.Names
 	}
-	return ""
+	return nil
 }
 
-type FindDefaultBranchNameRequest struct {
+type FindAllTagNamesRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 }
 
-func (m *FindDefaultBranchNameRequest) Reset()                    { *m = FindDefaultBranchNameRequest{} }
-func (m *FindDefaultBranchNameRequest) String() string            { return proto.CompactTextString(m) }
-func (*FindDefaultBranchNameRequest) ProtoMessage()               {}
-func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+func (m *FindAllTagNamesRequest) Reset()                    { *m = FindAllTagNamesRequest{} }
+func (m *FindAllTagNamesRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindAllTagNamesRequest) ProtoMessage()               {}
+func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{4} }
 
-func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
+func (m *FindAllTagNamesRequest) GetRepository() *Repository {
 	if m != nil {
 		return m.Repository
 	}
 	return nil
 }
 
-type FindAllBranchNamesRequest struct {
-	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+type FindAllTagNamesResponse struct {
+	Names [][]byte `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
 }
 
-func (m *FindAllBranchNamesRequest) Reset()                    { *m = FindAllBranchNamesRequest{} }
-func (m *FindAllBranchNamesRequest) String() string            { return proto.CompactTextString(m) }
-func (*FindAllBranchNamesRequest) ProtoMessage()               {}
-func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+func (m *FindAllTagNamesResponse) Reset()                    { *m = FindAllTagNamesResponse{} }
+func (m *FindAllTagNamesResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindAllTagNamesResponse) ProtoMessage()               {}
+func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{5} }
 
-func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
+func (m *FindAllTagNamesResponse) GetNames() [][]byte {
 	if m != nil {
-		return m.Repository
+		return m.Names
 	}
 	return nil
 }
 
-type FindAllTagNamesRequest struct {
+type FindRefNameRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Require that the resulting ref contains this commit as an ancestor
+	CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
+	// Example prefix: "refs/heads/". Type bytes because that is the type of ref names.
+	Prefix []byte `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
 }
 
-func (m *FindAllTagNamesRequest) Reset()                    { *m = FindAllTagNamesRequest{} }
-func (m *FindAllTagNamesRequest) String() string            { return proto.CompactTextString(m) }
-func (*FindAllTagNamesRequest) ProtoMessage()               {}
-func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+func (m *FindRefNameRequest) Reset()                    { *m = FindRefNameRequest{} }
+func (m *FindRefNameRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindRefNameRequest) ProtoMessage()               {}
+func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{6} }
 
-func (m *FindAllTagNamesRequest) GetRepository() *Repository {
+func (m *FindRefNameRequest) GetRepository() *Repository {
 	if m != nil {
 		return m.Repository
 	}
 	return nil
 }
 
-type FindDefaultBranchNameResponse struct {
-	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-}
-
-func (m *FindDefaultBranchNameResponse) Reset()                    { *m = FindDefaultBranchNameResponse{} }
-func (m *FindDefaultBranchNameResponse) String() string            { return proto.CompactTextString(m) }
-func (*FindDefaultBranchNameResponse) ProtoMessage()               {}
-func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
-
-func (m *FindDefaultBranchNameResponse) GetName() []byte {
+func (m *FindRefNameRequest) GetCommitId() string {
 	if m != nil {
-		return m.Name
+		return m.CommitId
 	}
-	return nil
-}
-
-type FindAllBranchNamesResponse struct {
-	Names [][]byte `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
+	return ""
 }
 
-func (m *FindAllBranchNamesResponse) Reset()                    { *m = FindAllBranchNamesResponse{} }
-func (m *FindAllBranchNamesResponse) String() string            { return proto.CompactTextString(m) }
-func (*FindAllBranchNamesResponse) ProtoMessage()               {}
-func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
-
-func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
+func (m *FindRefNameRequest) GetPrefix() []byte {
 	if m != nil {
-		return m.Names
+		return m.Prefix
 	}
 	return nil
 }
 
-type FindAllTagNamesResponse struct {
-	Names [][]byte `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
+type FindRefNameResponse struct {
+	// Example name: "refs/heads/master". Cannot assume UTF8, so the type is bytes.
+	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 }
 
-func (m *FindAllTagNamesResponse) Reset()                    { *m = FindAllTagNamesResponse{} }
-func (m *FindAllTagNamesResponse) String() string            { return proto.CompactTextString(m) }
-func (*FindAllTagNamesResponse) ProtoMessage()               {}
-func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+func (m *FindRefNameResponse) Reset()                    { *m = FindRefNameResponse{} }
+func (m *FindRefNameResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindRefNameResponse) ProtoMessage()               {}
+func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{7} }
 
-func (m *FindAllTagNamesResponse) GetNames() [][]byte {
+func (m *FindRefNameResponse) GetName() []byte {
 	if m != nil {
-		return m.Names
+		return m.Name
 	}
 	return nil
 }
 
-type CommitDiffRequest struct {
-	Repository    *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-	LeftCommitId  string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId" json:"left_commit_id,omitempty"`
-	RightCommitId string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId" json:"right_commit_id,omitempty"`
+type FindLocalBranchesRequest struct {
+	Repository *Repository                     `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	SortBy     FindLocalBranchesRequest_SortBy `protobuf:"varint,2,opt,name=sort_by,json=sortBy,enum=gitaly.FindLocalBranchesRequest_SortBy" json:"sort_by,omitempty"`
 }
 
-func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
-func (m *CommitDiffRequest) String() string            { return proto.CompactTextString(m) }
-func (*CommitDiffRequest) ProtoMessage()               {}
-func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+func (m *FindLocalBranchesRequest) Reset()                    { *m = FindLocalBranchesRequest{} }
+func (m *FindLocalBranchesRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindLocalBranchesRequest) ProtoMessage()               {}
+func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{8} }
 
-func (m *CommitDiffRequest) GetRepository() *Repository {
+func (m *FindLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
 		return m.Repository
 	}
 	return nil
 }
 
-func (m *CommitDiffRequest) GetLeftCommitId() string {
+func (m *FindLocalBranchesRequest) GetSortBy() FindLocalBranchesRequest_SortBy {
 	if m != nil {
-		return m.LeftCommitId
+		return m.SortBy
 	}
-	return ""
+	return FindLocalBranchesRequest_NAME
+}
+
+type FindLocalBranchesResponse struct {
+	Branches []*FindLocalBranchResponse `protobuf:"bytes,1,rep,name=branches" json:"branches,omitempty"`
 }
 
-func (m *CommitDiffRequest) GetRightCommitId() string {
+func (m *FindLocalBranchesResponse) Reset()                    { *m = FindLocalBranchesResponse{} }
+func (m *FindLocalBranchesResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindLocalBranchesResponse) ProtoMessage()               {}
+func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{9} }
+
+func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse {
 	if m != nil {
-		return m.RightCommitId
+		return m.Branches
 	}
-	return ""
+	return nil
 }
 
-// A CommitDiffResponse corresponds to a single changed file in a commit.
-type CommitDiffResponse struct {
-	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
-	ToPath   []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
-	// Blob ID as returned via `git diff --full-index`
-	FromId    string   `protobuf:"bytes,3,opt,name=from_id,json=fromId" json:"from_id,omitempty"`
-	ToId      string   `protobuf:"bytes,4,opt,name=to_id,json=toId" json:"to_id,omitempty"`
-	OldMode   int32    `protobuf:"varint,5,opt,name=old_mode,json=oldMode" json:"old_mode,omitempty"`
-	NewMode   int32    `protobuf:"varint,6,opt,name=new_mode,json=newMode" json:"new_mode,omitempty"`
-	Binary    bool     `protobuf:"varint,7,opt,name=binary" json:"binary,omitempty"`
-	RawChunks [][]byte `protobuf:"bytes,8,rep,name=raw_chunks,json=rawChunks,proto3" json:"raw_chunks,omitempty"`
+type FindLocalBranchResponse struct {
+	Name            []byte                       `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	CommitId        string                       `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
+	CommitSubject   []byte                       `protobuf:"bytes,3,opt,name=commit_subject,json=commitSubject,proto3" json:"commit_subject,omitempty"`
+	CommitAuthor    *FindLocalBranchCommitAuthor `protobuf:"bytes,4,opt,name=commit_author,json=commitAuthor" json:"commit_author,omitempty"`
+	CommitCommitter *FindLocalBranchCommitAuthor `protobuf:"bytes,5,opt,name=commit_committer,json=commitCommitter" json:"commit_committer,omitempty"`
 }
 
-func (m *CommitDiffResponse) Reset()                    { *m = CommitDiffResponse{} }
-func (m *CommitDiffResponse) String() string            { return proto.CompactTextString(m) }
-func (*CommitDiffResponse) ProtoMessage()               {}
-func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+func (m *FindLocalBranchResponse) Reset()                    { *m = FindLocalBranchResponse{} }
+func (m *FindLocalBranchResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindLocalBranchResponse) ProtoMessage()               {}
+func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{10} }
 
-func (m *CommitDiffResponse) GetFromPath() []byte {
+func (m *FindLocalBranchResponse) GetName() []byte {
 	if m != nil {
-		return m.FromPath
+		return m.Name
 	}
 	return nil
 }
 
-func (m *CommitDiffResponse) GetToPath() []byte {
+func (m *FindLocalBranchResponse) GetCommitId() string {
 	if m != nil {
-		return m.ToPath
+		return m.CommitId
 	}
-	return nil
+	return ""
 }
 
-func (m *CommitDiffResponse) GetFromId() string {
+func (m *FindLocalBranchResponse) GetCommitSubject() []byte {
 	if m != nil {
-		return m.FromId
+		return m.CommitSubject
 	}
-	return ""
+	return nil
 }
 
-func (m *CommitDiffResponse) GetToId() string {
+func (m *FindLocalBranchResponse) GetCommitAuthor() *FindLocalBranchCommitAuthor {
 	if m != nil {
-		return m.ToId
+		return m.CommitAuthor
 	}
-	return ""
+	return nil
 }
 
-func (m *CommitDiffResponse) GetOldMode() int32 {
+func (m *FindLocalBranchResponse) GetCommitCommitter() *FindLocalBranchCommitAuthor {
 	if m != nil {
-		return m.OldMode
+		return m.CommitCommitter
 	}
-	return 0
+	return nil
+}
+
+type FindLocalBranchCommitAuthor struct {
+	Name  []byte                     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Email []byte                     `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
+	Date  *google_protobuf.Timestamp `protobuf:"bytes,3,opt,name=date" json:"date,omitempty"`
 }
 
-func (m *CommitDiffResponse) GetNewMode() int32 {
+func (m *FindLocalBranchCommitAuthor) Reset()                    { *m = FindLocalBranchCommitAuthor{} }
+func (m *FindLocalBranchCommitAuthor) String() string            { return proto.CompactTextString(m) }
+func (*FindLocalBranchCommitAuthor) ProtoMessage()               {}
+func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{11} }
+
+func (m *FindLocalBranchCommitAuthor) GetName() []byte {
 	if m != nil {
-		return m.NewMode
+		return m.Name
 	}
-	return 0
+	return nil
 }
 
-func (m *CommitDiffResponse) GetBinary() bool {
+func (m *FindLocalBranchCommitAuthor) GetEmail() []byte {
 	if m != nil {
-		return m.Binary
+		return m.Email
 	}
-	return false
+	return nil
 }
 
-func (m *CommitDiffResponse) GetRawChunks() [][]byte {
+func (m *FindLocalBranchCommitAuthor) GetDate() *google_protobuf.Timestamp {
 	if m != nil {
-		return m.RawChunks
+		return m.Date
 	}
 	return nil
 }
 
 func init() {
-	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
-	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
-	proto.RegisterType((*PostReceiveResponse)(nil), "gitaly.PostReceiveResponse")
-	proto.RegisterType((*FindRefNameRequest)(nil), "gitaly.FindRefNameRequest")
-	proto.RegisterType((*FindRefNameResponse)(nil), "gitaly.FindRefNameResponse")
-	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
 	proto.RegisterType((*FindDefaultBranchNameRequest)(nil), "gitaly.FindDefaultBranchNameRequest")
-	proto.RegisterType((*FindAllBranchNamesRequest)(nil), "gitaly.FindAllBranchNamesRequest")
-	proto.RegisterType((*FindAllTagNamesRequest)(nil), "gitaly.FindAllTagNamesRequest")
 	proto.RegisterType((*FindDefaultBranchNameResponse)(nil), "gitaly.FindDefaultBranchNameResponse")
+	proto.RegisterType((*FindAllBranchNamesRequest)(nil), "gitaly.FindAllBranchNamesRequest")
 	proto.RegisterType((*FindAllBranchNamesResponse)(nil), "gitaly.FindAllBranchNamesResponse")
+	proto.RegisterType((*FindAllTagNamesRequest)(nil), "gitaly.FindAllTagNamesRequest")
 	proto.RegisterType((*FindAllTagNamesResponse)(nil), "gitaly.FindAllTagNamesResponse")
-	proto.RegisterType((*CommitDiffRequest)(nil), "gitaly.CommitDiffRequest")
-	proto.RegisterType((*CommitDiffResponse)(nil), "gitaly.CommitDiffResponse")
+	proto.RegisterType((*FindRefNameRequest)(nil), "gitaly.FindRefNameRequest")
+	proto.RegisterType((*FindRefNameResponse)(nil), "gitaly.FindRefNameResponse")
+	proto.RegisterType((*FindLocalBranchesRequest)(nil), "gitaly.FindLocalBranchesRequest")
+	proto.RegisterType((*FindLocalBranchesResponse)(nil), "gitaly.FindLocalBranchesResponse")
+	proto.RegisterType((*FindLocalBranchResponse)(nil), "gitaly.FindLocalBranchResponse")
+	proto.RegisterType((*FindLocalBranchCommitAuthor)(nil), "gitaly.FindLocalBranchCommitAuthor")
+	proto.RegisterEnum("gitaly.FindLocalBranchesRequest_SortBy", FindLocalBranchesRequest_SortBy_name, FindLocalBranchesRequest_SortBy_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -407,70 +336,6 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Notifications service
-
-type NotificationsClient interface {
-	PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error)
-}
-
-type notificationsClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient {
-	return &notificationsClient{cc}
-}
-
-func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
-	out := new(PostReceiveResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// Server API for Notifications service
-
-type NotificationsServer interface {
-	PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error)
-}
-
-func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) {
-	s.RegisterService(&_Notifications_serviceDesc, srv)
-}
-
-func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(PostReceiveRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NotificationsServer).PostReceive(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.Notifications/PostReceive",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Notifications_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Notifications",
-	HandlerType: (*NotificationsServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "PostReceive",
-			Handler:    _Notifications_PostReceive_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "gitaly.proto",
-}
-
 // Client API for Ref service
 
 type RefClient interface {
@@ -479,6 +344,8 @@ type RefClient interface {
 	FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error)
 	// Find a Ref matching the given constraints. Response may be empty.
 	FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error)
+	// Return a stream so we can divide the response in chunks of branches
+	FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error)
 }
 
 type refClient struct {
@@ -571,6 +438,38 @@ func (c *refClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opt
 	return out, nil
 }
 
+func (c *refClient) FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[2], c.cc, "/gitaly.Ref/FindLocalBranches", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &refFindLocalBranchesClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Ref_FindLocalBranchesClient interface {
+	Recv() (*FindLocalBranchesResponse, error)
+	grpc.ClientStream
+}
+
+type refFindLocalBranchesClient struct {
+	grpc.ClientStream
+}
+
+func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) {
+	m := new(FindLocalBranchesResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for Ref service
 
 type RefServer interface {
@@ -579,6 +478,8 @@ type RefServer interface {
 	FindAllTagNames(*FindAllTagNamesRequest, Ref_FindAllTagNamesServer) error
 	// Find a Ref matching the given constraints. Response may be empty.
 	FindRefName(context.Context, *FindRefNameRequest) (*FindRefNameResponse, error)
+	// Return a stream so we can divide the response in chunks of branches
+	FindLocalBranches(*FindLocalBranchesRequest, Ref_FindLocalBranchesServer) error
 }
 
 func RegisterRefServer(s *grpc.Server, srv RefServer) {
@@ -663,6 +564,27 @@ func _Ref_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(int
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Ref_FindLocalBranches_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(FindLocalBranchesRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(RefServer).FindLocalBranches(m, &refFindLocalBranchesServer{stream})
+}
+
+type Ref_FindLocalBranchesServer interface {
+	Send(*FindLocalBranchesResponse) error
+	grpc.ServerStream
+}
+
+type refFindLocalBranchesServer struct {
+	grpc.ServerStream
+}
+
+func (x *refFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _Ref_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.Ref",
 	HandlerType: (*RefServer)(nil),
@@ -687,212 +609,56 @@ var _Ref_serviceDesc = grpc.ServiceDesc{
 			Handler:       _Ref_FindAllTagNames_Handler,
 			ServerStreams: true,
 		},
-	},
-	Metadata: "gitaly.proto",
-}
-
-// Client API for Diff service
-
-type DiffClient interface {
-	// Returns stream of CommitDiffResponse: 1 per changed file
-	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
-}
-
-type diffClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewDiffClient(cc *grpc.ClientConn) DiffClient {
-	return &diffClient{cc}
-}
-
-func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[0], c.cc, "/gitaly.Diff/CommitDiff", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &diffCommitDiffClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type Diff_CommitDiffClient interface {
-	Recv() (*CommitDiffResponse, error)
-	grpc.ClientStream
-}
-
-type diffCommitDiffClient struct {
-	grpc.ClientStream
-}
-
-func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) {
-	m := new(CommitDiffResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Server API for Diff service
-
-type DiffServer interface {
-	// Returns stream of CommitDiffResponse: 1 per changed file
-	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
-}
-
-func RegisterDiffServer(s *grpc.Server, srv DiffServer) {
-	s.RegisterService(&_Diff_serviceDesc, srv)
-}
-
-func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(CommitDiffRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(DiffServer).CommitDiff(m, &diffCommitDiffServer{stream})
-}
-
-type Diff_CommitDiffServer interface {
-	Send(*CommitDiffResponse) error
-	grpc.ServerStream
-}
-
-type diffCommitDiffServer struct {
-	grpc.ServerStream
-}
-
-func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-var _Diff_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Diff",
-	HandlerType: (*DiffServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
 		{
-			StreamName:    "CommitDiff",
-			Handler:       _Diff_CommitDiff_Handler,
+			StreamName:    "FindLocalBranches",
+			Handler:       _Ref_FindLocalBranches_Handler,
 			ServerStreams: true,
 		},
 	},
-	Metadata: "gitaly.proto",
-}
-
-// Client API for Commit service
-
-type CommitClient interface {
-	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
-}
-
-type commitClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewCommitClient(cc *grpc.ClientConn) CommitClient {
-	return &commitClient{cc}
-}
-
-func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
-	out := new(CommitIsAncestorResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Commit/CommitIsAncestor", in, out, c.cc, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// Server API for Commit service
-
-type CommitServer interface {
-	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
-}
-
-func RegisterCommitServer(s *grpc.Server, srv CommitServer) {
-	s.RegisterService(&_Commit_serviceDesc, srv)
-}
-
-func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CommitIsAncestorRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(CommitServer).CommitIsAncestor(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.Commit/CommitIsAncestor",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Commit_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Commit",
-	HandlerType: (*CommitServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "CommitIsAncestor",
-			Handler:    _Commit_CommitIsAncestor_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "gitaly.proto",
-}
-
-func init() { proto.RegisterFile("gitaly.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-	// 675 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x55, 0xdf, 0x52, 0xd3, 0x4e,
-	0x14, 0x26, 0xb4, 0x4d, 0xdb, 0xd3, 0xf2, 0xe3, 0xe7, 0x41, 0x20, 0x04, 0x91, 0x9a, 0x41, 0xa7,
-	0xde, 0x20, 0x13, 0x9e, 0x00, 0x61, 0x94, 0xce, 0x28, 0x30, 0x3b, 0x8e, 0x8e, 0x57, 0x9d, 0x25,
-	0xd9, 0x90, 0x1d, 0xd3, 0x6c, 0x4d, 0xb6, 0x54, 0x2e, 0x7c, 0x00, 0x1f, 0xc0, 0x47, 0xf4, 0xde,
-	0x47, 0x70, 0x92, 0x4d, 0x48, 0xfa, 0x87, 0x3a, 0x63, 0xef, 0x7a, 0xce, 0x77, 0xfe, 0xed, 0xe9,
-	0x77, 0xbe, 0x40, 0xfb, 0x86, 0x4b, 0x1a, 0xdc, 0x1d, 0x0e, 0x23, 0x21, 0x05, 0xea, 0xca, 0x32,
-	0xdb, 0xb1, 0x4f, 0x23, 0xe6, 0x2a, 0xaf, 0x75, 0x04, 0xc6, 0xa9, 0x18, 0x0c, 0xb8, 0xec, 0xc5,
-	0x27, 0xa1, 0xc3, 0x62, 0x29, 0x22, 0xc2, 0xe2, 0xa1, 0x08, 0x63, 0x86, 0x8f, 0xa1, 0x76, 0x4b,
-	0x83, 0x11, 0x33, 0xb4, 0x8e, 0xd6, 0x6d, 0x10, 0x65, 0x58, 0xe7, 0x80, 0x57, 0x22, 0x96, 0x84,
-	0x39, 0x8c, 0xdf, 0x32, 0xc2, 0xbe, 0x8e, 0x58, 0x2c, 0xd1, 0x06, 0x88, 0xd8, 0x50, 0xc4, 0x5c,
-	0x8a, 0xe8, 0x2e, 0x4d, 0x68, 0xd9, 0x78, 0x98, 0x0d, 0x40, 0xee, 0x11, 0x52, 0x8a, 0xb2, 0x36,
-	0x61, 0x63, 0xa2, 0x92, 0x6a, 0x6b, 0x7d, 0x07, 0x7c, 0xc3, 0x43, 0x97, 0x30, 0xef, 0x82, 0x0e,
-	0x96, 0x69, 0x80, 0xbb, 0xd0, 0x74, 0xd2, 0xc7, 0xf5, 0xb9, 0x6b, 0xac, 0x76, 0xb4, 0x6e, 0x93,
-	0x34, 0x94, 0xa3, 0xe7, 0xe2, 0x16, 0xe8, 0xc3, 0x88, 0x79, 0xfc, 0x9b, 0x51, 0xe9, 0x68, 0xdd,
-	0x36, 0xc9, 0x2c, 0xeb, 0x25, 0x6c, 0x4c, 0xb4, 0xcf, 0x96, 0x81, 0x50, 0x0d, 0xe9, 0x40, 0xed,
-	0xa2, 0x4d, 0xd2, 0xdf, 0xd6, 0x0f, 0x0d, 0xb6, 0x67, 0xb7, 0xf7, 0xef, 0xf3, 0xee, 0x43, 0x8b,
-	0x66, 0x65, 0x8a, 0x89, 0x21, 0x77, 0xf5, 0x5c, 0xdc, 0x81, 0x86, 0xe3, 0xf3, 0xc0, 0x4d, 0xd0,
-	0x4a, 0x8a, 0xd6, 0x53, 0xbb, 0xe7, 0x5a, 0x04, 0x9e, 0x24, 0x63, 0x9f, 0x31, 0x8f, 0x8e, 0x02,
-	0xf9, 0x3a, 0xa2, 0xa1, 0xe3, 0x2f, 0xb9, 0x3f, 0xeb, 0x12, 0x76, 0x92, 0x9a, 0x27, 0x41, 0x50,
-	0xd4, 0x8b, 0x97, 0x29, 0xf8, 0x0e, 0xb6, 0xb2, 0x82, 0x1f, 0xe8, 0xcd, 0xd2, 0xd5, 0x8e, 0x61,
-	0xef, 0x81, 0x27, 0x2f, 0xf8, 0xcf, 0x6c, 0x30, 0xe7, 0xbd, 0xa9, 0xa0, 0x7c, 0x12, 0x15, 0x1b,
-	0x5a, 0xa7, 0xd2, 0x6d, 0x13, 0x65, 0x58, 0xaf, 0x60, 0x7b, 0x66, 0xec, 0x85, 0x09, 0x3f, 0x35,
-	0x78, 0xa4, 0x88, 0x71, 0xc6, 0x3d, 0x6f, 0x19, 0x4a, 0x1c, 0xc0, 0x7f, 0x01, 0xf3, 0x64, 0x7f,
-	0x9a, 0xc7, 0xed, 0xc4, 0x7b, 0x9a, 0x73, 0xf9, 0x05, 0xac, 0x47, 0xfc, 0xc6, 0x2f, 0x87, 0x29,
-	0x7a, 0xac, 0xa5, 0xee, 0x3c, 0xce, 0xfa, 0xa5, 0x01, 0x96, 0xe7, 0xca, 0x1e, 0xb1, 0x0b, 0x4d,
-	0x2f, 0x12, 0x83, 0xfe, 0x90, 0x4a, 0x3f, 0x5b, 0x56, 0x23, 0x71, 0x5c, 0x51, 0xe9, 0xe3, 0x36,
-	0xd4, 0xa5, 0x50, 0xd0, 0xaa, 0x3a, 0x14, 0x29, 0x72, 0x20, 0xcd, 0xba, 0x6f, 0xa6, 0x27, 0x66,
-	0xcf, 0xc5, 0x0d, 0xa8, 0x49, 0x91, 0xb8, 0xab, 0xa9, 0xbb, 0x2a, 0x85, 0xa2, 0xae, 0x08, 0xdc,
-	0xfe, 0x40, 0xb8, 0xcc, 0xa8, 0x75, 0xb4, 0x6e, 0x8d, 0xd4, 0x45, 0xe0, 0xbe, 0x17, 0x2e, 0x4b,
-	0xa0, 0x90, 0x8d, 0x15, 0xa4, 0x2b, 0x28, 0x64, 0xe3, 0x14, 0xda, 0x02, 0xfd, 0x9a, 0x87, 0x34,
-	0xba, 0x33, 0xea, 0xa9, 0x06, 0x65, 0x16, 0xee, 0x01, 0x44, 0x74, 0xdc, 0x77, 0xfc, 0x51, 0xf8,
-	0x25, 0x36, 0x1a, 0xe9, 0xee, 0x9b, 0x11, 0x1d, 0x9f, 0xa6, 0x0e, 0xfb, 0x33, 0xac, 0x5d, 0x08,
-	0xc9, 0x3d, 0xee, 0x50, 0xc9, 0x45, 0x18, 0xe3, 0x39, 0xb4, 0x4a, 0x52, 0x83, 0x66, 0xbe, 0xf5,
-	0x59, 0x25, 0x33, 0x77, 0xe7, 0x62, 0x99, 0x36, 0xad, 0xd8, 0xbf, 0x57, 0xa1, 0x42, 0x98, 0x87,
-	0x1e, 0x6c, 0xce, 0x25, 0x1f, 0x1e, 0xe4, 0xf9, 0x8b, 0xce, 0xd1, 0x7c, 0xfe, 0x97, 0xa8, 0xbc,
-	0x1f, 0xf6, 0x95, 0x1a, 0x4e, 0xf2, 0x15, 0x9f, 0x95, 0xd3, 0xe7, 0xde, 0xa7, 0x69, 0x2d, 0x0a,
-	0xc9, 0xcb, 0x1f, 0x69, 0xf8, 0x11, 0xd6, 0xa7, 0xc8, 0x8d, 0x4f, 0xa7, 0x52, 0xa7, 0x8e, 0xd5,
-	0xdc, 0x7f, 0x10, 0x2f, 0xd5, 0x3d, 0x87, 0x56, 0x49, 0x47, 0x8b, 0x95, 0xcf, 0x6a, 0x7b, 0xb1,
-	0xf2, 0x39, 0xc2, 0x6b, 0xad, 0xd8, 0x97, 0x50, 0x4d, 0xe8, 0x8a, 0x6f, 0x01, 0x0a, 0xf2, 0xe2,
-	0x4e, 0x9e, 0x34, 0x73, 0x68, 0xa6, 0x39, 0x0f, 0x2a, 0x46, 0xb3, 0x29, 0xe8, 0x0a, 0xc1, 0x4f,
-	0xf0, 0xff, 0xb4, 0x80, 0xe3, 0xfe, 0x64, 0xf6, 0x8c, 0xb4, 0x9b, 0x9d, 0x87, 0x03, 0xf2, 0x26,
-	0xd7, 0x7a, 0xfa, 0x79, 0x3d, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x56, 0xf0, 0xf5, 0xb9, 0x84,
-	0x07, 0x00, 0x00,
+	Metadata: "ref.proto",
+}
+
+func init() { proto.RegisterFile("ref.proto", fileDescriptor3) }
+
+var fileDescriptor3 = []byte{
+	// 615 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x51, 0x73, 0xd2, 0x4c,
+	0x14, 0x6d, 0x0a, 0xe5, 0x6b, 0x2f, 0xf9, 0x5a, 0x5c, 0x6b, 0x8d, 0x41, 0x85, 0x46, 0x3b, 0xe2,
+	0x4b, 0x70, 0xd2, 0xf1, 0xc9, 0x17, 0x29, 0xe0, 0xd4, 0x99, 0x8a, 0xce, 0x82, 0x8e, 0x0f, 0xce,
+	0x30, 0x0b, 0x6c, 0x20, 0x4e, 0xc2, 0x62, 0xb2, 0x8c, 0xf2, 0xe0, 0x2f, 0xf0, 0x87, 0xf9, 0xe6,
+	0x6f, 0x72, 0xd8, 0x4d, 0x68, 0xa0, 0x49, 0xea, 0x0c, 0x4f, 0xe1, 0xde, 0x3d, 0xe7, 0xde, 0xbb,
+	0xf7, 0xb0, 0x07, 0x0e, 0x7c, 0x6a, 0x9b, 0x33, 0x9f, 0x71, 0x86, 0x0a, 0x63, 0x87, 0x13, 0x77,
+	0xa1, 0xab, 0xc1, 0x84, 0xf8, 0x74, 0x24, 0xb3, 0x7a, 0x65, 0xcc, 0xd8, 0xd8, 0xa5, 0x75, 0x11,
+	0x0d, 0xe6, 0x76, 0x9d, 0x3b, 0x1e, 0x0d, 0x38, 0xf1, 0x66, 0x12, 0x60, 0x60, 0x78, 0xf8, 0xc6,
+	0x99, 0x8e, 0x5a, 0xd4, 0x26, 0x73, 0x97, 0x5f, 0xf8, 0x64, 0x3a, 0x9c, 0x74, 0x88, 0x47, 0x31,
+	0xfd, 0x36, 0xa7, 0x01, 0x47, 0x16, 0x80, 0x4f, 0x67, 0x2c, 0x70, 0x38, 0xf3, 0x17, 0x9a, 0x52,
+	0x55, 0x6a, 0x45, 0x0b, 0x99, 0xb2, 0x97, 0x89, 0x57, 0x27, 0x38, 0x86, 0x32, 0xce, 0xe1, 0x51,
+	0x4a, 0xcd, 0x60, 0xc6, 0xa6, 0x01, 0x45, 0x08, 0xf2, 0x53, 0xe2, 0x51, 0x51, 0x4e, 0xc5, 0xe2,
+	0xb7, 0xf1, 0x1e, 0x1e, 0x2c, 0x49, 0x0d, 0xd7, 0xbd, 0x26, 0x04, 0xdb, 0x4c, 0x61, 0x81, 0x9e,
+	0x54, 0x30, 0x1c, 0xe1, 0x18, 0xf6, 0x96, 0x6d, 0x03, 0x4d, 0xa9, 0xe6, 0x6a, 0x2a, 0x96, 0x81,
+	0x71, 0x05, 0x27, 0x21, 0xa7, 0x47, 0xc6, 0x5b, 0x4f, 0x50, 0x87, 0xfb, 0x37, 0xaa, 0x65, 0xb6,
+	0xff, 0x09, 0x68, 0x49, 0xc0, 0xd4, 0xde, 0x52, 0x02, 0x54, 0x86, 0x83, 0x21, 0xf3, 0x3c, 0x87,
+	0xf7, 0x9d, 0x91, 0xb6, 0x5b, 0x55, 0x6a, 0x07, 0x78, 0x5f, 0x26, 0xde, 0x8e, 0xd0, 0x09, 0x14,
+	0x66, 0x3e, 0xb5, 0x9d, 0x1f, 0x5a, 0x4e, 0x08, 0x10, 0x46, 0xc6, 0x73, 0xb8, 0xbb, 0xd6, 0x3e,
+	0x43, 0xad, 0xdf, 0x0a, 0x68, 0x4b, 0xec, 0x15, 0x1b, 0x92, 0x70, 0xbf, 0x5b, 0xed, 0x0a, 0xbd,
+	0x86, 0xff, 0x02, 0xe6, 0xf3, 0xfe, 0x60, 0x21, 0xc6, 0x3d, 0xb4, 0x9e, 0x45, 0x84, 0xb4, 0x36,
+	0x66, 0x97, 0xf9, 0xfc, 0x62, 0x81, 0x0b, 0x81, 0xf8, 0x1a, 0x2f, 0xa1, 0x20, 0x33, 0x68, 0x1f,
+	0xf2, 0x9d, 0xc6, 0xbb, 0x76, 0x69, 0x07, 0x1d, 0x41, 0xf1, 0xe3, 0x87, 0x56, 0xa3, 0xd7, 0x6e,
+	0xf5, 0x1b, 0xdd, 0x66, 0x49, 0x41, 0x25, 0x50, 0xa3, 0x44, 0xab, 0xdd, 0x6d, 0x96, 0x76, 0x8d,
+	0xcf, 0xf2, 0x7f, 0xb7, 0xd1, 0x21, 0xbc, 0xfa, 0x2b, 0xd8, 0x1f, 0x84, 0x39, 0xa1, 0x54, 0xd1,
+	0xaa, 0xa4, 0x8c, 0x15, 0x51, 0xf0, 0x8a, 0x60, 0xfc, 0xda, 0x95, 0xfa, 0x27, 0xa0, 0x92, 0x76,
+	0x9a, 0xad, 0xd9, 0x19, 0x1c, 0x86, 0x87, 0xc1, 0x7c, 0xf0, 0x95, 0x0e, 0x79, 0xa8, 0xdd, 0xff,
+	0x32, 0xdb, 0x95, 0x49, 0x74, 0x09, 0x61, 0xa2, 0x4f, 0xe6, 0x7c, 0xc2, 0x7c, 0x2d, 0x2f, 0xb6,
+	0xff, 0x24, 0x65, 0xea, 0xa6, 0xc0, 0x36, 0x04, 0x14, 0xab, 0xc3, 0x58, 0x84, 0x3a, 0x50, 0x0a,
+	0x2b, 0xc9, 0x0f, 0xa7, 0xbe, 0xb6, 0xf7, 0xef, 0xc5, 0x8e, 0x24, 0xab, 0x19, 0x71, 0x8d, 0xef,
+	0x50, 0xce, 0xc0, 0x27, 0x2e, 0xe4, 0x18, 0xf6, 0xa8, 0x47, 0x1c, 0x57, 0x2c, 0x43, 0xc5, 0x32,
+	0x40, 0x26, 0xe4, 0x47, 0x84, 0x53, 0x71, 0xff, 0xa2, 0xa5, 0x9b, 0xd2, 0xe1, 0xcc, 0xc8, 0xe1,
+	0xcc, 0x5e, 0xe4, 0x70, 0x58, 0xe0, 0xac, 0x3f, 0x39, 0xc8, 0x61, 0x6a, 0x23, 0x1b, 0xee, 0x25,
+	0xba, 0x12, 0x7a, 0x1a, 0xbf, 0x4f, 0x9a, 0x11, 0xea, 0x67, 0xb7, 0xa0, 0xa4, 0xb0, 0xc6, 0x0e,
+	0xea, 0xcb, 0x47, 0xbc, 0xee, 0x3b, 0xe8, 0x34, 0x4e, 0x4f, 0x34, 0x39, 0xdd, 0xc8, 0x82, 0x44,
+	0xe5, 0x5f, 0x28, 0xe8, 0x13, 0x1c, 0x6d, 0xd8, 0x0a, 0x7a, 0xbc, 0x41, 0xdd, 0x70, 0x2f, 0xbd,
+	0x92, 0x7a, 0x1e, 0xab, 0x7b, 0x09, 0xc5, 0xd8, 0xf3, 0x47, 0x7a, 0x9c, 0xb3, 0x6e, 0x49, 0x7a,
+	0x39, 0xf1, 0x6c, 0xb5, 0x82, 0x2f, 0x70, 0xe7, 0xc6, 0x9b, 0x42, 0xd5, 0xdb, 0x1e, 0xb4, 0x7e,
+	0x9a, 0x81, 0xb8, 0x9e, 0x73, 0x50, 0x10, 0x52, 0x9f, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x2c,
+	0xc7, 0x33, 0x9b, 0xfd, 0x06, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go

@@ -14,13 +14,15 @@ var _ = fmt.Errorf
 var _ = math.Inf
 
 type Repository struct {
-	Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
+	Path         string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
+	StorageName  string `protobuf:"bytes,2,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	RelativePath string `protobuf:"bytes,3,opt,name=relative_path,json=relativePath" json:"relative_path,omitempty"`
 }
 
 func (m *Repository) Reset()                    { *m = Repository{} }
 func (m *Repository) String() string            { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()               {}
-func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
 
 func (m *Repository) GetPath() string {
 	if m != nil {
@@ -29,6 +31,20 @@ func (m *Repository) GetPath() string {
 	return ""
 }
 
+func (m *Repository) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *Repository) GetRelativePath() string {
+	if m != nil {
+		return m.RelativePath
+	}
+	return ""
+}
+
 type ExitStatus struct {
 	Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 }
@@ -36,7 +52,7 @@ type ExitStatus struct {
 func (m *ExitStatus) Reset()                    { *m = ExitStatus{} }
 func (m *ExitStatus) String() string            { return proto.CompactTextString(m) }
 func (*ExitStatus) ProtoMessage()               {}
-func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -50,15 +66,19 @@ func init() {
 	proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor1) }
+func init() { proto.RegisterFile("shared.proto", fileDescriptor4) }
 
-var fileDescriptor1 = []byte{
-	// 111 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0xce, 0x48, 0x2c,
-	0x4a, 0x4d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9,
-	0x54, 0x52, 0xe0, 0xe2, 0x0a, 0x4a, 0x2d, 0xc8, 0x2f, 0xce, 0x2c, 0xc9, 0x2f, 0xaa, 0x14, 0x12,
-	0xe2, 0x62, 0x29, 0x48, 0x2c, 0xc9, 0x90, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xb3, 0x95,
-	0x94, 0xb8, 0xb8, 0x5c, 0x2b, 0x32, 0x4b, 0x82, 0x4b, 0x12, 0x4b, 0x4a, 0x8b, 0x85, 0x44, 0xb8,
-	0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0xc1, 0x4a, 0x58, 0x83, 0x20, 0x9c, 0x24, 0x36, 0xb0, 0xa1,
-	0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x48, 0xc1, 0x82, 0x64, 0x00, 0x00, 0x00,
+var fileDescriptor4 = []byte{
+	// 161 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0x8e, 0xb1, 0xca, 0xc2, 0x40,
+	0x10, 0x84, 0xc9, 0xff, 0x9b, 0x80, 0x6b, 0x6c, 0x16, 0x8b, 0x94, 0x1a, 0x1b, 0x2b, 0x1b, 0x9f,
+	0xc1, 0x56, 0xe4, 0x7c, 0x80, 0xb0, 0xe2, 0x92, 0x3b, 0xb8, 0x78, 0xc7, 0xdd, 0x26, 0x98, 0xb7,
+	0x17, 0x56, 0xed, 0x76, 0xbf, 0x99, 0x61, 0x06, 0xea, 0x6c, 0x29, 0xf1, 0xe3, 0x18, 0x53, 0x90,
+	0x80, 0x55, 0xef, 0x84, 0xfc, 0xdc, 0x5a, 0x00, 0xc3, 0x31, 0x64, 0x27, 0x21, 0xcd, 0x88, 0xb0,
+	0x88, 0x24, 0xb6, 0x29, 0xb6, 0xc5, 0x61, 0x69, 0xf4, 0xc6, 0x1d, 0xd4, 0x59, 0x42, 0xa2, 0x9e,
+	0xbb, 0x27, 0x0d, 0xdc, 0xfc, 0xa9, 0xb6, 0xfa, 0xb2, 0x0b, 0x0d, 0x8c, 0x7b, 0x58, 0x27, 0xf6,
+	0x24, 0x6e, 0xe2, 0x4e, 0xf3, 0xff, 0xea, 0xa9, 0x7f, 0xf0, 0x4a, 0x62, 0xdb, 0x16, 0xe0, 0xfc,
+	0x72, 0x72, 0x13, 0x92, 0x31, 0xe3, 0x06, 0xca, 0x89, 0xfc, 0xc8, 0x5a, 0x55, 0x9a, 0xcf, 0x73,
+	0xaf, 0x74, 0xdc, 0xe9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xf7, 0x56, 0x73, 0xac, 0x00, 0x00,
+	0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go

@@ -25,7 +25,7 @@ type InfoRefsRequest struct {
 func (m *InfoRefsRequest) Reset()                    { *m = InfoRefsRequest{} }
 func (m *InfoRefsRequest) String() string            { return proto.CompactTextString(m) }
 func (*InfoRefsRequest) ProtoMessage()               {}
-func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
 
 func (m *InfoRefsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -41,7 +41,7 @@ type InfoRefsResponse struct {
 func (m *InfoRefsResponse) Reset()                    { *m = InfoRefsResponse{} }
 func (m *InfoRefsResponse) String() string            { return proto.CompactTextString(m) }
 func (*InfoRefsResponse) ProtoMessage()               {}
-func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
 
 func (m *InfoRefsResponse) GetData() []byte {
 	if m != nil {
@@ -50,9 +50,109 @@ func (m *InfoRefsResponse) GetData() []byte {
 	return nil
 }
 
+type PostUploadPackRequest struct {
+	// repository should only be present in the first message of the stream
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Raw data to be copied to stdin of 'git upload-pack'
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *PostUploadPackRequest) Reset()                    { *m = PostUploadPackRequest{} }
+func (m *PostUploadPackRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostUploadPackRequest) ProtoMessage()               {}
+func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
+
+func (m *PostUploadPackRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *PostUploadPackRequest) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type PostUploadPackResponse struct {
+	// Raw data from stdout of 'git upload-pack'
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *PostUploadPackResponse) Reset()                    { *m = PostUploadPackResponse{} }
+func (m *PostUploadPackResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostUploadPackResponse) ProtoMessage()               {}
+func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
+
+func (m *PostUploadPackResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type PostReceivePackRequest struct {
+	// repository should only be present in the first message of the stream
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Raw data to be copied to stdin of 'git receive-pack'
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+	// gl_id becomes env variable GL_ID, used by the Git {pre,post}-receive
+	// hooks. Should only be present in the first message of the stream.
+	GlId string `protobuf:"bytes,3,opt,name=gl_id,json=glId" json:"gl_id,omitempty"`
+}
+
+func (m *PostReceivePackRequest) Reset()                    { *m = PostReceivePackRequest{} }
+func (m *PostReceivePackRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostReceivePackRequest) ProtoMessage()               {}
+func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
+
+func (m *PostReceivePackRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *PostReceivePackRequest) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *PostReceivePackRequest) GetGlId() string {
+	if m != nil {
+		return m.GlId
+	}
+	return ""
+}
+
+type PostReceivePackResponse struct {
+	// Raw data from stdout of 'git receive-pack'
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *PostReceivePackResponse) Reset()                    { *m = PostReceivePackResponse{} }
+func (m *PostReceivePackResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostReceivePackResponse) ProtoMessage()               {}
+func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
+
+func (m *PostReceivePackResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*InfoRefsRequest)(nil), "gitaly.InfoRefsRequest")
 	proto.RegisterType((*InfoRefsResponse)(nil), "gitaly.InfoRefsResponse")
+	proto.RegisterType((*PostUploadPackRequest)(nil), "gitaly.PostUploadPackRequest")
+	proto.RegisterType((*PostUploadPackResponse)(nil), "gitaly.PostUploadPackResponse")
+	proto.RegisterType((*PostReceivePackRequest)(nil), "gitaly.PostReceivePackRequest")
+	proto.RegisterType((*PostReceivePackResponse)(nil), "gitaly.PostReceivePackResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -70,6 +170,10 @@ type SmartHTTPClient interface {
 	InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error)
 	// The response body for GET /info/refs?service=git-receive-pack
 	InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error)
+	// Request and response body for POST /upload-pack
+	PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error)
+	// Request and response body for POST /receive-pack
+	PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error)
 }
 
 type smartHTTPClient struct {
@@ -144,6 +248,68 @@ func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) {
 	return m, nil
 }
 
+func (c *smartHTTPClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTP/PostUploadPack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPPostUploadPackClient{stream}
+	return x, nil
+}
+
+type SmartHTTP_PostUploadPackClient interface {
+	Send(*PostUploadPackRequest) error
+	Recv() (*PostUploadPackResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPPostUploadPackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPPostUploadPackClient) Send(m *PostUploadPackRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) {
+	m := new(PostUploadPackResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *smartHTTPClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTP/PostReceivePack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPPostReceivePackClient{stream}
+	return x, nil
+}
+
+type SmartHTTP_PostReceivePackClient interface {
+	Send(*PostReceivePackRequest) error
+	Recv() (*PostReceivePackResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPPostReceivePackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPPostReceivePackClient) Send(m *PostReceivePackRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error) {
+	m := new(PostReceivePackResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for SmartHTTP service
 
 type SmartHTTPServer interface {
@@ -151,6 +317,10 @@ type SmartHTTPServer interface {
 	InfoRefsUploadPack(*InfoRefsRequest, SmartHTTP_InfoRefsUploadPackServer) error
 	// The response body for GET /info/refs?service=git-receive-pack
 	InfoRefsReceivePack(*InfoRefsRequest, SmartHTTP_InfoRefsReceivePackServer) error
+	// Request and response body for POST /upload-pack
+	PostUploadPack(SmartHTTP_PostUploadPackServer) error
+	// Request and response body for POST /receive-pack
+	PostReceivePack(SmartHTTP_PostReceivePackServer) error
 }
 
 func RegisterSmartHTTPServer(s *grpc.Server, srv SmartHTTPServer) {
@@ -199,6 +369,58 @@ func (x *smartHTTPInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
+func _SmartHTTP_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SmartHTTPServer).PostUploadPack(&smartHTTPPostUploadPackServer{stream})
+}
+
+type SmartHTTP_PostUploadPackServer interface {
+	Send(*PostUploadPackResponse) error
+	Recv() (*PostUploadPackRequest, error)
+	grpc.ServerStream
+}
+
+type smartHTTPPostUploadPackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPPostUploadPackServer) Send(m *PostUploadPackResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) {
+	m := new(PostUploadPackRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _SmartHTTP_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SmartHTTPServer).PostReceivePack(&smartHTTPPostReceivePackServer{stream})
+}
+
+type SmartHTTP_PostReceivePackServer interface {
+	Send(*PostReceivePackResponse) error
+	Recv() (*PostReceivePackRequest, error)
+	grpc.ServerStream
+}
+
+type smartHTTPPostReceivePackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPPostReceivePackServer) Send(m *PostReceivePackResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) {
+	m := new(PostReceivePackRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 var _SmartHTTP_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.SmartHTTP",
 	HandlerType: (*SmartHTTPServer)(nil),
@@ -214,25 +436,43 @@ var _SmartHTTP_serviceDesc = grpc.ServiceDesc{
 			Handler:       _SmartHTTP_InfoRefsReceivePack_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "PostUploadPack",
+			Handler:       _SmartHTTP_PostUploadPack_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "PostReceivePack",
+			Handler:       _SmartHTTP_PostReceivePack_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
 	},
 	Metadata: "smarthttp.proto",
 }
 
-func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor2) }
-
-var fileDescriptor2 = []byte{
-	// 200 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2f, 0xce, 0x4d, 0x2c,
-	0x2a, 0xc9, 0x28, 0x29, 0x29, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c,
-	0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0xb9, 0x72,
-	0xf1, 0x7b, 0xe6, 0xa5, 0xe5, 0x07, 0xa5, 0xa6, 0x15, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97,
-	0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17, 0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30,
-	0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x74, 0xeb, 0x05, 0xc1, 0x65, 0x82, 0x90, 0x54,
-	0x29, 0xa9, 0x71, 0x09, 0x20, 0x8c, 0x29, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0x15, 0x12, 0xe2, 0x62,
-	0x49, 0x49, 0x2c, 0x49, 0x04, 0x9b, 0xc0, 0x13, 0x04, 0x66, 0x1b, 0x2d, 0x63, 0xe4, 0xe2, 0x0c,
-	0x06, 0x39, 0xcc, 0x23, 0x24, 0x24, 0x40, 0xc8, 0x9b, 0x4b, 0x08, 0xa6, 0x2b, 0xb4, 0x20, 0x27,
-	0x3f, 0x31, 0x25, 0x20, 0x31, 0x39, 0x5b, 0x48, 0x1c, 0x66, 0x17, 0x9a, 0xc3, 0xa4, 0x24, 0x30,
-	0x25, 0x20, 0x56, 0x29, 0x31, 0x18, 0x30, 0x0a, 0xf9, 0x70, 0x09, 0x23, 0xc4, 0x93, 0x53, 0x33,
-	0xcb, 0x52, 0x29, 0x30, 0x2d, 0x89, 0x0d, 0x1c, 0x3c, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0xfd, 0x13, 0x70, 0x6d, 0x47, 0x01, 0x00, 0x00,
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor5) }
+
+var fileDescriptor5 = []byte{
+	// 304 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x4b, 0xc3, 0x40,
+	0x14, 0x74, 0x6b, 0x2d, 0xf4, 0x59, 0xac, 0xbc, 0xa2, 0x0d, 0x01, 0xb5, 0xe4, 0x20, 0x39, 0x68,
+	0x28, 0xf1, 0x37, 0x08, 0x16, 0x3d, 0x84, 0xb5, 0x05, 0x6f, 0x65, 0x6d, 0xb6, 0x69, 0x30, 0x76,
+	0xe3, 0xee, 0x56, 0xe8, 0x2f, 0xf5, 0xef, 0x88, 0x09, 0xf9, 0x68, 0x62, 0x3c, 0x28, 0xde, 0xc2,
+	0x9b, 0xf7, 0x66, 0x26, 0x33, 0x2c, 0xf4, 0xd5, 0x2b, 0x93, 0x7a, 0xa5, 0x75, 0xec, 0xc4, 0x52,
+	0x68, 0x81, 0x9d, 0x20, 0xd4, 0x2c, 0xda, 0x9a, 0x3d, 0xb5, 0x62, 0x92, 0xfb, 0xe9, 0xd4, 0xba,
+	0x85, 0xfe, 0x64, 0xbd, 0x14, 0x94, 0x2f, 0x15, 0xe5, 0x6f, 0x1b, 0xae, 0x34, 0xba, 0x00, 0x92,
+	0xc7, 0x42, 0x85, 0x5a, 0xc8, 0xad, 0x41, 0x46, 0xc4, 0x3e, 0x74, 0xd1, 0x49, 0xaf, 0x1d, 0x9a,
+	0x23, 0xb4, 0xb4, 0x65, 0x5d, 0xc2, 0x71, 0x41, 0xa3, 0x62, 0xb1, 0x56, 0x1c, 0x11, 0xda, 0x3e,
+	0xd3, 0x2c, 0x61, 0xe8, 0xd1, 0xe4, 0xdb, 0x9a, 0xc3, 0x89, 0x27, 0x94, 0x9e, 0xc5, 0x91, 0x60,
+	0xbe, 0xc7, 0x16, 0x2f, 0x7f, 0x10, 0xcd, 0x05, 0x5a, 0x25, 0x81, 0x2b, 0x38, 0xad, 0x0a, 0xfc,
+	0x60, 0x67, 0x93, 0x6e, 0x53, 0xbe, 0xe0, 0xe1, 0x3b, 0xff, 0x07, 0x3f, 0x38, 0x80, 0x83, 0x20,
+	0x9a, 0x87, 0xbe, 0xb1, 0x3f, 0x22, 0x76, 0x97, 0xb6, 0x83, 0x68, 0xe2, 0x5b, 0xd7, 0x30, 0xac,
+	0xc9, 0x36, 0xbb, 0x74, 0x3f, 0x5a, 0xd0, 0x7d, 0xfc, 0x6a, 0xf3, 0x6e, 0x3a, 0xf5, 0xf0, 0x1e,
+	0x30, 0x8b, 0xba, 0xf8, 0x4b, 0x1c, 0x66, 0xde, 0x2a, 0x6d, 0x9a, 0x46, 0x1d, 0x48, 0xa5, 0xac,
+	0xbd, 0x31, 0xc1, 0x07, 0x18, 0x14, 0xf3, 0xdc, 0xcd, 0x6f, 0xd9, 0x66, 0x70, 0xb4, 0x1b, 0x3e,
+	0x9e, 0x65, 0xfb, 0xdf, 0xb6, 0x6e, 0x9e, 0x37, 0xc1, 0x19, 0xa9, 0x4d, 0xc6, 0x04, 0x9f, 0xa0,
+	0x5f, 0x89, 0x0b, 0x77, 0x0e, 0xeb, 0xf5, 0x99, 0x17, 0x8d, 0x78, 0x99, 0xf9, 0xb9, 0x93, 0x3c,
+	0x82, 0x9b, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x16, 0x3e, 0x9b, 0xd1, 0x2d, 0x03, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go

@@ -28,7 +28,7 @@ type SSHUploadPackRequest struct {
 func (m *SSHUploadPackRequest) Reset()                    { *m = SSHUploadPackRequest{} }
 func (m *SSHUploadPackRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadPackRequest) ProtoMessage()               {}
-func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -57,7 +57,7 @@ type SSHUploadPackResponse struct {
 func (m *SSHUploadPackResponse) Reset()                    { *m = SSHUploadPackResponse{} }
 func (m *SSHUploadPackResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadPackResponse) ProtoMessage()               {}
-func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -92,7 +92,7 @@ type SSHReceivePackRequest struct {
 func (m *SSHReceivePackRequest) Reset()                    { *m = SSHReceivePackRequest{} }
 func (m *SSHReceivePackRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHReceivePackRequest) ProtoMessage()               {}
-func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -128,7 +128,7 @@ type SSHReceivePackResponse struct {
 func (m *SSHReceivePackResponse) Reset()                    { *m = SSHReceivePackResponse{} }
 func (m *SSHReceivePackResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHReceivePackResponse) ProtoMessage()               {}
-func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -331,11 +331,11 @@ var _SSH_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor3) }
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor6) }
 
-var fileDescriptor3 = []byte{
+var fileDescriptor6 = []byte{
 	// 284 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4a, 0xc3, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4a, 0xc3, 0x40,
 	0x10, 0x76, 0xad, 0x0d, 0x74, 0x1a, 0x3d, 0xac, 0xb5, 0x84, 0xa0, 0x52, 0x72, 0xca, 0x29, 0x48,
 	0xfa, 0x0c, 0x42, 0xbd, 0xc9, 0x86, 0x9e, 0x6b, 0xec, 0x2e, 0xe9, 0x62, 0xe8, 0xc6, 0x9d, 0x49,
 	0x69, 0x41, 0xdf, 0xc9, 0x47, 0x14, 0x92, 0x58, 0x92, 0x6a, 0x8f, 0xf6, 0xb6, 0x33, 0xdf, 0xce,

vendor/vendor.json

@@ -41,6 +41,12 @@
 			"path": "github.com/golang/protobuf/proto",
 			"revision": "8ee79997227bf9b34611aee7946ae64735e6fd93"
 		},
+		{
+			"checksumSHA1": "sfoot+dHmmOgWZS6GJ5X79ClZM0=",
+			"path": "github.com/golang/protobuf/ptypes/timestamp",
+			"revision": "c9c7427a2a70d2eb3bafa0ab2dc163e45f143317",
+			"revisionTime": "2017-03-07T00:15:33Z"
+		},
 		{
 			"checksumSHA1": "SmBqqqR0T+1Ksx5zwCl295Vey0s=",
 			"comment": "v1.0.0-39-ge8f0f8a",
@@ -122,20 +128,20 @@
 			"revisionTime": "2016-11-17T07:43:51Z"
 		},
 		{
-			"checksumSHA1": "HWuFvDMQ5zp554X4QpVjBUgW5wk=",
+			"checksumSHA1": "qnITGZYkVMWqbOeVVt6jMKJ544M=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "84b3ffd032eea7af8df96fb9d7bdc100dac2c569",
-			"revisionTime": "2017-02-27T16:43:55Z",
-			"version": "v0.3.0",
-			"versionExact": "v0.3.0"
+			"revision": "52f77b23166e640a932e50223472d761404afb42",
+			"revisionTime": "2017-03-29T16:52:58Z",
+			"version": "v0.5.0",
+			"versionExact": "v0.5.0"
 		},
 		{
 			"checksumSHA1": "2E36lBoyaVky2EJP1E5ub6Rg+uI=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/helper",
-			"revision": "84b3ffd032eea7af8df96fb9d7bdc100dac2c569",
-			"revisionTime": "2017-02-27T16:43:55Z",
-			"version": "v0.3.0",
-			"versionExact": "v0.3.0"
+			"revision": "52f77b23166e640a932e50223472d761404afb42",
+			"revisionTime": "2017-03-29T16:52:58Z",
+			"version": "v0.5.0",
+			"versionExact": "v0.5.0"
 		},
 		{
 			"checksumSHA1": "9jjO5GjLa0XF/nfWihF02RoH4qc=",