Merge branch 'feature/migrate-get-blob-to-gitaly-2' into 'master'

Use GetBlob RPC instead of TreeEntry RPC for serving blobs

See merge request !182

gitaly_test.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bytes"
-	"encoding/base64"
 	"fmt"
 	"math/rand"
 	"net"
@@ -331,13 +330,12 @@ func TestGetBlobProxiedToGitalySuccessfully(t *testing.T) {
 	defer gitalyServer.Stop()
 
 	gitalyAddress := "unix://" + socketPath
-	pathEncoded := base64.StdEncoding.EncodeToString([]byte("LICENSE"))
 	repoStorage := "default"
-	revisionEncoded := base64.StdEncoding.EncodeToString([]byte("54fcc214b94e78d7a41a9a8fe6d87a5e59500e51"))
+	oid := "54fcc214b94e78d7a41a9a8fe6d87a5e59500e51"
 	repoRelativePath := "foo/bar.git"
-	jsonParams := fmt.Sprintf(`{"GitalyServer":{"Address":"%s","Token":""},"TreeEntryRequest":{"repository":{"storage_name":"%s","relative_path":"%s"},"revision":"%s","path":"%s"}}`,
-		gitalyAddress, repoStorage, repoRelativePath, revisionEncoded, pathEncoded)
-	expectedBody := testhelper.GitalyTreeEntryResponseMock
+	jsonParams := fmt.Sprintf(`{"GitalyServer":{"Address":"%s","Token":""},"GetBlobRequest":{"repository":{"storage_name":"%s","relative_path":"%s"},"oid":"%s","limit":-1}}`,
+		gitalyAddress, repoStorage, repoRelativePath, oid)
+	expectedBody := testhelper.GitalyGetBlobResponseMock
 	blobLength := len(expectedBody)
 
 	resp, body, err := doSendDataRequest("/something", "git-blob", jsonParams)
@@ -354,12 +352,11 @@ func TestGetBlobProxiedToGitalyInterruptedStream(t *testing.T) {
 	defer gitalyServer.Stop()
 
 	gitalyAddress := "unix://" + socketPath
-	pathEncoded := base64.StdEncoding.EncodeToString([]byte("LICENSE"))
 	repoStorage := "default"
-	revisionEncoded := base64.StdEncoding.EncodeToString([]byte("54fcc214b94e78d7a41a9a8fe6d87a5e59500e51"))
+	oid := "54fcc214b94e78d7a41a9a8fe6d87a5e59500e51"
 	repoRelativePath := "foo/bar.git"
-	jsonParams := fmt.Sprintf(`{"GitalyServer":{"Address":"%s","Token":""},"TreeEntryRequest":{"repository":{"storage_name":"%s","relative_path":"%s"},"revision":"%s","path":"%s"}}`,
-		gitalyAddress, repoStorage, repoRelativePath, revisionEncoded, pathEncoded)
+	jsonParams := fmt.Sprintf(`{"GitalyServer":{"Address":"%s","Token":""},"GetBlobRequest":{"repository":{"storage_name":"%s","relative_path":"%s"},"oid":"%s","limit":-1}}`,
+		gitalyAddress, repoStorage, repoRelativePath, oid)
 
 	resp, _, err := doSendDataRequest("/something", "git-blob", jsonParams)
 	require.NoError(t, err)
@@ -397,7 +394,7 @@ func startGitalyServer(t *testing.T, finalMessageCode codes.Code) (*combinedServ
 
 	gitalyServer := testhelper.NewGitalyServer(finalMessageCode)
 	pb.RegisterSmartHTTPServer(server, gitalyServer)
-	pb.RegisterCommitServer(server, gitalyServer)
+	pb.RegisterBlobServiceServer(server, gitalyServer)
 
 	go server.Serve(listener)
 

internal/git/blob.go

@@ -16,10 +16,10 @@ import (
 
 type blob struct{ senddata.Prefix }
 type blobParams struct {
-	RepoPath         string
-	BlobId           string
-	GitalyServer     gitaly.Server
-	TreeEntryRequest pb.TreeEntryRequest
+	RepoPath       string
+	BlobId         string
+	GitalyServer   gitaly.Server
+	GetBlobRequest pb.GetBlobRequest
 }
 
 var SendBlob = &blob{"git-blob:"}
@@ -39,13 +39,13 @@ func (b *blob) Inject(w http.ResponseWriter, r *http.Request, sendData string) {
 }
 
 func handleSendBlobWithGitaly(w http.ResponseWriter, r *http.Request, params *blobParams) {
-	commitClient, err := gitaly.NewCommitClient(params.GitalyServer)
+	blobClient, err := gitaly.NewBlobClient(params.GitalyServer)
 	if err != nil {
-		helper.Fail500(w, r, fmt.Errorf("commit.GetBlob: %v", err))
+		helper.Fail500(w, r, fmt.Errorf("blob.GetBlob: %v", err))
 	}
 
-	if err := commitClient.SendBlob(r.Context(), w, &params.TreeEntryRequest); err != nil {
-		helper.Fail500(w, r, fmt.Errorf("commit.GetBlob: %v", err))
+	if err := blobClient.SendBlob(r.Context(), w, &params.GetBlobRequest); err != nil {
+		helper.Fail500(w, r, fmt.Errorf("blob.GetBlob: %v", err))
 	}
 }
 

internal/gitaly/commit.go → internal/gitaly/blob.go

@@ -11,12 +11,12 @@ import (
 	"gitlab.com/gitlab-org/gitaly/streamio"
 )
 
-type CommitClient struct {
-	pb.CommitClient
+type BlobClient struct {
+	pb.BlobServiceClient
 }
 
-func (client *CommitClient) SendBlob(ctx context.Context, w http.ResponseWriter, request *pb.TreeEntryRequest) error {
-	c, err := client.TreeEntry(ctx, request)
+func (client *BlobClient) SendBlob(ctx context.Context, w http.ResponseWriter, request *pb.GetBlobRequest) error {
+	c, err := client.GetBlob(ctx, request)
 	if err != nil {
 		return fmt.Errorf("rpc failed: %v", err)
 	}

internal/gitaly/gitaly.go

@@ -36,13 +36,13 @@ func NewSmartHTTPClient(server Server) (*SmartHTTPClient, error) {
 	return &SmartHTTPClient{grpcClient}, nil
 }
 
-func NewCommitClient(server Server) (*CommitClient, error) {
+func NewBlobClient(server Server) (*BlobClient, error) {
 	conn, err := getOrCreateConnection(server)
 	if err != nil {
 		return nil, err
 	}
-	grpcClient := pb.NewCommitClient(conn)
-	return &CommitClient{grpcClient}, nil
+	grpcClient := pb.NewBlobServiceClient(conn)
+	return &BlobClient{grpcClient}, nil
 }
 
 func getOrCreateConnection(server Server) (*grpc.ClientConn, error) {

internal/testhelper/gitaly.go

@@ -23,7 +23,7 @@ type GitalyTestServer struct {
 
 var (
 	GitalyInfoRefsResponseMock    = strings.Repeat("Mock Gitaly InfoRefsResponse data", 100000)
-	GitalyTreeEntryResponseMock   = strings.Repeat("Mock Gitaly TreeEntryResponse data", 100000)
+	GitalyGetBlobResponseMock     = strings.Repeat("Mock Gitaly GetBlobResponse data", 100000)
 	GitalyReceivePackResponseMock []byte
 	GitalyUploadPackResponseMock  []byte
 )
@@ -173,7 +173,7 @@ func (s *GitalyTestServer) CommitIsAncestor(ctx context.Context, in *pb.CommitIs
 	return nil, nil
 }
 
-func (s *GitalyTestServer) TreeEntry(in *pb.TreeEntryRequest, stream pb.Commit_TreeEntryServer) error {
+func (s *GitalyTestServer) GetBlob(in *pb.GetBlobRequest, stream pb.BlobService_GetBlobServer) error {
 	s.WaitGroup.Add(1)
 	defer s.WaitGroup.Done()
 
@@ -181,13 +181,11 @@ func (s *GitalyTestServer) TreeEntry(in *pb.TreeEntryRequest, stream pb.Commit_T
 		return err
 	}
 
-	response := &pb.TreeEntryResponse{
-		Type: pb.TreeEntryResponse_BLOB,
-		Oid:  "deadfacedeadfacedeadfacedeadfacedeadface",
-		Size: int64(len(GitalyTreeEntryResponseMock)),
-		Mode: 0100644,
+	response := &pb.GetBlobResponse{
+		Oid:  in.GetOid(),
+		Size: int64(len(GitalyGetBlobResponseMock)),
 	}
-	nSends, err := sendBytes([]byte(GitalyTreeEntryResponseMock), 100, func(p []byte) error {
+	nSends, err := sendBytes([]byte(GitalyGetBlobResponseMock), 100, func(p []byte) error {
 		response.Data = p
 
 		if err := stream.Send(response); err != nil {
@@ -195,7 +193,7 @@ func (s *GitalyTestServer) TreeEntry(in *pb.TreeEntryRequest, stream pb.Commit_T
 		}
 
 		// Use a new response so we don't send other fields (Size, ...) over and over
-		response = &pb.TreeEntryResponse{}
+		response = &pb.GetBlobResponse{}
 
 		return nil
 	})

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

-0.9.0
+0.15.0

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

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: blob.proto
+
+/*
+Package gitaly is a generated protocol buffer package.
+
+It is generated from these files:
+	blob.proto
+	commit.proto
+	deprecated-services.proto
+	diff.proto
+	notifications.proto
+	ref.proto
+	repository-service.proto
+	shared.proto
+	smarthttp.proto
+	ssh.proto
+
+It has these top-level messages:
+	GetBlobRequest
+	GetBlobResponse
+	CommitIsAncestorRequest
+	CommitIsAncestorResponse
+	TreeEntryRequest
+	TreeEntryResponse
+	CommitsBetweenRequest
+	CommitsBetweenResponse
+	CountCommitsRequest
+	CountCommitsResponse
+	TreeEntry
+	GetTreeEntriesRequest
+	GetTreeEntriesResponse
+	CommitDiffRequest
+	CommitDiffResponse
+	CommitDeltaRequest
+	CommitDelta
+	CommitDeltaResponse
+	PostReceiveRequest
+	PostReceiveResponse
+	FindDefaultBranchNameRequest
+	FindDefaultBranchNameResponse
+	FindAllBranchNamesRequest
+	FindAllBranchNamesResponse
+	FindAllTagNamesRequest
+	FindAllTagNamesResponse
+	FindRefNameRequest
+	FindRefNameResponse
+	FindLocalBranchesRequest
+	FindLocalBranchesResponse
+	FindLocalBranchResponse
+	FindLocalBranchCommitAuthor
+	RepositoryExistsRequest
+	RepositoryExistsResponse
+	Repository
+	GitCommit
+	CommitAuthor
+	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 GetBlobRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Object ID (SHA1) of the blob we want to get
+	Oid string `protobuf:"bytes,2,opt,name=oid" json:"oid,omitempty"`
+	// Maximum number of bytes we want to receive. Use '-1' to get the full blob no matter how big.
+	Limit int64 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
+}
+
+func (m *GetBlobRequest) Reset()                    { *m = GetBlobRequest{} }
+func (m *GetBlobRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobRequest) ProtoMessage()               {}
+func (*GetBlobRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *GetBlobRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetBlobRequest) GetOid() string {
+	if m != nil {
+		return m.Oid
+	}
+	return ""
+}
+
+func (m *GetBlobRequest) GetLimit() int64 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
+type GetBlobResponse struct {
+	// Blob size; present only in first response message
+	Size int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
+	// Chunk of blob data
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+	// Object ID of the actual blob returned. Empty if no blob was found.
+	Oid string `protobuf:"bytes,3,opt,name=oid" json:"oid,omitempty"`
+}
+
+func (m *GetBlobResponse) Reset()                    { *m = GetBlobResponse{} }
+func (m *GetBlobResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobResponse) ProtoMessage()               {}
+func (*GetBlobResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *GetBlobResponse) GetSize() int64 {
+	if m != nil {
+		return m.Size
+	}
+	return 0
+}
+
+func (m *GetBlobResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *GetBlobResponse) GetOid() string {
+	if m != nil {
+		return m.Oid
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*GetBlobRequest)(nil), "gitaly.GetBlobRequest")
+	proto.RegisterType((*GetBlobResponse)(nil), "gitaly.GetBlobResponse")
+}
+
+// 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 BlobService service
+
+type BlobServiceClient interface {
+	// GetBlob returns the contents of a blob object referenced by its object
+	// ID. We use a stream to return a chunked arbitrarily large binary
+	// response
+	GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (BlobService_GetBlobClient, error)
+}
+
+type blobServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewBlobServiceClient(cc *grpc.ClientConn) BlobServiceClient {
+	return &blobServiceClient{cc}
+}
+
+func (c *blobServiceClient) GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (BlobService_GetBlobClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[0], c.cc, "/gitaly.BlobService/GetBlob", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &blobServiceGetBlobClient{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 BlobService_GetBlobClient interface {
+	Recv() (*GetBlobResponse, error)
+	grpc.ClientStream
+}
+
+type blobServiceGetBlobClient struct {
+	grpc.ClientStream
+}
+
+func (x *blobServiceGetBlobClient) Recv() (*GetBlobResponse, error) {
+	m := new(GetBlobResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for BlobService service
+
+type BlobServiceServer interface {
+	// GetBlob returns the contents of a blob object referenced by its object
+	// ID. We use a stream to return a chunked arbitrarily large binary
+	// response
+	GetBlob(*GetBlobRequest, BlobService_GetBlobServer) error
+}
+
+func RegisterBlobServiceServer(s *grpc.Server, srv BlobServiceServer) {
+	s.RegisterService(&_BlobService_serviceDesc, srv)
+}
+
+func _BlobService_GetBlob_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetBlobRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(BlobServiceServer).GetBlob(m, &blobServiceGetBlobServer{stream})
+}
+
+type BlobService_GetBlobServer interface {
+	Send(*GetBlobResponse) error
+	grpc.ServerStream
+}
+
+type blobServiceGetBlobServer struct {
+	grpc.ServerStream
+}
+
+func (x *blobServiceGetBlobServer) Send(m *GetBlobResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _BlobService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.BlobService",
+	HandlerType: (*BlobServiceServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetBlob",
+			Handler:       _BlobService_GetBlob_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "blob.proto",
+}
+
+func init() { proto.RegisterFile("blob.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 217 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0x31, 0x4b, 0xc7, 0x30,
+	0x10, 0xc5, 0x8d, 0xd1, 0xbf, 0x78, 0x2d, 0x2a, 0x87, 0x68, 0xe9, 0x54, 0x3a, 0x75, 0x2a, 0x52,
+	0x77, 0x07, 0x17, 0x07, 0x71, 0x89, 0x9f, 0x20, 0xb1, 0x87, 0x06, 0xa2, 0x57, 0x93, 0x28, 0xd4,
+	0x4f, 0x2f, 0x4d, 0x6c, 0x51, 0xdc, 0x5e, 0x5e, 0x92, 0xf7, 0x7b, 0x77, 0x00, 0xc6, 0xb1, 0xe9,
+	0x27, 0xcf, 0x91, 0x71, 0xf7, 0x6c, 0xa3, 0x76, 0x73, 0x5d, 0x86, 0x17, 0xed, 0x69, 0xcc, 0x6e,
+	0xeb, 0xe0, 0xe4, 0x8e, 0xe2, 0xad, 0x63, 0xa3, 0xe8, 0xfd, 0x83, 0x42, 0xc4, 0x01, 0xc0, 0xd3,
+	0xc4, 0xc1, 0x46, 0xf6, 0x73, 0x25, 0x1a, 0xd1, 0x15, 0x03, 0xf6, 0xf9, 0x73, 0xaf, 0xb6, 0x1b,
+	0xf5, 0xeb, 0x15, 0x9e, 0x81, 0x64, 0x3b, 0x56, 0xfb, 0x8d, 0xe8, 0x8e, 0xd5, 0x22, 0xf1, 0x1c,
+	0x0e, 0x9d, 0x7d, 0xb5, 0xb1, 0x92, 0x8d, 0xe8, 0xa4, 0xca, 0x87, 0xf6, 0x1e, 0x4e, 0x37, 0x5a,
+	0x98, 0xf8, 0x2d, 0x10, 0x22, 0x1c, 0x04, 0xfb, 0x45, 0x09, 0x24, 0x55, 0xd2, 0x8b, 0x37, 0xea,
+	0xa8, 0x53, 0x5e, 0xa9, 0x92, 0x5e, 0x11, 0x72, 0x43, 0x0c, 0x0f, 0x50, 0x2c, 0x49, 0x8f, 0xe4,
+	0x3f, 0xed, 0x13, 0xe1, 0x0d, 0x1c, 0xfd, 0x64, 0xe3, 0xc5, 0x5a, 0xf7, 0xef, 0x68, 0xf5, 0xe5,
+	0x3f, 0x3f, 0x97, 0x68, 0xf7, 0xae, 0x84, 0xd9, 0xa5, 0x85, 0x5c, 0x7f, 0x07, 0x00, 0x00, 0xff,
+	0xff, 0xab, 0x77, 0x1a, 0x6d, 0x34, 0x01, 0x00, 0x00,
+}

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

 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: commit.proto
 
-/*
-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
-	TreeEntryRequest
-	TreeEntryResponse
-	CommitDiffRequest
-	CommitDiffResponse
-	CommitDeltaRequest
-	CommitDelta
-	CommitDeltaResponse
-	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"
@@ -66,12 +17,6 @@ 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 TreeEntryResponse_ObjectType int32
 
 const (
@@ -98,9 +43,33 @@ func (x TreeEntryResponse_ObjectType) String() string {
 	return proto.EnumName(TreeEntryResponse_ObjectType_name, int32(x))
 }
 func (TreeEntryResponse_ObjectType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{3, 0}
+	return fileDescriptor1, []int{3, 0}
 }
 
+type TreeEntry_EntryType int32
+
+const (
+	TreeEntry_BLOB   TreeEntry_EntryType = 0
+	TreeEntry_TREE   TreeEntry_EntryType = 1
+	TreeEntry_COMMIT TreeEntry_EntryType = 3
+)
+
+var TreeEntry_EntryType_name = map[int32]string{
+	0: "BLOB",
+	1: "TREE",
+	3: "COMMIT",
+}
+var TreeEntry_EntryType_value = map[string]int32{
+	"BLOB":   0,
+	"TREE":   1,
+	"COMMIT": 3,
+}
+
+func (x TreeEntry_EntryType) String() string {
+	return proto.EnumName(TreeEntry_EntryType_name, int32(x))
+}
+func (TreeEntry_EntryType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{8, 0} }
+
 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"`
@@ -110,7 +79,7 @@ type CommitIsAncestorRequest struct {
 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 (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
 
 func (m *CommitIsAncestorRequest) GetRepository() *Repository {
 	if m != nil {
@@ -140,7 +109,7 @@ type CommitIsAncestorResponse struct {
 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 (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
 
 func (m *CommitIsAncestorResponse) GetValue() bool {
 	if m != nil {
@@ -151,15 +120,17 @@ func (m *CommitIsAncestorResponse) GetValue() bool {
 
 type TreeEntryRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-	Revision   []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
-	Path       []byte      `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
-	Limit      int64       `protobuf:"varint,4,opt,name=limit" json:"limit,omitempty"`
+	// commit ID or refname
+	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
+	// entry path relative to repository root
+	Path  []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
+	Limit int64  `protobuf:"varint,4,opt,name=limit" json:"limit,omitempty"`
 }
 
 func (m *TreeEntryRequest) Reset()                    { *m = TreeEntryRequest{} }
 func (m *TreeEntryRequest) String() string            { return proto.CompactTextString(m) }
 func (*TreeEntryRequest) ProtoMessage()               {}
-func (*TreeEntryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+func (*TreeEntryRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
 
 func (m *TreeEntryRequest) GetRepository() *Repository {
 	if m != nil {
@@ -191,16 +162,19 @@ func (m *TreeEntryRequest) GetLimit() int64 {
 
 type TreeEntryResponse struct {
 	Type TreeEntryResponse_ObjectType `protobuf:"varint,1,opt,name=type,enum=gitaly.TreeEntryResponse_ObjectType" json:"type,omitempty"`
-	Oid  string                       `protobuf:"bytes,2,opt,name=oid" json:"oid,omitempty"`
-	Size int64                        `protobuf:"varint,3,opt,name=size" json:"size,omitempty"`
-	Mode int32                        `protobuf:"varint,4,opt,name=mode" json:"mode,omitempty"`
-	Data []byte                       `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
+	// SHA1 object ID
+	Oid  string `protobuf:"bytes,2,opt,name=oid" json:"oid,omitempty"`
+	Size int64  `protobuf:"varint,3,opt,name=size" json:"size,omitempty"`
+	// file mode
+	Mode int32 `protobuf:"varint,4,opt,name=mode" json:"mode,omitempty"`
+	// raw object contents
+	Data []byte `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
 }
 
 func (m *TreeEntryResponse) Reset()                    { *m = TreeEntryResponse{} }
 func (m *TreeEntryResponse) String() string            { return proto.CompactTextString(m) }
 func (*TreeEntryResponse) ProtoMessage()               {}
-func (*TreeEntryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+func (*TreeEntryResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 
 func (m *TreeEntryResponse) GetType() TreeEntryResponse_ObjectType {
 	if m != nil {
@@ -237,12 +211,217 @@ func (m *TreeEntryResponse) GetData() []byte {
 	return nil
 }
 
+type CommitsBetweenRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	From       []byte      `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
+	To         []byte      `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
+}
+
+func (m *CommitsBetweenRequest) Reset()                    { *m = CommitsBetweenRequest{} }
+func (m *CommitsBetweenRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitsBetweenRequest) ProtoMessage()               {}
+func (*CommitsBetweenRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
+
+func (m *CommitsBetweenRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitsBetweenRequest) GetFrom() []byte {
+	if m != nil {
+		return m.From
+	}
+	return nil
+}
+
+func (m *CommitsBetweenRequest) GetTo() []byte {
+	if m != nil {
+		return m.To
+	}
+	return nil
+}
+
+type CommitsBetweenResponse struct {
+	Commits []*GitCommit `protobuf:"bytes,1,rep,name=commits" json:"commits,omitempty"`
+}
+
+func (m *CommitsBetweenResponse) Reset()                    { *m = CommitsBetweenResponse{} }
+func (m *CommitsBetweenResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitsBetweenResponse) ProtoMessage()               {}
+func (*CommitsBetweenResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
+
+func (m *CommitsBetweenResponse) GetCommits() []*GitCommit {
+	if m != nil {
+		return m.Commits
+	}
+	return nil
+}
+
+type CountCommitsRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Revision   []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
+}
+
+func (m *CountCommitsRequest) Reset()                    { *m = CountCommitsRequest{} }
+func (m *CountCommitsRequest) String() string            { return proto.CompactTextString(m) }
+func (*CountCommitsRequest) ProtoMessage()               {}
+func (*CountCommitsRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
+
+func (m *CountCommitsRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CountCommitsRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+type CountCommitsResponse struct {
+	Count int32 `protobuf:"varint,1,opt,name=count" json:"count,omitempty"`
+}
+
+func (m *CountCommitsResponse) Reset()                    { *m = CountCommitsResponse{} }
+func (m *CountCommitsResponse) String() string            { return proto.CompactTextString(m) }
+func (*CountCommitsResponse) ProtoMessage()               {}
+func (*CountCommitsResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
+
+func (m *CountCommitsResponse) GetCount() int32 {
+	if m != nil {
+		return m.Count
+	}
+	return 0
+}
+
+type TreeEntry struct {
+	// OID of the object this tree entry points to
+	Oid string `protobuf:"bytes,1,opt,name=oid" json:"oid,omitempty"`
+	// OID of the tree attached to commit_oid
+	RootOid string `protobuf:"bytes,2,opt,name=root_oid,json=rootOid" json:"root_oid,omitempty"`
+	// Path relative to repository root
+	Path []byte              `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
+	Type TreeEntry_EntryType `protobuf:"varint,4,opt,name=type,enum=gitaly.TreeEntry_EntryType" json:"type,omitempty"`
+	// File mode e.g. 0644
+	Mode int32 `protobuf:"varint,5,opt,name=mode" json:"mode,omitempty"`
+	// The commit object via which this entry was retrieved
+	CommitOid string `protobuf:"bytes,6,opt,name=commit_oid,json=commitOid" json:"commit_oid,omitempty"`
+}
+
+func (m *TreeEntry) Reset()                    { *m = TreeEntry{} }
+func (m *TreeEntry) String() string            { return proto.CompactTextString(m) }
+func (*TreeEntry) ProtoMessage()               {}
+func (*TreeEntry) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
+
+func (m *TreeEntry) GetOid() string {
+	if m != nil {
+		return m.Oid
+	}
+	return ""
+}
+
+func (m *TreeEntry) GetRootOid() string {
+	if m != nil {
+		return m.RootOid
+	}
+	return ""
+}
+
+func (m *TreeEntry) GetPath() []byte {
+	if m != nil {
+		return m.Path
+	}
+	return nil
+}
+
+func (m *TreeEntry) GetType() TreeEntry_EntryType {
+	if m != nil {
+		return m.Type
+	}
+	return TreeEntry_BLOB
+}
+
+func (m *TreeEntry) GetMode() int32 {
+	if m != nil {
+		return m.Mode
+	}
+	return 0
+}
+
+func (m *TreeEntry) GetCommitOid() string {
+	if m != nil {
+		return m.CommitOid
+	}
+	return ""
+}
+
+type GetTreeEntriesRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Revision   []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
+	Path       []byte      `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
+}
+
+func (m *GetTreeEntriesRequest) Reset()                    { *m = GetTreeEntriesRequest{} }
+func (m *GetTreeEntriesRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetTreeEntriesRequest) ProtoMessage()               {}
+func (*GetTreeEntriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} }
+
+func (m *GetTreeEntriesRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetTreeEntriesRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+func (m *GetTreeEntriesRequest) GetPath() []byte {
+	if m != nil {
+		return m.Path
+	}
+	return nil
+}
+
+type GetTreeEntriesResponse struct {
+	Entries []*TreeEntry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
+}
+
+func (m *GetTreeEntriesResponse) Reset()                    { *m = GetTreeEntriesResponse{} }
+func (m *GetTreeEntriesResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetTreeEntriesResponse) ProtoMessage()               {}
+func (*GetTreeEntriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} }
+
+func (m *GetTreeEntriesResponse) GetEntries() []*TreeEntry {
+	if m != nil {
+		return m.Entries
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
 	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
 	proto.RegisterType((*TreeEntryRequest)(nil), "gitaly.TreeEntryRequest")
 	proto.RegisterType((*TreeEntryResponse)(nil), "gitaly.TreeEntryResponse")
+	proto.RegisterType((*CommitsBetweenRequest)(nil), "gitaly.CommitsBetweenRequest")
+	proto.RegisterType((*CommitsBetweenResponse)(nil), "gitaly.CommitsBetweenResponse")
+	proto.RegisterType((*CountCommitsRequest)(nil), "gitaly.CountCommitsRequest")
+	proto.RegisterType((*CountCommitsResponse)(nil), "gitaly.CountCommitsResponse")
+	proto.RegisterType((*TreeEntry)(nil), "gitaly.TreeEntry")
+	proto.RegisterType((*GetTreeEntriesRequest)(nil), "gitaly.GetTreeEntriesRequest")
+	proto.RegisterType((*GetTreeEntriesResponse)(nil), "gitaly.GetTreeEntriesResponse")
 	proto.RegisterEnum("gitaly.TreeEntryResponse_ObjectType", TreeEntryResponse_ObjectType_name, TreeEntryResponse_ObjectType_value)
+	proto.RegisterEnum("gitaly.TreeEntry_EntryType", TreeEntry_EntryType_name, TreeEntry_EntryType_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -253,36 +432,39 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Commit service
+// Client API for CommitService service
 
-type CommitClient interface {
+type CommitServiceClient interface {
 	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
-	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error)
+	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error)
+	CommitsBetween(ctx context.Context, in *CommitsBetweenRequest, opts ...grpc.CallOption) (CommitService_CommitsBetweenClient, error)
+	CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error)
+	GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (CommitService_GetTreeEntriesClient, error)
 }
 
-type commitClient struct {
+type commitServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewCommitClient(cc *grpc.ClientConn) CommitClient {
-	return &commitClient{cc}
+func NewCommitServiceClient(cc *grpc.ClientConn) CommitServiceClient {
+	return &commitServiceClient{cc}
 }
 
-func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
+func (c *commitServiceClient) 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...)
+	err := grpc.Invoke(ctx, "/gitaly.CommitService/CommitIsAncestor", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Commit_serviceDesc.Streams[0], c.cc, "/gitaly.Commit/TreeEntry", opts...)
+func (c *commitServiceClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[0], c.cc, "/gitaly.CommitService/TreeEntry", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &commitTreeEntryClient{stream}
+	x := &commitServiceTreeEntryClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -292,16 +474,16 @@ func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts
 	return x, nil
 }
 
-type Commit_TreeEntryClient interface {
+type CommitService_TreeEntryClient interface {
 	Recv() (*TreeEntryResponse, error)
 	grpc.ClientStream
 }
 
-type commitTreeEntryClient struct {
+type commitServiceTreeEntryClient struct {
 	grpc.ClientStream
 }
 
-func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) {
+func (x *commitServiceTreeEntryClient) Recv() (*TreeEntryResponse, error) {
 	m := new(TreeEntryResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -309,103 +491,268 @@ func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) {
 	return m, nil
 }
 
-// Server API for Commit service
+func (c *commitServiceClient) CommitsBetween(ctx context.Context, in *CommitsBetweenRequest, opts ...grpc.CallOption) (CommitService_CommitsBetweenClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[1], c.cc, "/gitaly.CommitService/CommitsBetween", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &commitServiceCommitsBetweenClient{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 CommitService_CommitsBetweenClient interface {
+	Recv() (*CommitsBetweenResponse, error)
+	grpc.ClientStream
+}
+
+type commitServiceCommitsBetweenClient struct {
+	grpc.ClientStream
+}
+
+func (x *commitServiceCommitsBetweenClient) Recv() (*CommitsBetweenResponse, error) {
+	m := new(CommitsBetweenResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *commitServiceClient) CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error) {
+	out := new(CountCommitsResponse)
+	err := grpc.Invoke(ctx, "/gitaly.CommitService/CountCommits", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *commitServiceClient) GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (CommitService_GetTreeEntriesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[2], c.cc, "/gitaly.CommitService/GetTreeEntries", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &commitServiceGetTreeEntriesClient{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 CommitService_GetTreeEntriesClient interface {
+	Recv() (*GetTreeEntriesResponse, error)
+	grpc.ClientStream
+}
+
+type commitServiceGetTreeEntriesClient struct {
+	grpc.ClientStream
+}
+
+func (x *commitServiceGetTreeEntriesClient) Recv() (*GetTreeEntriesResponse, error) {
+	m := new(GetTreeEntriesResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for CommitService service
 
-type CommitServer interface {
+type CommitServiceServer interface {
 	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
-	TreeEntry(*TreeEntryRequest, Commit_TreeEntryServer) error
+	TreeEntry(*TreeEntryRequest, CommitService_TreeEntryServer) error
+	CommitsBetween(*CommitsBetweenRequest, CommitService_CommitsBetweenServer) error
+	CountCommits(context.Context, *CountCommitsRequest) (*CountCommitsResponse, error)
+	GetTreeEntries(*GetTreeEntriesRequest, CommitService_GetTreeEntriesServer) error
 }
 
-func RegisterCommitServer(s *grpc.Server, srv CommitServer) {
-	s.RegisterService(&_Commit_serviceDesc, srv)
+func RegisterCommitServiceServer(s *grpc.Server, srv CommitServiceServer) {
+	s.RegisterService(&_CommitService_serviceDesc, srv)
 }
 
-func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _CommitService_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)
+		return srv.(CommitServiceServer).CommitIsAncestor(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/gitaly.Commit/CommitIsAncestor",
+		FullMethod: "/gitaly.CommitService/CommitIsAncestor",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
+		return srv.(CommitServiceServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Commit_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _CommitService_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(TreeEntryRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(CommitServer).TreeEntry(m, &commitTreeEntryServer{stream})
+	return srv.(CommitServiceServer).TreeEntry(m, &commitServiceTreeEntryServer{stream})
 }
 
-type Commit_TreeEntryServer interface {
+type CommitService_TreeEntryServer interface {
 	Send(*TreeEntryResponse) error
 	grpc.ServerStream
 }
 
-type commitTreeEntryServer struct {
+type commitServiceTreeEntryServer struct {
+	grpc.ServerStream
+}
+
+func (x *commitServiceTreeEntryServer) Send(m *TreeEntryResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _CommitService_CommitsBetween_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CommitsBetweenRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(CommitServiceServer).CommitsBetween(m, &commitServiceCommitsBetweenServer{stream})
+}
+
+type CommitService_CommitsBetweenServer interface {
+	Send(*CommitsBetweenResponse) error
+	grpc.ServerStream
+}
+
+type commitServiceCommitsBetweenServer struct {
 	grpc.ServerStream
 }
 
-func (x *commitTreeEntryServer) Send(m *TreeEntryResponse) error {
+func (x *commitServiceCommitsBetweenServer) Send(m *CommitsBetweenResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-var _Commit_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Commit",
-	HandlerType: (*CommitServer)(nil),
+func _CommitService_CountCommits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CountCommitsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CommitServiceServer).CountCommits(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.CommitService/CountCommits",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CommitServiceServer).CountCommits(ctx, req.(*CountCommitsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _CommitService_GetTreeEntries_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetTreeEntriesRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(CommitServiceServer).GetTreeEntries(m, &commitServiceGetTreeEntriesServer{stream})
+}
+
+type CommitService_GetTreeEntriesServer interface {
+	Send(*GetTreeEntriesResponse) error
+	grpc.ServerStream
+}
+
+type commitServiceGetTreeEntriesServer struct {
+	grpc.ServerStream
+}
+
+func (x *commitServiceGetTreeEntriesServer) Send(m *GetTreeEntriesResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _CommitService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.CommitService",
+	HandlerType: (*CommitServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "CommitIsAncestor",
-			Handler:    _Commit_CommitIsAncestor_Handler,
+			Handler:    _CommitService_CommitIsAncestor_Handler,
+		},
+		{
+			MethodName: "CountCommits",
+			Handler:    _CommitService_CountCommits_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
 			StreamName:    "TreeEntry",
-			Handler:       _Commit_TreeEntry_Handler,
+			Handler:       _CommitService_TreeEntry_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "CommitsBetween",
+			Handler:       _CommitService_CommitsBetween_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "GetTreeEntries",
+			Handler:       _CommitService_GetTreeEntries_Handler,
 			ServerStreams: true,
 		},
 	},
 	Metadata: "commit.proto",
 }
 
-func init() { proto.RegisterFile("commit.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-	// 404 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xc1, 0x6a, 0xdc, 0x30,
-	0x10, 0x86, 0x57, 0xb1, 0xd7, 0x71, 0x26, 0xa6, 0xb8, 0x43, 0xa1, 0xce, 0x5e, 0x62, 0x4c, 0x0f,
-	0x7b, 0x32, 0xc1, 0xa5, 0xd0, 0x6b, 0x92, 0x2e, 0xc5, 0xd0, 0xb0, 0x20, 0x0c, 0x3d, 0x16, 0xc7,
-	0x16, 0x5d, 0x15, 0xdb, 0x72, 0x25, 0x25, 0xe0, 0xbe, 0x41, 0xa1, 0xef, 0xd1, 0xf7, 0xe9, 0x13,
-	0x15, 0x49, 0x59, 0x37, 0x34, 0xdd, 0x53, 0x6f, 0xff, 0xcc, 0xfc, 0x1e, 0x7f, 0xfa, 0x25, 0x88,
-	0x1a, 0xd1, 0xf7, 0x5c, 0xe7, 0xa3, 0x14, 0x5a, 0x60, 0xf0, 0x99, 0xeb, 0xba, 0x9b, 0x56, 0x91,
-	0xda, 0xd5, 0x92, 0xb5, 0xae, 0x9b, 0x7d, 0x27, 0xf0, 0xf2, 0xda, 0xda, 0x4a, 0x75, 0x39, 0x34,
-	0x4c, 0x69, 0x21, 0x29, 0xfb, 0x7a, 0xc7, 0x94, 0xc6, 0x02, 0x40, 0xb2, 0x51, 0x28, 0xae, 0x85,
-	0x9c, 0x12, 0x92, 0x92, 0xf5, 0x69, 0x81, 0xb9, 0x5b, 0x93, 0xd3, 0x79, 0x42, 0x1f, 0xb9, 0xf0,
-	0x1c, 0x4e, 0xeb, 0x87, 0x35, 0x9f, 0x78, 0x9b, 0x1c, 0xa5, 0x64, 0x7d, 0x42, 0x61, 0xdf, 0x2a,
-	0x5b, 0x3c, 0x83, 0xb0, 0xd9, 0xf1, 0xae, 0x35, 0x53, 0xcf, 0x4e, 0x8f, 0x6d, 0x5d, 0xb6, 0xd9,
-	0x05, 0x24, 0x4f, 0x51, 0xd4, 0x28, 0x06, 0xc5, 0xf0, 0x05, 0x2c, 0xef, 0xeb, 0xee, 0x8e, 0x59,
-	0x8c, 0x90, 0xba, 0x22, 0xfb, 0x41, 0x20, 0xae, 0x24, 0x63, 0x9b, 0x41, 0xcb, 0xe9, 0x7f, 0xb0,
-	0x57, 0x10, 0x4a, 0x76, 0xcf, 0x15, 0x17, 0x83, 0x65, 0x8e, 0xe8, 0x5c, 0x23, 0x82, 0x3f, 0xd6,
-	0x7a, 0x67, 0x69, 0x23, 0x6a, 0xb5, 0xc1, 0xe9, 0x78, 0xcf, 0x75, 0xe2, 0xa7, 0x64, 0xed, 0x51,
-	0x57, 0x64, 0xbf, 0x08, 0x3c, 0x7f, 0x84, 0xf3, 0x80, 0xfe, 0x16, 0x7c, 0x3d, 0x8d, 0x8e, 0xfc,
-	0x59, 0xf1, 0x6a, 0x4f, 0xf2, 0xc4, 0x98, 0x6f, 0x6f, 0xbf, 0xb0, 0x46, 0x57, 0xd3, 0xc8, 0xa8,
-	0xfd, 0x02, 0x63, 0xf0, 0xc4, 0x1c, 0xa2, 0x91, 0x86, 0x45, 0xf1, 0x6f, 0xcc, 0xb2, 0x78, 0xd4,
-	0x6a, 0xd3, 0xeb, 0x45, 0xcb, 0x2c, 0xca, 0x92, 0x5a, 0x6d, 0x7a, 0x6d, 0xad, 0xeb, 0x64, 0xe9,
-	0x98, 0x8d, 0xce, 0xde, 0x00, 0xfc, 0xf9, 0x03, 0x02, 0x04, 0xd7, 0xdb, 0x9b, 0x9b, 0xb2, 0x8a,
-	0x17, 0x18, 0x82, 0x7f, 0xf5, 0x61, 0x7b, 0x15, 0x13, 0xa3, 0x2a, 0xba, 0xd9, 0xc4, 0x47, 0x78,
-	0x0c, 0x5e, 0x75, 0xf9, 0x3e, 0xf6, 0x8a, 0x9f, 0x04, 0x02, 0x77, 0x2d, 0xf8, 0x11, 0xe2, 0xbf,
-	0x2f, 0x08, 0xcf, 0xf7, 0xe7, 0x39, 0xf0, 0x8a, 0x56, 0xe9, 0x61, 0x83, 0x3b, 0x77, 0xb6, 0xc0,
-	0x77, 0x70, 0x32, 0xc7, 0x81, 0xc9, 0x3f, 0x12, 0x72, 0xab, 0xce, 0x0e, 0x66, 0x97, 0x2d, 0x2e,
-	0xc8, 0x6d, 0x60, 0x9f, 0xf4, 0xeb, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa2, 0xe6, 0x0b, 0xac,
-	0xf8, 0x02, 0x00, 0x00,
+func init() { proto.RegisterFile("commit.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 656 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xdb, 0x6e, 0x13, 0x3d,
+	0x10, 0x8e, 0xb3, 0x39, 0x4e, 0xf3, 0x47, 0x5b, 0xff, 0x2d, 0x6c, 0x53, 0x4a, 0x23, 0x8b, 0x8b,
+	0x48, 0x45, 0xa1, 0x0a, 0x42, 0xe2, 0xb6, 0x2d, 0x51, 0x15, 0x41, 0x15, 0xc9, 0x8d, 0xc4, 0x65,
+	0xb5, 0xcd, 0x1a, 0x6a, 0x94, 0xc4, 0xcb, 0xda, 0x0d, 0x0a, 0x3c, 0x01, 0x12, 0xaf, 0xc1, 0x0b,
+	0x71, 0xcf, 0xbb, 0x20, 0xdb, 0x7b, 0xca, 0xe9, 0xaa, 0x82, 0x9b, 0x68, 0x66, 0x3c, 0x9e, 0xef,
+	0xcb, 0xcc, 0x37, 0x5e, 0x68, 0x8c, 0xc5, 0x74, 0xca, 0x55, 0x37, 0x8c, 0x84, 0x12, 0xb8, 0xf2,
+	0x91, 0x2b, 0x7f, 0xb2, 0x68, 0x35, 0xe4, 0x9d, 0x1f, 0xb1, 0xc0, 0x46, 0xc9, 0x77, 0x04, 0x8f,
+	0x2f, 0x4c, 0xda, 0x40, 0x9e, 0xcd, 0xc6, 0x4c, 0x2a, 0x11, 0x51, 0xf6, 0xf9, 0x9e, 0x49, 0x85,
+	0x7b, 0x00, 0x11, 0x0b, 0x85, 0xe4, 0x4a, 0x44, 0x0b, 0x0f, 0xb5, 0x51, 0x67, 0xa7, 0x87, 0xbb,
+	0xb6, 0x4c, 0x97, 0xa6, 0x27, 0x34, 0x97, 0x85, 0x8f, 0x61, 0xc7, 0x8f, 0xcb, 0xdc, 0xf0, 0xc0,
+	0x2b, 0xb6, 0x51, 0xa7, 0x4e, 0x21, 0x09, 0x0d, 0x02, 0x7c, 0x00, 0xb5, 0xf1, 0x1d, 0x9f, 0x04,
+	0xfa, 0xd4, 0x31, 0xa7, 0x55, 0xe3, 0x0f, 0x02, 0x72, 0x0a, 0xde, 0x3a, 0x15, 0x19, 0x8a, 0x99,
+	0x64, 0x78, 0x0f, 0xca, 0x73, 0x7f, 0x72, 0xcf, 0x0c, 0x8d, 0x1a, 0xb5, 0x0e, 0xf9, 0x81, 0xc0,
+	0x1d, 0x45, 0x8c, 0xf5, 0x67, 0x2a, 0x5a, 0x3c, 0x84, 0x76, 0x0b, 0x6a, 0x11, 0x9b, 0x73, 0xc9,
+	0xc5, 0xcc, 0x70, 0x6e, 0xd0, 0xd4, 0xc7, 0x18, 0x4a, 0xa1, 0xaf, 0xee, 0x0c, 0xdb, 0x06, 0x35,
+	0xb6, 0xa6, 0x33, 0xe1, 0x53, 0xae, 0xbc, 0x52, 0x1b, 0x75, 0x1c, 0x6a, 0x1d, 0xf2, 0x0b, 0xc1,
+	0x6e, 0x8e, 0x4e, 0x4c, 0xfd, 0x35, 0x94, 0xd4, 0x22, 0xb4, 0xcc, 0x9b, 0xbd, 0x67, 0x09, 0x93,
+	0xb5, 0xc4, 0xee, 0xf0, 0xf6, 0x13, 0x1b, 0xab, 0xd1, 0x22, 0x64, 0xd4, 0xdc, 0xc0, 0x2e, 0x38,
+	0x22, 0x6d, 0xa2, 0x36, 0x35, 0x17, 0xc9, 0xbf, 0x32, 0xc3, 0xc5, 0xa1, 0xc6, 0xd6, 0xb1, 0xa9,
+	0x08, 0x98, 0xa1, 0x52, 0xa6, 0xc6, 0xd6, 0xb1, 0xc0, 0x57, 0xbe, 0x57, 0xb6, 0x9c, 0xb5, 0x4d,
+	0x5e, 0x01, 0x64, 0x08, 0x18, 0xa0, 0x72, 0x31, 0xbc, 0xba, 0x1a, 0x8c, 0xdc, 0x02, 0xae, 0x41,
+	0xe9, 0xfc, 0xdd, 0xf0, 0xdc, 0x45, 0xda, 0x1a, 0xd1, 0x7e, 0xdf, 0x2d, 0xe2, 0x2a, 0x38, 0xa3,
+	0xb3, 0x4b, 0xd7, 0x21, 0x02, 0xf6, 0xed, 0x54, 0xe4, 0x39, 0x53, 0x5f, 0x18, 0x9b, 0x3d, 0xa4,
+	0xcf, 0x18, 0x4a, 0x1f, 0x22, 0x31, 0x8d, 0x7b, 0x6c, 0x6c, 0xdc, 0x84, 0xa2, 0x12, 0x71, 0x77,
+	0x8b, 0x4a, 0x90, 0x3e, 0x3c, 0x5a, 0x05, 0x8c, 0x3b, 0x79, 0x02, 0x55, 0x2b, 0x69, 0xe9, 0xa1,
+	0xb6, 0xd3, 0xd9, 0xe9, 0xed, 0x26, 0x70, 0x97, 0x5c, 0xd9, 0x3b, 0x34, 0xc9, 0x20, 0x0c, 0xfe,
+	0xbf, 0x10, 0xf7, 0xb3, 0x38, 0x2e, 0xff, 0x92, 0x3a, 0xc8, 0x73, 0xd8, 0x5b, 0x86, 0xc9, 0x04,
+	0x3b, 0xd6, 0x71, 0x03, 0x51, 0xa6, 0xd6, 0x21, 0xbf, 0x11, 0xd4, 0xd3, 0xc1, 0x27, 0xf3, 0x45,
+	0xd9, 0x7c, 0x0f, 0xa0, 0x16, 0x09, 0xa1, 0x6e, 0xb2, 0xb1, 0x57, 0xb5, 0x3f, 0xb4, 0xa3, 0x5f,
+	0x93, 0xe1, 0x8b, 0x58, 0x5a, 0x25, 0x23, 0xad, 0xc3, 0x35, 0x69, 0x75, 0xcd, 0x6f, 0x4e, 0x51,
+	0x89, 0x56, 0xca, 0x39, 0xad, 0x1c, 0x01, 0xd8, 0x9e, 0x19, 0xd4, 0x8a, 0x41, 0xad, 0xdb, 0xc8,
+	0x90, 0x07, 0xe4, 0x04, 0xea, 0x69, 0x95, 0x54, 0x29, 0x85, 0x54, 0x29, 0x28, 0xa7, 0x24, 0x87,
+	0x7c, 0x83, 0xfd, 0x4b, 0xa6, 0x12, 0x7c, 0xce, 0xe4, 0x3f, 0x5c, 0x4a, 0x2d, 0x9c, 0x55, 0xf0,
+	0x4c, 0x38, 0xcc, 0x86, 0x56, 0x85, 0x93, 0x6d, 0x61, 0x92, 0xd1, 0xfb, 0xe9, 0xc0, 0x7f, 0x76,
+	0x9a, 0xd7, 0x2c, 0x9a, 0xf3, 0x31, 0xc3, 0xef, 0xc1, 0x5d, 0x7d, 0x98, 0xf0, 0x71, 0x52, 0x61,
+	0xcb, 0xeb, 0xd9, 0x6a, 0x6f, 0x4f, 0xb0, 0xac, 0x48, 0x01, 0xbf, 0xc9, 0xab, 0xc1, 0xdb, 0xf0,
+	0x32, 0xd8, 0x52, 0x07, 0x5b, 0xdf, 0x0c, 0x52, 0x38, 0x45, 0xf8, 0x1a, 0x9a, 0xcb, 0x0b, 0x83,
+	0x8f, 0x96, 0xb1, 0x57, 0x36, 0xb7, 0xf5, 0x74, 0xdb, 0x71, 0xae, 0xe8, 0x5b, 0x68, 0xe4, 0x75,
+	0x8d, 0x0f, 0xb3, 0x3b, 0x6b, 0x4b, 0xd5, 0x7a, 0xb2, 0xf9, 0x30, 0xfd, 0x9f, 0xd7, 0xd0, 0x5c,
+	0x9e, 0x4c, 0xc6, 0x70, 0xa3, 0x5c, 0x32, 0x86, 0x9b, 0x07, 0xaa, 0x19, 0xde, 0x56, 0xcc, 0x17,
+	0xec, 0xe5, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x44, 0x63, 0x9b, 0x80, 0xe7, 0x06, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: deprecated-services.proto
+
+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
+
+// 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)
+	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, 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
+}
+
+func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Commit_serviceDesc.Streams[0], c.cc, "/gitaly.Commit/TreeEntry", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &commitTreeEntryClient{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 Commit_TreeEntryClient interface {
+	Recv() (*TreeEntryResponse, error)
+	grpc.ClientStream
+}
+
+type commitTreeEntryClient struct {
+	grpc.ClientStream
+}
+
+func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) {
+	m := new(TreeEntryResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Commit service
+
+type CommitServer interface {
+	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
+	TreeEntry(*TreeEntryRequest, Commit_TreeEntryServer) 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)
+}
+
+func _Commit_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(TreeEntryRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(CommitServer).TreeEntry(m, &commitTreeEntryServer{stream})
+}
+
+type Commit_TreeEntryServer interface {
+	Send(*TreeEntryResponse) error
+	grpc.ServerStream
+}
+
+type commitTreeEntryServer struct {
+	grpc.ServerStream
+}
+
+func (x *commitTreeEntryServer) Send(m *TreeEntryResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _Commit_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Commit",
+	HandlerType: (*CommitServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CommitIsAncestor",
+			Handler:    _Commit_CommitIsAncestor_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "TreeEntry",
+			Handler:       _Commit_TreeEntry_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "deprecated-services.proto",
+}
+
+// Client API for Diff service
+
+type DiffClient interface {
+	// Returns stream of CommitDiffResponse with patches chunked over messages
+	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
+	// Return a stream so we can divide the response in chunks of deltas
+	CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, 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
+}
+
+func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[1], c.cc, "/gitaly.Diff/CommitDelta", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &diffCommitDeltaClient{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_CommitDeltaClient interface {
+	Recv() (*CommitDeltaResponse, error)
+	grpc.ClientStream
+}
+
+type diffCommitDeltaClient struct {
+	grpc.ClientStream
+}
+
+func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
+	m := new(CommitDeltaResponse)
+	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 with patches chunked over messages
+	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
+	// Return a stream so we can divide the response in chunks of deltas
+	CommitDelta(*CommitDeltaRequest, Diff_CommitDeltaServer) 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)
+}
+
+func _Diff_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CommitDeltaRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DiffServer).CommitDelta(m, &diffCommitDeltaServer{stream})
+}
+
+type Diff_CommitDeltaServer interface {
+	Send(*CommitDeltaResponse) error
+	grpc.ServerStream
+}
+
+type diffCommitDeltaServer struct {
+	grpc.ServerStream
+}
+
+func (x *diffCommitDeltaServer) Send(m *CommitDeltaResponse) 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,
+		},
+		{
+			StreamName:    "CommitDelta",
+			Handler:       _Diff_CommitDelta_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "deprecated-services.proto",
+}
+
+// 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: "deprecated-services.proto",
+}
+
+// Client API for Ref service
+
+type RefClient interface {
+	FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error)
+	FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error)
+	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 {
+	cc *grpc.ClientConn
+}
+
+func NewRefClient(cc *grpc.ClientConn) RefClient {
+	return &refClient{cc}
+}
+
+func (c *refClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) {
+	out := new(FindDefaultBranchNameResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Ref/FindDefaultBranchName", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[0], c.cc, "/gitaly.Ref/FindAllBranchNames", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &refFindAllBranchNamesClient{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_FindAllBranchNamesClient interface {
+	Recv() (*FindAllBranchNamesResponse, error)
+	grpc.ClientStream
+}
+
+type refFindAllBranchNamesClient struct {
+	grpc.ClientStream
+}
+
+func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) {
+	m := new(FindAllBranchNamesResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[1], c.cc, "/gitaly.Ref/FindAllTagNames", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &refFindAllTagNamesClient{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_FindAllTagNamesClient interface {
+	Recv() (*FindAllTagNamesResponse, error)
+	grpc.ClientStream
+}
+
+type refFindAllTagNamesClient struct {
+	grpc.ClientStream
+}
+
+func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) {
+	m := new(FindAllTagNamesResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *refClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) {
+	out := new(FindRefNameResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Ref/FindRefName", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	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 {
+	FindDefaultBranchName(context.Context, *FindDefaultBranchNameRequest) (*FindDefaultBranchNameResponse, error)
+	FindAllBranchNames(*FindAllBranchNamesRequest, Ref_FindAllBranchNamesServer) error
+	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) {
+	s.RegisterService(&_Ref_serviceDesc, srv)
+}
+
+func _Ref_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FindDefaultBranchNameRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RefServer).FindDefaultBranchName(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Ref/FindDefaultBranchName",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RefServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Ref_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(FindAllBranchNamesRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(RefServer).FindAllBranchNames(m, &refFindAllBranchNamesServer{stream})
+}
+
+type Ref_FindAllBranchNamesServer interface {
+	Send(*FindAllBranchNamesResponse) error
+	grpc.ServerStream
+}
+
+type refFindAllBranchNamesServer struct {
+	grpc.ServerStream
+}
+
+func (x *refFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _Ref_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(FindAllTagNamesRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(RefServer).FindAllTagNames(m, &refFindAllTagNamesServer{stream})
+}
+
+type Ref_FindAllTagNamesServer interface {
+	Send(*FindAllTagNamesResponse) error
+	grpc.ServerStream
+}
+
+type refFindAllTagNamesServer struct {
+	grpc.ServerStream
+}
+
+func (x *refFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _Ref_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FindRefNameRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RefServer).FindRefName(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Ref/FindRefName",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RefServer).FindRefName(ctx, req.(*FindRefNameRequest))
+	}
+	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),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "FindDefaultBranchName",
+			Handler:    _Ref_FindDefaultBranchName_Handler,
+		},
+		{
+			MethodName: "FindRefName",
+			Handler:    _Ref_FindRefName_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "FindAllBranchNames",
+			Handler:       _Ref_FindAllBranchNames_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "FindAllTagNames",
+			Handler:       _Ref_FindAllTagNames_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "FindLocalBranches",
+			Handler:       _Ref_FindLocalBranches_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "deprecated-services.proto",
+}
+
+// Client API for SmartHTTP service
+
+type SmartHTTPClient interface {
+	// The response body for GET /info/refs?service=git-upload-pack
+	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 {
+	cc *grpc.ClientConn
+}
+
+func NewSmartHTTPClient(cc *grpc.ClientConn) SmartHTTPClient {
+	return &smartHTTPClient{cc}
+}
+
+func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTP/InfoRefsUploadPack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPInfoRefsUploadPackClient{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 SmartHTTP_InfoRefsUploadPackClient interface {
+	Recv() (*InfoRefsResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPInfoRefsUploadPackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) {
+	m := new(InfoRefsResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTP/InfoRefsReceivePack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPInfoRefsReceivePackClient{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 SmartHTTP_InfoRefsReceivePackClient interface {
+	Recv() (*InfoRefsResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPInfoRefsReceivePackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) {
+	m := new(InfoRefsResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	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 {
+	// The response body for GET /info/refs?service=git-upload-pack
+	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) {
+	s.RegisterService(&_SmartHTTP_serviceDesc, srv)
+}
+
+func _SmartHTTP_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(InfoRefsRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SmartHTTPServer).InfoRefsUploadPack(m, &smartHTTPInfoRefsUploadPackServer{stream})
+}
+
+type SmartHTTP_InfoRefsUploadPackServer interface {
+	Send(*InfoRefsResponse) error
+	grpc.ServerStream
+}
+
+type smartHTTPInfoRefsUploadPackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _SmartHTTP_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(InfoRefsRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SmartHTTPServer).InfoRefsReceivePack(m, &smartHTTPInfoRefsReceivePackServer{stream})
+}
+
+type SmartHTTP_InfoRefsReceivePackServer interface {
+	Send(*InfoRefsResponse) error
+	grpc.ServerStream
+}
+
+type smartHTTPInfoRefsReceivePackServer struct {
+	grpc.ServerStream
+}
+
+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),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "InfoRefsUploadPack",
+			Handler:       _SmartHTTP_InfoRefsUploadPack_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "InfoRefsReceivePack",
+			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: "deprecated-services.proto",
+}
+
+// Client API for SSH service
+
+type SSHClient interface {
+	// To forward 'git upload-pack' to Gitaly for SSH sessions
+	SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error)
+	// To forward 'git receive-pack' to Gitaly for SSH sessions
+	SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error)
+}
+
+type sSHClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewSSHClient(cc *grpc.ClientConn) SSHClient {
+	return &sSHClient{cc}
+}
+
+func (c *sSHClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[0], c.cc, "/gitaly.SSH/SSHUploadPack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &sSHSSHUploadPackClient{stream}
+	return x, nil
+}
+
+type SSH_SSHUploadPackClient interface {
+	Send(*SSHUploadPackRequest) error
+	Recv() (*SSHUploadPackResponse, error)
+	grpc.ClientStream
+}
+
+type sSHSSHUploadPackClient struct {
+	grpc.ClientStream
+}
+
+func (x *sSHSSHUploadPackClient) Send(m *SSHUploadPackRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) {
+	m := new(SSHUploadPackResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *sSHClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[1], c.cc, "/gitaly.SSH/SSHReceivePack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &sSHSSHReceivePackClient{stream}
+	return x, nil
+}
+
+type SSH_SSHReceivePackClient interface {
+	Send(*SSHReceivePackRequest) error
+	Recv() (*SSHReceivePackResponse, error)
+	grpc.ClientStream
+}
+
+type sSHSSHReceivePackClient struct {
+	grpc.ClientStream
+}
+
+func (x *sSHSSHReceivePackClient) Send(m *SSHReceivePackRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) {
+	m := new(SSHReceivePackResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for SSH service
+
+type SSHServer interface {
+	// To forward 'git upload-pack' to Gitaly for SSH sessions
+	SSHUploadPack(SSH_SSHUploadPackServer) error
+	// To forward 'git receive-pack' to Gitaly for SSH sessions
+	SSHReceivePack(SSH_SSHReceivePackServer) error
+}
+
+func RegisterSSHServer(s *grpc.Server, srv SSHServer) {
+	s.RegisterService(&_SSH_serviceDesc, srv)
+}
+
+func _SSH_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SSHServer).SSHUploadPack(&sSHSSHUploadPackServer{stream})
+}
+
+type SSH_SSHUploadPackServer interface {
+	Send(*SSHUploadPackResponse) error
+	Recv() (*SSHUploadPackRequest, error)
+	grpc.ServerStream
+}
+
+type sSHSSHUploadPackServer struct {
+	grpc.ServerStream
+}
+
+func (x *sSHSSHUploadPackServer) Send(m *SSHUploadPackResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) {
+	m := new(SSHUploadPackRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _SSH_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SSHServer).SSHReceivePack(&sSHSSHReceivePackServer{stream})
+}
+
+type SSH_SSHReceivePackServer interface {
+	Send(*SSHReceivePackResponse) error
+	Recv() (*SSHReceivePackRequest, error)
+	grpc.ServerStream
+}
+
+type sSHSSHReceivePackServer struct {
+	grpc.ServerStream
+}
+
+func (x *sSHSSHReceivePackServer) Send(m *SSHReceivePackResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) {
+	m := new(SSHReceivePackRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+var _SSH_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.SSH",
+	HandlerType: (*SSHServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "SSHUploadPack",
+			Handler:       _SSH_SSHUploadPack_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "SSHReceivePack",
+			Handler:       _SSH_SSHReceivePack_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "deprecated-services.proto",
+}
+
+func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor2) }
+
+var fileDescriptor2 = []byte{
+	// 534 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40,
+	0x10, 0x80, 0x31, 0x41, 0x91, 0x32, 0xa1, 0x0d, 0x6c, 0x85, 0x68, 0x0c, 0x4d, 0xda, 0x0a, 0x24,
+	0x5e, 0x88, 0xaa, 0x70, 0x82, 0x42, 0x00, 0x17, 0xaa, 0x2a, 0xb2, 0x13, 0x7e, 0x24, 0x24, 0xb4,
+	0x38, 0xb3, 0x8d, 0x85, 0xe3, 0x0d, 0xde, 0x6d, 0xa5, 0x9e, 0x85, 0x03, 0xf0, 0xca, 0x49, 0x78,
+	0xe5, 0x3a, 0xc8, 0x3f, 0x13, 0xaf, 0x13, 0xbb, 0x3c, 0xf4, 0x6d, 0x33, 0xdf, 0xcc, 0xb7, 0x93,
+	0xf1, 0xd8, 0xd0, 0x9d, 0xe1, 0x32, 0x46, 0x9f, 0x6b, 0x9c, 0x3d, 0x57, 0x18, 0x5f, 0x06, 0x3e,
+	0xaa, 0xc1, 0x32, 0x96, 0x5a, 0xb2, 0xe6, 0x79, 0xa0, 0x79, 0x78, 0x65, 0xdf, 0xf5, 0xe5, 0x62,
+	0x11, 0xe8, 0x2c, 0x6a, 0xc3, 0x2c, 0x10, 0x22, 0x3f, 0xef, 0x44, 0x52, 0x07, 0x22, 0xf0, 0xb9,
+	0x0e, 0x64, 0x94, 0x97, 0xd9, 0xad, 0x18, 0x89, 0x77, 0xd4, 0x82, 0xc7, 0x7a, 0xae, 0xf5, 0x92,
+	0x98, 0x52, 0xf3, 0xec, 0x38, 0xfc, 0x65, 0x41, 0xf3, 0x55, 0x2a, 0x66, 0x1f, 0xe1, 0x5e, 0x76,
+	0x3a, 0x51, 0xc7, 0x91, 0x8f, 0x4a, 0xcb, 0x98, 0xf5, 0x07, 0xd9, 0xed, 0x83, 0x75, 0xe2, 0xe2,
+	0x8f, 0x0b, 0x54, 0xda, 0xde, 0xaf, 0x4f, 0x50, 0x4b, 0x19, 0x29, 0x3c, 0xbc, 0xc5, 0x46, 0xd0,
+	0x9a, 0xc4, 0x88, 0xaf, 0x23, 0x1d, 0x5f, 0xb1, 0x5d, 0x2a, 0x58, 0x85, 0x48, 0xd5, 0xad, 0x20,
+	0xe4, 0x38, 0xb2, 0x86, 0x3f, 0x2d, 0xb8, 0x33, 0x0a, 0x84, 0x60, 0x6f, 0x01, 0xb2, 0xcb, 0xd2,
+	0x5f, 0xdd, 0x72, 0x03, 0x49, 0x8c, 0x84, 0x76, 0x15, 0x2a, 0x8c, 0xec, 0x1d, 0xb4, 0x73, 0x82,
+	0xa1, 0xe6, 0x6c, 0x3d, 0x3d, 0x09, 0x92, 0xea, 0x51, 0x25, 0x33, 0xba, 0xfb, 0x0c, 0x5b, 0x67,
+	0xe6, 0x53, 0x60, 0x0e, 0xb4, 0xc7, 0x52, 0x69, 0x17, 0x7d, 0x0c, 0x2e, 0xb1, 0x90, 0x1b, 0xc1,
+	0x0d, 0x79, 0x89, 0x91, 0x7c, 0xf8, 0xa7, 0x01, 0x0d, 0x17, 0x05, 0x13, 0xf0, 0xe0, 0x4d, 0x10,
+	0xcd, 0x46, 0x28, 0xf8, 0x45, 0xa8, 0x5f, 0xc6, 0x3c, 0xf2, 0xe7, 0x67, 0x7c, 0x81, 0xec, 0x09,
+	0xd5, 0x57, 0x62, 0xba, 0xe5, 0xe9, 0x7f, 0xb2, 0x56, 0x8f, 0xeb, 0x2b, 0xb0, 0x24, 0xe5, 0x38,
+	0x0c, 0x0b, 0xac, 0xd8, 0x81, 0x59, 0x5e, 0x66, 0x74, 0xc3, 0xe1, 0x75, 0x29, 0xc6, 0xdc, 0x3f,
+	0x40, 0x27, 0xcf, 0x98, 0xf0, 0xf3, 0xcc, 0xde, 0x5b, 0x2b, 0x25, 0x40, 0xea, 0x7e, 0x2d, 0x37,
+	0xbc, 0x0e, 0xb4, 0x13, 0xec, 0xa2, 0x48, 0xc7, 0x62, 0x9b, 0x35, 0x79, 0x70, 0x63, 0xe4, 0x25,
+	0xb6, 0x1a, 0xc1, 0x17, 0xb8, 0x9f, 0x80, 0x53, 0xe9, 0xf3, 0xfc, 0x5f, 0xa0, 0x62, 0xfb, 0x66,
+	0x4d, 0x09, 0x91, 0xf5, 0xe0, 0x9a, 0x0c, 0x63, 0x57, 0xfe, 0xde, 0x86, 0x96, 0x97, 0xbc, 0x92,
+	0xce, 0x64, 0x32, 0x66, 0xef, 0x81, 0x9d, 0x44, 0x42, 0xba, 0x28, 0xd4, 0x74, 0x19, 0x4a, 0x3e,
+	0x1b, 0x73, 0xff, 0x3b, 0x7b, 0x48, 0x2a, 0x62, 0x74, 0xc7, 0xee, 0x26, 0x30, 0x46, 0x70, 0x0a,
+	0x3b, 0x45, 0x3c, 0x5d, 0xa4, 0x9b, 0xd8, 0xa6, 0xb0, 0x9d, 0xac, 0xa4, 0xd1, 0xd6, 0x9e, 0xb9,
+	0xaa, 0x45, 0x9c, 0x74, 0xbd, 0x3a, 0x4c, 0xd2, 0x67, 0xd6, 0x91, 0xc5, 0x3e, 0x41, 0xc7, 0xd8,
+	0xf4, 0xd4, 0xdb, 0xab, 0x78, 0x05, 0x4c, 0x71, 0xbf, 0x96, 0x9b, 0xe6, 0xe1, 0x6f, 0x0b, 0x1a,
+	0x9e, 0xe7, 0x30, 0x17, 0xb6, 0x3c, 0xcf, 0x31, 0xfa, 0x7e, 0x4c, 0xf5, 0xa5, 0x30, 0xd9, 0xf7,
+	0x6a, 0x68, 0xa9, 0xeb, 0x29, 0x6c, 0x7b, 0x9e, 0x63, 0x36, 0x6d, 0x96, 0x55, 0xf4, 0xdc, 0xab,
+	0xc3, 0xa6, 0xf6, 0x5b, 0x33, 0xfd, 0x0e, 0xbf, 0xf8, 0x17, 0x00, 0x00, 0xff, 0xff, 0x79, 0x83,
+	0xb6, 0xb0, 0x02, 0x06, 0x00, 0x00,
+}

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

@@ -28,7 +28,7 @@ type CommitDiffRequest struct {
 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 (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
 
 func (m *CommitDiffRequest) GetRepository() *Repository {
 	if m != nil {
@@ -82,7 +82,7 @@ type CommitDiffResponse struct {
 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 (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
 
 func (m *CommitDiffResponse) GetFromPath() []byte {
 	if m != nil {
@@ -157,7 +157,7 @@ type CommitDeltaRequest struct {
 func (m *CommitDeltaRequest) Reset()                    { *m = CommitDeltaRequest{} }
 func (m *CommitDeltaRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitDeltaRequest) ProtoMessage()               {}
-func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
+func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
 
 func (m *CommitDeltaRequest) GetRepository() *Repository {
 	if m != nil {
@@ -200,7 +200,7 @@ type CommitDelta struct {
 func (m *CommitDelta) Reset()                    { *m = CommitDelta{} }
 func (m *CommitDelta) String() string            { return proto.CompactTextString(m) }
 func (*CommitDelta) ProtoMessage()               {}
-func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
+func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
 
 func (m *CommitDelta) GetFromPath() []byte {
 	if m != nil {
@@ -251,7 +251,7 @@ type CommitDeltaResponse struct {
 func (m *CommitDeltaResponse) Reset()                    { *m = CommitDeltaResponse{} }
 func (m *CommitDeltaResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitDeltaResponse) ProtoMessage()               {}
-func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
+func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{4} }
 
 func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta {
 	if m != nil {
@@ -276,29 +276,29 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Diff service
+// Client API for DiffService service
 
-type DiffClient interface {
+type DiffServiceClient interface {
 	// Returns stream of CommitDiffResponse with patches chunked over messages
-	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
+	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error)
 	// Return a stream so we can divide the response in chunks of deltas
-	CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error)
+	CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error)
 }
 
-type diffClient struct {
+type diffServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewDiffClient(cc *grpc.ClientConn) DiffClient {
-	return &diffClient{cc}
+func NewDiffServiceClient(cc *grpc.ClientConn) DiffServiceClient {
+	return &diffServiceClient{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...)
+func (c *diffServiceClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_DiffService_serviceDesc.Streams[0], c.cc, "/gitaly.DiffService/CommitDiff", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &diffCommitDiffClient{stream}
+	x := &diffServiceCommitDiffClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -308,16 +308,16 @@ func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts
 	return x, nil
 }
 
-type Diff_CommitDiffClient interface {
+type DiffService_CommitDiffClient interface {
 	Recv() (*CommitDiffResponse, error)
 	grpc.ClientStream
 }
 
-type diffCommitDiffClient struct {
+type diffServiceCommitDiffClient struct {
 	grpc.ClientStream
 }
 
-func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) {
+func (x *diffServiceCommitDiffClient) Recv() (*CommitDiffResponse, error) {
 	m := new(CommitDiffResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -325,12 +325,12 @@ func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) {
 	return m, nil
 }
 
-func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[1], c.cc, "/gitaly.Diff/CommitDelta", opts...)
+func (c *diffServiceClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_DiffService_serviceDesc.Streams[1], c.cc, "/gitaly.DiffService/CommitDelta", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &diffCommitDeltaClient{stream}
+	x := &diffServiceCommitDeltaClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -340,16 +340,16 @@ func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, op
 	return x, nil
 }
 
-type Diff_CommitDeltaClient interface {
+type DiffService_CommitDeltaClient interface {
 	Recv() (*CommitDeltaResponse, error)
 	grpc.ClientStream
 }
 
-type diffCommitDeltaClient struct {
+type diffServiceCommitDeltaClient struct {
 	grpc.ClientStream
 }
 
-func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
+func (x *diffServiceCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
 	m := new(CommitDeltaResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -357,112 +357,113 @@ func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
 	return m, nil
 }
 
-// Server API for Diff service
+// Server API for DiffService service
 
-type DiffServer interface {
+type DiffServiceServer interface {
 	// Returns stream of CommitDiffResponse with patches chunked over messages
-	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
+	CommitDiff(*CommitDiffRequest, DiffService_CommitDiffServer) error
 	// Return a stream so we can divide the response in chunks of deltas
-	CommitDelta(*CommitDeltaRequest, Diff_CommitDeltaServer) error
+	CommitDelta(*CommitDeltaRequest, DiffService_CommitDeltaServer) error
 }
 
-func RegisterDiffServer(s *grpc.Server, srv DiffServer) {
-	s.RegisterService(&_Diff_serviceDesc, srv)
+func RegisterDiffServiceServer(s *grpc.Server, srv DiffServiceServer) {
+	s.RegisterService(&_DiffService_serviceDesc, srv)
 }
 
-func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _DiffService_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})
+	return srv.(DiffServiceServer).CommitDiff(m, &diffServiceCommitDiffServer{stream})
 }
 
-type Diff_CommitDiffServer interface {
+type DiffService_CommitDiffServer interface {
 	Send(*CommitDiffResponse) error
 	grpc.ServerStream
 }
 
-type diffCommitDiffServer struct {
+type diffServiceCommitDiffServer struct {
 	grpc.ServerStream
 }
 
-func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error {
+func (x *diffServiceCommitDiffServer) Send(m *CommitDiffResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func _Diff_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _DiffService_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(CommitDeltaRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(DiffServer).CommitDelta(m, &diffCommitDeltaServer{stream})
+	return srv.(DiffServiceServer).CommitDelta(m, &diffServiceCommitDeltaServer{stream})
 }
 
-type Diff_CommitDeltaServer interface {
+type DiffService_CommitDeltaServer interface {
 	Send(*CommitDeltaResponse) error
 	grpc.ServerStream
 }
 
-type diffCommitDeltaServer struct {
+type diffServiceCommitDeltaServer struct {
 	grpc.ServerStream
 }
 
-func (x *diffCommitDeltaServer) Send(m *CommitDeltaResponse) error {
+func (x *diffServiceCommitDeltaServer) Send(m *CommitDeltaResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-var _Diff_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Diff",
-	HandlerType: (*DiffServer)(nil),
+var _DiffService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.DiffService",
+	HandlerType: (*DiffServiceServer)(nil),
 	Methods:     []grpc.MethodDesc{},
 	Streams: []grpc.StreamDesc{
 		{
 			StreamName:    "CommitDiff",
-			Handler:       _Diff_CommitDiff_Handler,
+			Handler:       _DiffService_CommitDiff_Handler,
 			ServerStreams: true,
 		},
 		{
 			StreamName:    "CommitDelta",
-			Handler:       _Diff_CommitDelta_Handler,
+			Handler:       _DiffService_CommitDelta_Handler,
 			ServerStreams: true,
 		},
 	},
 	Metadata: "diff.proto",
 }
 
-func init() { proto.RegisterFile("diff.proto", fileDescriptor1) }
-
-var fileDescriptor1 = []byte{
-	// 473 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0x4d, 0x8a, 0xdb, 0x30,
-	0x14, 0xc7, 0xab, 0xc4, 0x76, 0x9c, 0x17, 0xf7, 0x4b, 0x29, 0x53, 0x4d, 0x66, 0x63, 0x4c, 0x29,
-	0x86, 0x42, 0x28, 0xe9, 0xa6, 0xeb, 0xce, 0x40, 0xc9, 0x40, 0xe9, 0xe0, 0x4d, 0x97, 0x46, 0x13,
-	0xc9, 0xb1, 0xc0, 0xb1, 0x5c, 0x59, 0xc5, 0xe4, 0x1e, 0xdd, 0xf5, 0x00, 0xdd, 0xf4, 0x5a, 0xbd,
-	0x47, 0x91, 0x94, 0x71, 0x3c, 0x25, 0x07, 0xc8, 0x52, 0xff, 0xdf, 0x5f, 0x4f, 0xef, 0xcb, 0x06,
-	0x60, 0xa2, 0x28, 0x96, 0x8d, 0x92, 0x5a, 0xe2, 0x60, 0x2b, 0x34, 0xad, 0xf6, 0x8b, 0xa8, 0x2d,
-	0xa9, 0xe2, 0xcc, 0xa9, 0xc9, 0x5f, 0x04, 0x2f, 0xaf, 0xe5, 0x6e, 0x27, 0xf4, 0x8d, 0x28, 0x8a,
-	0x8c, 0x7f, 0xff, 0xc1, 0x5b, 0x8d, 0x57, 0x00, 0x8a, 0x37, 0xb2, 0x15, 0x5a, 0xaa, 0x3d, 0x41,
-	0x31, 0x4a, 0x67, 0x2b, 0xbc, 0x74, 0x01, 0x96, 0x59, 0x4f, 0xb2, 0x81, 0x0b, 0xbf, 0x81, 0x67,
-	0x15, 0x2f, 0x74, 0xbe, 0xb1, 0xd1, 0x72, 0xc1, 0xc8, 0x28, 0x46, 0xe9, 0x34, 0x8b, 0x8c, 0xea,
-	0x9e, 0x58, 0x33, 0xfc, 0x16, 0x9e, 0x2b, 0xb1, 0x2d, 0x87, 0xb6, 0xb1, 0xb5, 0x3d, 0xb5, 0x72,
-	0xef, 0xfb, 0x08, 0x44, 0x6c, 0x6b, 0xa9, 0x78, 0xde, 0x95, 0x42, 0xf3, 0xb6, 0xa1, 0x1b, 0x9e,
-	0x6f, 0x4a, 0x5a, 0x6f, 0x39, 0xf1, 0x62, 0x94, 0x86, 0xd9, 0x85, 0xe3, 0xdf, 0x7a, 0x7c, 0x6d,
-	0x29, 0x7e, 0x05, 0x7e, 0x43, 0x75, 0xd9, 0x12, 0x3f, 0x1e, 0xa7, 0x51, 0xe6, 0x0e, 0xc9, 0xcf,
-	0x11, 0xe0, 0x61, 0x9d, 0x6d, 0x23, 0xeb, 0x96, 0xe3, 0x2b, 0x98, 0x16, 0x4a, 0xee, 0x72, 0x63,
-	0xb2, 0x75, 0x46, 0x59, 0x68, 0x84, 0x3b, 0xaa, 0x4b, 0xfc, 0x1a, 0x26, 0x5a, 0x3a, 0x34, 0xb2,
-	0x28, 0xd0, 0xf2, 0x01, 0xd8, 0x5b, 0x7d, 0xf2, 0x81, 0x39, 0xae, 0x19, 0x9e, 0x83, 0xaf, 0xa5,
-	0x91, 0x3d, 0x2b, 0x7b, 0x5a, 0xae, 0x19, 0xbe, 0x84, 0x50, 0x56, 0x2c, 0xdf, 0x49, 0xc6, 0x89,
-	0x1f, 0xa3, 0xd4, 0xcf, 0x26, 0xb2, 0x62, 0x5f, 0x24, 0xe3, 0x06, 0xd5, 0xbc, 0x73, 0x28, 0x70,
-	0xa8, 0xe6, 0x9d, 0x45, 0x17, 0x10, 0xdc, 0x8b, 0x9a, 0xaa, 0x3d, 0x99, 0xd8, 0x72, 0x0f, 0x27,
-	0xd3, 0x66, 0x45, 0x3b, 0x93, 0xd5, 0xa6, 0xcc, 0x19, 0xd5, 0x94, 0x4c, 0x6d, 0x6e, 0x91, 0xa2,
-	0xdd, 0x9d, 0x11, 0x6f, 0xa8, 0xa6, 0x38, 0x86, 0x88, 0xd7, 0x2c, 0x97, 0x85, 0x33, 0x12, 0xb0,
-	0x31, 0x80, 0xd7, 0xec, 0x6b, 0x61, 0x5d, 0xb7, 0x5e, 0x18, 0xbe, 0x98, 0x26, 0x7f, 0x50, 0xdf,
-	0x16, 0x5e, 0x69, 0x7a, 0x3e, 0xf3, 0xef, 0xa7, 0xe8, 0x0d, 0xa7, 0xf8, 0x1b, 0xc1, 0x6c, 0x90,
-	0xee, 0xf9, 0x8e, 0x2f, 0xf9, 0x04, 0xf3, 0x47, 0x7d, 0x3d, 0xec, 0xdb, 0x3b, 0x08, 0x98, 0x11,
-	0x5a, 0x82, 0xe2, 0x71, 0x3a, 0x5b, 0xcd, 0x1f, 0x9a, 0x3a, 0x34, 0x1f, 0x2c, 0xab, 0x5f, 0x08,
-	0x3c, 0xb3, 0xad, 0xf8, 0x33, 0xc0, 0x71, 0x77, 0xf1, 0xe5, 0x7f, 0x77, 0x8e, 0xdf, 0xed, 0x62,
-	0x71, 0x0a, 0xb9, 0xa7, 0x93, 0x27, 0xef, 0x11, 0xbe, 0x7d, 0xdc, 0xbe, 0xc5, 0xa9, 0xd7, 0x0f,
-	0xa1, 0xae, 0x4e, 0xb2, 0x63, 0xac, 0xfb, 0xc0, 0xfe, 0x40, 0x3e, 0xfc, 0x0b, 0x00, 0x00, 0xff,
-	0xff, 0x0c, 0x62, 0x85, 0xba, 0x64, 0x04, 0x00, 0x00,
+func init() { proto.RegisterFile("diff.proto", fileDescriptor3) }
+
+var fileDescriptor3 = []byte{
+	// 481 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0x4f, 0x8e, 0xd3, 0x30,
+	0x14, 0xc6, 0x71, 0xdb, 0xa4, 0xe9, 0x6b, 0xf8, 0xe7, 0xa2, 0xc1, 0xd3, 0xd9, 0x44, 0x11, 0x42,
+	0x91, 0x90, 0x2a, 0x54, 0x36, 0xac, 0x99, 0x91, 0x50, 0x47, 0x42, 0x8c, 0xc2, 0x82, 0x65, 0xe4,
+	0x89, 0x9d, 0xc6, 0x52, 0x1a, 0x07, 0xc7, 0x10, 0xf5, 0x1e, 0x9c, 0x80, 0x0d, 0x1b, 0xae, 0xc5,
+	0x3d, 0x90, 0xed, 0x4e, 0x9a, 0x41, 0x3d, 0xc0, 0x2c, 0xfd, 0xfd, 0x3e, 0xbf, 0x7e, 0x7e, 0xef,
+	0x35, 0x00, 0x4c, 0x14, 0xc5, 0xaa, 0x51, 0x52, 0x4b, 0xec, 0x6f, 0x85, 0xa6, 0xd5, 0x7e, 0x19,
+	0xb6, 0x25, 0x55, 0x9c, 0x39, 0x35, 0xfe, 0x8b, 0xe0, 0xf9, 0xa5, 0xdc, 0xed, 0x84, 0xbe, 0x12,
+	0x45, 0x91, 0xf2, 0x6f, 0xdf, 0x79, 0xab, 0xf1, 0x1a, 0x40, 0xf1, 0x46, 0xb6, 0x42, 0x4b, 0xb5,
+	0x27, 0x28, 0x42, 0xc9, 0x7c, 0x8d, 0x57, 0xae, 0xc0, 0x2a, 0xed, 0x49, 0x3a, 0x70, 0xe1, 0x57,
+	0xf0, 0xa4, 0xe2, 0x85, 0xce, 0x72, 0x5b, 0x2d, 0x13, 0x8c, 0x8c, 0x22, 0x94, 0xcc, 0xd2, 0xd0,
+	0xa8, 0xee, 0x27, 0x36, 0x0c, 0xbf, 0x86, 0xa7, 0x4a, 0x6c, 0xcb, 0xa1, 0x6d, 0x6c, 0x6d, 0x8f,
+	0xad, 0xdc, 0xfb, 0xde, 0x03, 0x11, 0xdb, 0x5a, 0x2a, 0x9e, 0x75, 0xa5, 0xd0, 0xbc, 0x6d, 0x68,
+	0xce, 0xb3, 0xbc, 0xa4, 0xf5, 0x96, 0x93, 0x49, 0x84, 0x92, 0x20, 0x3d, 0x73, 0xfc, 0x6b, 0x8f,
+	0x2f, 0x2d, 0xc5, 0x2f, 0xc0, 0x6b, 0xa8, 0x2e, 0x5b, 0xe2, 0x45, 0xe3, 0x24, 0x4c, 0xdd, 0x21,
+	0xfe, 0x39, 0x02, 0x3c, 0x7c, 0x67, 0xdb, 0xc8, 0xba, 0xe5, 0xf8, 0x02, 0x66, 0x85, 0x92, 0xbb,
+	0xcc, 0x98, 0xec, 0x3b, 0xc3, 0x34, 0x30, 0xc2, 0x0d, 0xd5, 0x25, 0x7e, 0x09, 0x53, 0x2d, 0x1d,
+	0x1a, 0x59, 0xe4, 0x6b, 0x79, 0x07, 0xec, 0xad, 0x3e, 0xbc, 0x6f, 0x8e, 0x1b, 0x86, 0x17, 0xe0,
+	0x69, 0x69, 0xe4, 0x89, 0x95, 0x27, 0x5a, 0x6e, 0x18, 0x3e, 0x87, 0x40, 0x56, 0x2c, 0xdb, 0x49,
+	0xc6, 0x89, 0x17, 0xa1, 0xc4, 0x4b, 0xa7, 0xb2, 0x62, 0x9f, 0x24, 0xe3, 0x06, 0xd5, 0xbc, 0x73,
+	0xc8, 0x77, 0xa8, 0xe6, 0x9d, 0x45, 0x67, 0xe0, 0xdf, 0x8a, 0x9a, 0xaa, 0x3d, 0x99, 0xda, 0xe7,
+	0x1e, 0x4e, 0xa6, 0xcd, 0x8a, 0x76, 0x26, 0x55, 0x5e, 0x66, 0x8c, 0x6a, 0x4a, 0x66, 0x36, 0x5b,
+	0xa8, 0x68, 0x77, 0x63, 0xc4, 0x2b, 0xaa, 0x29, 0x8e, 0x20, 0xe4, 0x35, 0xcb, 0x64, 0xe1, 0x8c,
+	0x04, 0x6c, 0x0d, 0xe0, 0x35, 0xfb, 0x5c, 0x58, 0xd7, 0xf5, 0x24, 0x08, 0x9e, 0xcd, 0xe2, 0x3f,
+	0xa8, 0x6f, 0x0b, 0xaf, 0x34, 0x7d, 0x38, 0xf3, 0xef, 0xa7, 0x38, 0x19, 0x4e, 0xf1, 0x37, 0x82,
+	0xf9, 0x20, 0xee, 0xc3, 0x1d, 0x5f, 0xfc, 0x01, 0x16, 0xf7, 0xfa, 0x7a, 0xd8, 0xb7, 0x37, 0xe0,
+	0x33, 0x23, 0xb4, 0x04, 0x45, 0xe3, 0x64, 0xbe, 0x5e, 0xdc, 0x35, 0x75, 0x68, 0x3e, 0x58, 0xd6,
+	0xbf, 0x10, 0xcc, 0xcd, 0xb6, 0x7e, 0xe1, 0xea, 0x87, 0xc8, 0x39, 0xfe, 0x08, 0x70, 0x5c, 0x61,
+	0x7c, 0xfe, 0xdf, 0xd5, 0xe3, 0xdf, 0x77, 0xb9, 0x3c, 0x85, 0x5c, 0x82, 0xf8, 0xd1, 0x5b, 0x84,
+	0xaf, 0xef, 0x77, 0x71, 0x79, 0x2a, 0xc4, 0xa1, 0xd4, 0xc5, 0x49, 0x76, 0xac, 0x75, 0xeb, 0xdb,
+	0xef, 0xc8, 0xbb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4b, 0xf5, 0xb7, 0x6e, 0x6b, 0x04, 0x00,
+	0x00,
 }

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

@@ -24,7 +24,7 @@ type PostReceiveRequest struct {
 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 (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
 
 func (m *PostReceiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -39,7 +39,7 @@ 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 (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
 
 func init() {
 	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
@@ -54,74 +54,74 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Notifications service
+// Client API for NotificationService service
 
-type NotificationsClient interface {
+type NotificationServiceClient interface {
 	PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error)
 }
 
-type notificationsClient struct {
+type notificationServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient {
-	return &notificationsClient{cc}
+func NewNotificationServiceClient(cc *grpc.ClientConn) NotificationServiceClient {
+	return &notificationServiceClient{cc}
 }
 
-func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
+func (c *notificationServiceClient) 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...)
+	err := grpc.Invoke(ctx, "/gitaly.NotificationService/PostReceive", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-// Server API for Notifications service
+// Server API for NotificationService service
 
-type NotificationsServer interface {
+type NotificationServiceServer interface {
 	PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error)
 }
 
-func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) {
-	s.RegisterService(&_Notifications_serviceDesc, srv)
+func RegisterNotificationServiceServer(s *grpc.Server, srv NotificationServiceServer) {
+	s.RegisterService(&_NotificationService_serviceDesc, srv)
 }
 
-func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _NotificationService_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)
+		return srv.(NotificationServiceServer).PostReceive(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/gitaly.Notifications/PostReceive",
+		FullMethod: "/gitaly.NotificationService/PostReceive",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest))
+		return srv.(NotificationServiceServer).PostReceive(ctx, req.(*PostReceiveRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-var _Notifications_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Notifications",
-	HandlerType: (*NotificationsServer)(nil),
+var _NotificationService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.NotificationService",
+	HandlerType: (*NotificationServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "PostReceive",
-			Handler:    _Notifications_PostReceive_Handler,
+			Handler:    _NotificationService_PostReceive_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "notifications.proto",
 }
 
-func init() { proto.RegisterFile("notifications.proto", fileDescriptor2) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor4) }
 
-var fileDescriptor2 = []byte{
-	// 163 bytes of a gzipped FileDescriptorProto
+var fileDescriptor4 = []byte{
+	// 170 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,
@@ -129,8 +129,8 @@ var fileDescriptor2 = []byte{
 	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,
+	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x9e, 0x4b, 0xd8, 0x0f, 0xc9, 0x35, 0xc1, 0xa9, 0x45, 0x65, 0x99,
+	0xc9, 0xa9, 0x42, 0x1e, 0x5c, 0xdc, 0x48, 0xaa, 0x85, 0xa4, 0x60, 0x86, 0x63, 0x3a, 0x46, 0x4a,
+	0x1a, 0xab, 0x1c, 0xc4, 0x78, 0x25, 0x86, 0x24, 0x36, 0xb0, 0x47, 0x8c, 0x01, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x98, 0xea, 0xcc, 0xff, 0xf5, 0x00, 0x00, 0x00,
 }

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

@@ -41,7 +41,7 @@ func (x FindLocalBranchesRequest_SortBy) String() string {
 	return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
 }
 func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor3, []int{8, 0}
+	return fileDescriptor5, []int{8, 0}
 }
 
 type FindDefaultBranchNameRequest struct {
@@ -51,7 +51,7 @@ type FindDefaultBranchNameRequest struct {
 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 (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
 
 func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -67,7 +67,7 @@ type FindDefaultBranchNameResponse struct {
 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 (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
 
 func (m *FindDefaultBranchNameResponse) GetName() []byte {
 	if m != nil {
@@ -83,7 +83,7 @@ type FindAllBranchNamesRequest struct {
 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 (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
 
 func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -99,7 +99,7 @@ type FindAllBranchNamesResponse struct {
 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 (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
 
 func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -115,7 +115,7 @@ type FindAllTagNamesRequest struct {
 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 (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
 
 func (m *FindAllTagNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -131,7 +131,7 @@ type FindAllTagNamesResponse struct {
 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 (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
 
 func (m *FindAllTagNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -151,7 +151,7 @@ type FindRefNameRequest struct {
 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 (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
 
 func (m *FindRefNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -182,7 +182,7 @@ type FindRefNameResponse struct {
 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 (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
 
 func (m *FindRefNameResponse) GetName() []byte {
 	if m != nil {
@@ -199,7 +199,7 @@ type FindLocalBranchesRequest struct {
 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 (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{8} }
 
 func (m *FindLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -222,7 +222,7 @@ type FindLocalBranchesResponse struct {
 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 (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{9} }
 
 func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse {
 	if m != nil {
@@ -242,7 +242,7 @@ type FindLocalBranchResponse struct {
 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 (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{10} }
 
 func (m *FindLocalBranchResponse) GetName() []byte {
 	if m != nil {
@@ -288,7 +288,7 @@ type FindLocalBranchCommitAuthor struct {
 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 (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{11} }
 
 func (m *FindLocalBranchCommitAuthor) GetName() []byte {
 	if m != nil {
@@ -335,41 +335,41 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Ref service
+// Client API for RefService service
 
-type RefClient interface {
+type RefServiceClient interface {
 	FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error)
-	FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error)
-	FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error)
+	FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (RefService_FindAllBranchNamesClient, error)
+	FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (RefService_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)
+	FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (RefService_FindLocalBranchesClient, error)
 }
 
-type refClient struct {
+type refServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewRefClient(cc *grpc.ClientConn) RefClient {
-	return &refClient{cc}
+func NewRefServiceClient(cc *grpc.ClientConn) RefServiceClient {
+	return &refServiceClient{cc}
 }
 
-func (c *refClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) {
+func (c *refServiceClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) {
 	out := new(FindDefaultBranchNameResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Ref/FindDefaultBranchName", in, out, c.cc, opts...)
+	err := grpc.Invoke(ctx, "/gitaly.RefService/FindDefaultBranchName", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[0], c.cc, "/gitaly.Ref/FindAllBranchNames", opts...)
+func (c *refServiceClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (RefService_FindAllBranchNamesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[0], c.cc, "/gitaly.RefService/FindAllBranchNames", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &refFindAllBranchNamesClient{stream}
+	x := &refServiceFindAllBranchNamesClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -379,16 +379,16 @@ func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNam
 	return x, nil
 }
 
-type Ref_FindAllBranchNamesClient interface {
+type RefService_FindAllBranchNamesClient interface {
 	Recv() (*FindAllBranchNamesResponse, error)
 	grpc.ClientStream
 }
 
-type refFindAllBranchNamesClient struct {
+type refServiceFindAllBranchNamesClient struct {
 	grpc.ClientStream
 }
 
-func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) {
+func (x *refServiceFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) {
 	m := new(FindAllBranchNamesResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -396,12 +396,12 @@ func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error
 	return m, nil
 }
 
-func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[1], c.cc, "/gitaly.Ref/FindAllTagNames", opts...)
+func (c *refServiceClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (RefService_FindAllTagNamesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[1], c.cc, "/gitaly.RefService/FindAllTagNames", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &refFindAllTagNamesClient{stream}
+	x := &refServiceFindAllTagNamesClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -411,16 +411,16 @@ func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequ
 	return x, nil
 }
 
-type Ref_FindAllTagNamesClient interface {
+type RefService_FindAllTagNamesClient interface {
 	Recv() (*FindAllTagNamesResponse, error)
 	grpc.ClientStream
 }
 
-type refFindAllTagNamesClient struct {
+type refServiceFindAllTagNamesClient struct {
 	grpc.ClientStream
 }
 
-func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) {
+func (x *refServiceFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) {
 	m := new(FindAllTagNamesResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -428,21 +428,21 @@ func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) {
 	return m, nil
 }
 
-func (c *refClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) {
+func (c *refServiceClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) {
 	out := new(FindRefNameResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Ref/FindRefName", in, out, c.cc, opts...)
+	err := grpc.Invoke(ctx, "/gitaly.RefService/FindRefName", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
 	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...)
+func (c *refServiceClient) FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (RefService_FindLocalBranchesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[2], c.cc, "/gitaly.RefService/FindLocalBranches", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &refFindLocalBranchesClient{stream}
+	x := &refServiceFindLocalBranchesClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -452,16 +452,16 @@ func (c *refClient) FindLocalBranches(ctx context.Context, in *FindLocalBranches
 	return x, nil
 }
 
-type Ref_FindLocalBranchesClient interface {
+type RefService_FindLocalBranchesClient interface {
 	Recv() (*FindLocalBranchesResponse, error)
 	grpc.ClientStream
 }
 
-type refFindLocalBranchesClient struct {
+type refServiceFindLocalBranchesClient struct {
 	grpc.ClientStream
 }
 
-func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) {
+func (x *refServiceFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) {
 	m := new(FindLocalBranchesResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -469,195 +469,195 @@ func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error)
 	return m, nil
 }
 
-// Server API for Ref service
+// Server API for RefService service
 
-type RefServer interface {
+type RefServiceServer interface {
 	FindDefaultBranchName(context.Context, *FindDefaultBranchNameRequest) (*FindDefaultBranchNameResponse, error)
-	FindAllBranchNames(*FindAllBranchNamesRequest, Ref_FindAllBranchNamesServer) error
-	FindAllTagNames(*FindAllTagNamesRequest, Ref_FindAllTagNamesServer) error
+	FindAllBranchNames(*FindAllBranchNamesRequest, RefService_FindAllBranchNamesServer) error
+	FindAllTagNames(*FindAllTagNamesRequest, RefService_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
+	FindLocalBranches(*FindLocalBranchesRequest, RefService_FindLocalBranchesServer) error
 }
 
-func RegisterRefServer(s *grpc.Server, srv RefServer) {
-	s.RegisterService(&_Ref_serviceDesc, srv)
+func RegisterRefServiceServer(s *grpc.Server, srv RefServiceServer) {
+	s.RegisterService(&_RefService_serviceDesc, srv)
 }
 
-func _Ref_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _RefService_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FindDefaultBranchNameRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(RefServer).FindDefaultBranchName(ctx, in)
+		return srv.(RefServiceServer).FindDefaultBranchName(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/gitaly.Ref/FindDefaultBranchName",
+		FullMethod: "/gitaly.RefService/FindDefaultBranchName",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RefServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest))
+		return srv.(RefServiceServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Ref_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _RefService_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(FindAllBranchNamesRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(RefServer).FindAllBranchNames(m, &refFindAllBranchNamesServer{stream})
+	return srv.(RefServiceServer).FindAllBranchNames(m, &refServiceFindAllBranchNamesServer{stream})
 }
 
-type Ref_FindAllBranchNamesServer interface {
+type RefService_FindAllBranchNamesServer interface {
 	Send(*FindAllBranchNamesResponse) error
 	grpc.ServerStream
 }
 
-type refFindAllBranchNamesServer struct {
+type refServiceFindAllBranchNamesServer struct {
 	grpc.ServerStream
 }
 
-func (x *refFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error {
+func (x *refServiceFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func _Ref_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _RefService_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(FindAllTagNamesRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(RefServer).FindAllTagNames(m, &refFindAllTagNamesServer{stream})
+	return srv.(RefServiceServer).FindAllTagNames(m, &refServiceFindAllTagNamesServer{stream})
 }
 
-type Ref_FindAllTagNamesServer interface {
+type RefService_FindAllTagNamesServer interface {
 	Send(*FindAllTagNamesResponse) error
 	grpc.ServerStream
 }
 
-type refFindAllTagNamesServer struct {
+type refServiceFindAllTagNamesServer struct {
 	grpc.ServerStream
 }
 
-func (x *refFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error {
+func (x *refServiceFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func _Ref_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _RefService_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FindRefNameRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(RefServer).FindRefName(ctx, in)
+		return srv.(RefServiceServer).FindRefName(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/gitaly.Ref/FindRefName",
+		FullMethod: "/gitaly.RefService/FindRefName",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RefServer).FindRefName(ctx, req.(*FindRefNameRequest))
+		return srv.(RefServiceServer).FindRefName(ctx, req.(*FindRefNameRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Ref_FindLocalBranches_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _RefService_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})
+	return srv.(RefServiceServer).FindLocalBranches(m, &refServiceFindLocalBranchesServer{stream})
 }
 
-type Ref_FindLocalBranchesServer interface {
+type RefService_FindLocalBranchesServer interface {
 	Send(*FindLocalBranchesResponse) error
 	grpc.ServerStream
 }
 
-type refFindLocalBranchesServer struct {
+type refServiceFindLocalBranchesServer struct {
 	grpc.ServerStream
 }
 
-func (x *refFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error {
+func (x *refServiceFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-var _Ref_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Ref",
-	HandlerType: (*RefServer)(nil),
+var _RefService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.RefService",
+	HandlerType: (*RefServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "FindDefaultBranchName",
-			Handler:    _Ref_FindDefaultBranchName_Handler,
+			Handler:    _RefService_FindDefaultBranchName_Handler,
 		},
 		{
 			MethodName: "FindRefName",
-			Handler:    _Ref_FindRefName_Handler,
+			Handler:    _RefService_FindRefName_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
 			StreamName:    "FindAllBranchNames",
-			Handler:       _Ref_FindAllBranchNames_Handler,
+			Handler:       _RefService_FindAllBranchNames_Handler,
 			ServerStreams: true,
 		},
 		{
 			StreamName:    "FindAllTagNames",
-			Handler:       _Ref_FindAllTagNames_Handler,
+			Handler:       _RefService_FindAllTagNames_Handler,
 			ServerStreams: true,
 		},
 		{
 			StreamName:    "FindLocalBranches",
-			Handler:       _Ref_FindLocalBranches_Handler,
+			Handler:       _RefService_FindLocalBranches_Handler,
 			ServerStreams: true,
 		},
 	},
 	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,
+func init() { proto.RegisterFile("ref.proto", fileDescriptor5) }
+
+var fileDescriptor5 = []byte{
+	// 620 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xc1, 0x6e, 0xd3, 0x40,
+	0x10, 0xad, 0xdb, 0x34, 0xb4, 0x13, 0xd3, 0x86, 0xa5, 0x14, 0xe3, 0x02, 0x4d, 0x0d, 0x15, 0xe5,
+	0xe2, 0x22, 0x57, 0x9c, 0xb8, 0x90, 0x26, 0x45, 0x45, 0x2a, 0x05, 0x6d, 0x02, 0xe2, 0x80, 0x14,
+	0x6d, 0x9c, 0x75, 0x62, 0x64, 0x67, 0xc3, 0x7a, 0x03, 0xe4, 0xc0, 0x17, 0xf0, 0x61, 0x7c, 0x01,
+	0xff, 0x83, 0xb2, 0x6b, 0xa7, 0x4e, 0x6a, 0xbb, 0x48, 0x39, 0x39, 0x33, 0xfb, 0xde, 0xcc, 0xec,
+	0xbc, 0xec, 0x83, 0x4d, 0x4e, 0x3d, 0x7b, 0xc4, 0x99, 0x60, 0xa8, 0xdc, 0xf7, 0x05, 0x09, 0x26,
+	0xa6, 0x1e, 0x0d, 0x08, 0xa7, 0x3d, 0x95, 0x35, 0xf7, 0xfb, 0x8c, 0xf5, 0x03, 0x7a, 0x2c, 0xa3,
+	0xee, 0xd8, 0x3b, 0x16, 0x7e, 0x48, 0x23, 0x41, 0xc2, 0x91, 0x02, 0x58, 0x18, 0x1e, 0xbe, 0xf1,
+	0x87, 0xbd, 0x26, 0xf5, 0xc8, 0x38, 0x10, 0xa7, 0x9c, 0x0c, 0xdd, 0xc1, 0x25, 0x09, 0x29, 0xa6,
+	0xdf, 0xc6, 0x34, 0x12, 0xc8, 0x01, 0xe0, 0x74, 0xc4, 0x22, 0x5f, 0x30, 0x3e, 0x31, 0xb4, 0x9a,
+	0x76, 0x54, 0x71, 0x90, 0xad, 0x7a, 0xd9, 0x78, 0x76, 0x82, 0x53, 0x28, 0xeb, 0x04, 0x1e, 0xe5,
+	0xd4, 0x8c, 0x46, 0x6c, 0x18, 0x51, 0x84, 0xa0, 0x34, 0x24, 0x21, 0x95, 0xe5, 0x74, 0x2c, 0x7f,
+	0x5b, 0xef, 0xe1, 0xc1, 0x94, 0x54, 0x0f, 0x82, 0x2b, 0x42, 0xb4, 0xcc, 0x14, 0x0e, 0x98, 0x59,
+	0x05, 0xe3, 0x11, 0x76, 0x60, 0x7d, 0xda, 0x36, 0x32, 0xb4, 0xda, 0xda, 0x91, 0x8e, 0x55, 0x60,
+	0x5d, 0xc0, 0x6e, 0xcc, 0x69, 0x93, 0xfe, 0xd2, 0x13, 0x1c, 0xc3, 0xfd, 0x6b, 0xd5, 0x0a, 0xdb,
+	0xff, 0x02, 0x34, 0x25, 0x60, 0xea, 0x2d, 0x29, 0x01, 0xda, 0x83, 0x4d, 0x97, 0x85, 0xa1, 0x2f,
+	0x3a, 0x7e, 0xcf, 0x58, 0xad, 0x69, 0x47, 0x9b, 0x78, 0x43, 0x25, 0xde, 0xf6, 0xd0, 0x2e, 0x94,
+	0x47, 0x9c, 0x7a, 0xfe, 0x4f, 0x63, 0x4d, 0x0a, 0x10, 0x47, 0xd6, 0x73, 0xb8, 0x3b, 0xd7, 0xbe,
+	0x40, 0xad, 0x3f, 0x1a, 0x18, 0x53, 0xec, 0x05, 0x73, 0x49, 0xbc, 0xdf, 0xa5, 0x76, 0x85, 0x5e,
+	0xc3, 0xad, 0x88, 0x71, 0xd1, 0xe9, 0x4e, 0xe4, 0xb8, 0x5b, 0xce, 0xb3, 0x84, 0x90, 0xd7, 0xc6,
+	0x6e, 0x31, 0x2e, 0x4e, 0x27, 0xb8, 0x1c, 0xc9, 0xaf, 0xf5, 0x12, 0xca, 0x2a, 0x83, 0x36, 0xa0,
+	0x74, 0x59, 0x7f, 0x77, 0x56, 0x5d, 0x41, 0xdb, 0x50, 0xf9, 0xf8, 0xa1, 0x59, 0x6f, 0x9f, 0x35,
+	0x3b, 0xf5, 0x56, 0xa3, 0xaa, 0xa1, 0x2a, 0xe8, 0x49, 0xa2, 0x79, 0xd6, 0x6a, 0x54, 0x57, 0xad,
+	0xcf, 0xea, 0x7f, 0xb7, 0xd0, 0x21, 0xbe, 0xfa, 0x2b, 0xd8, 0xe8, 0xc6, 0x39, 0xa9, 0x54, 0xc5,
+	0xd9, 0xcf, 0x19, 0x2b, 0xa1, 0xe0, 0x19, 0xc1, 0xfa, 0xbd, 0xaa, 0xf4, 0xcf, 0x40, 0x65, 0xed,
+	0xb4, 0x58, 0xb3, 0x43, 0xd8, 0x8a, 0x0f, 0xa3, 0x71, 0xf7, 0x2b, 0x75, 0x45, 0xac, 0xdd, 0x6d,
+	0x95, 0x6d, 0xa9, 0x24, 0x3a, 0x87, 0x38, 0xd1, 0x21, 0x63, 0x31, 0x60, 0xdc, 0x28, 0xc9, 0xed,
+	0x3f, 0xc9, 0x99, 0xba, 0x21, 0xb1, 0x75, 0x09, 0xc5, 0xba, 0x9b, 0x8a, 0xd0, 0x25, 0x54, 0xe3,
+	0x4a, 0xea, 0x23, 0x28, 0x37, 0xd6, 0xff, 0xbf, 0xd8, 0xb6, 0x62, 0x35, 0x12, 0xae, 0xf5, 0x03,
+	0xf6, 0x0a, 0xf0, 0x99, 0x0b, 0xd9, 0x81, 0x75, 0x1a, 0x12, 0x3f, 0x90, 0xcb, 0xd0, 0xb1, 0x0a,
+	0x90, 0x0d, 0xa5, 0x1e, 0x11, 0x54, 0xde, 0xbf, 0xe2, 0x98, 0xb6, 0x72, 0x38, 0x3b, 0x71, 0x38,
+	0xbb, 0x9d, 0x38, 0x1c, 0x96, 0x38, 0xe7, 0xef, 0x1a, 0x00, 0xa6, 0x5e, 0x8b, 0xf2, 0xef, 0xbe,
+	0x4b, 0x91, 0x07, 0xf7, 0x32, 0xcd, 0x09, 0x3d, 0x4d, 0x5f, 0x2b, 0xcf, 0x0f, 0xcd, 0xc3, 0x1b,
+	0x50, 0x4a, 0x5f, 0x6b, 0x05, 0x75, 0xd4, 0x5b, 0x9e, 0xb7, 0x1f, 0x74, 0x90, 0xa6, 0x67, 0x7a,
+	0x9d, 0x69, 0x15, 0x41, 0x92, 0xf2, 0x2f, 0x34, 0xf4, 0x09, 0xb6, 0x17, 0xdc, 0x05, 0x3d, 0x5e,
+	0xa0, 0x2e, 0x98, 0x98, 0xb9, 0x9f, 0x7b, 0x9e, 0xaa, 0x7b, 0x0e, 0x95, 0x94, 0x0b, 0x20, 0x33,
+	0xcd, 0x99, 0x77, 0x26, 0x73, 0x2f, 0xf3, 0x6c, 0xb6, 0x82, 0x2f, 0x70, 0xe7, 0xda, 0xd3, 0x42,
+	0xb5, 0x9b, 0xde, 0xb5, 0x79, 0x50, 0x80, 0xb8, 0x9a, 0xb3, 0x5b, 0x96, 0x8a, 0x9f, 0xfc, 0x0b,
+	0x00, 0x00, 0xff, 0xff, 0xaa, 0x36, 0x2a, 0x93, 0x04, 0x07, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: repository-service.proto
+
+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 RepositoryExistsRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *RepositoryExistsRequest) Reset()                    { *m = RepositoryExistsRequest{} }
+func (m *RepositoryExistsRequest) String() string            { return proto.CompactTextString(m) }
+func (*RepositoryExistsRequest) ProtoMessage()               {}
+func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
+
+func (m *RepositoryExistsRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type RepositoryExistsResponse struct {
+	Exists bool `protobuf:"varint,1,opt,name=exists" json:"exists,omitempty"`
+}
+
+func (m *RepositoryExistsResponse) Reset()                    { *m = RepositoryExistsResponse{} }
+func (m *RepositoryExistsResponse) String() string            { return proto.CompactTextString(m) }
+func (*RepositoryExistsResponse) ProtoMessage()               {}
+func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
+
+func (m *RepositoryExistsResponse) GetExists() bool {
+	if m != nil {
+		return m.Exists
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
+	proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse")
+}
+
+// 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 RepositoryService service
+
+type RepositoryServiceClient interface {
+	Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error)
+}
+
+type repositoryServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewRepositoryServiceClient(cc *grpc.ClientConn) RepositoryServiceClient {
+	return &repositoryServiceClient{cc}
+}
+
+func (c *repositoryServiceClient) Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error) {
+	out := new(RepositoryExistsResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/Exists", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for RepositoryService service
+
+type RepositoryServiceServer interface {
+	Exists(context.Context, *RepositoryExistsRequest) (*RepositoryExistsResponse, error)
+}
+
+func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
+	s.RegisterService(&_RepositoryService_serviceDesc, srv)
+}
+
+func _RepositoryService_Exists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RepositoryExistsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).Exists(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/Exists",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).Exists(ctx, req.(*RepositoryExistsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _RepositoryService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.RepositoryService",
+	HandlerType: (*RepositoryServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Exists",
+			Handler:    _RepositoryService_Exists_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "repository-service.proto",
+}
+
+func init() { proto.RegisterFile("repository-service.proto", fileDescriptor6) }
+
+var fileDescriptor6 = []byte{
+	// 172 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x4a, 0x2d, 0xc8,
+	0x2f, 0xce, 0x2c, 0xc9, 0x2f, 0xaa, 0xd4, 0x2d, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b,
+	0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce,
+	0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0xf9, 0x72, 0x89, 0x07, 0xc1, 0x75, 0xb8, 0x56, 0x64,
+	0x16, 0x97, 0x14, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x21, 0x0c,
+	0x93, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x12, 0xd2, 0x83, 0x98, 0xa2, 0x87, 0xd0, 0x14, 0x84,
+	0xa4, 0x4a, 0xc9, 0x88, 0x4b, 0x02, 0xd3, 0xb8, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x21, 0x31,
+	0x2e, 0xb6, 0x54, 0xb0, 0x08, 0xd8, 0x2c, 0x8e, 0x20, 0x28, 0xcf, 0x28, 0x89, 0x4b, 0x10, 0xa1,
+	0x27, 0x18, 0xe2, 0x66, 0x21, 0x5f, 0x2e, 0x36, 0x88, 0x76, 0x21, 0x79, 0x4c, 0x2b, 0x51, 0xdc,
+	0x29, 0xa5, 0x80, 0x5b, 0x01, 0xc4, 0x66, 0x25, 0x86, 0x24, 0x36, 0xb0, 0x6f, 0x8d, 0x01, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0x7e, 0xc1, 0x7d, 0x44, 0x1f, 0x01, 0x00, 0x00,
+}

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

@@ -6,6 +6,7 @@ package gitaly
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/timestamp"
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -20,7 +21,7 @@ type Repository struct {
 func (m *Repository) Reset()                    { *m = Repository{} }
 func (m *Repository) String() string            { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()               {}
-func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
 
 func (m *Repository) GetStorageName() string {
 	if m != nil {
@@ -36,6 +37,94 @@ func (m *Repository) GetRelativePath() string {
 	return ""
 }
 
+type GitCommit struct {
+	Id        string        `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	Subject   []byte        `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
+	Body      []byte        `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+	Author    *CommitAuthor `protobuf:"bytes,4,opt,name=author" json:"author,omitempty"`
+	Committer *CommitAuthor `protobuf:"bytes,5,opt,name=committer" json:"committer,omitempty"`
+	ParentIds []string      `protobuf:"bytes,6,rep,name=parent_ids,json=parentIds" json:"parent_ids,omitempty"`
+}
+
+func (m *GitCommit) Reset()                    { *m = GitCommit{} }
+func (m *GitCommit) String() string            { return proto.CompactTextString(m) }
+func (*GitCommit) ProtoMessage()               {}
+func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
+
+func (m *GitCommit) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *GitCommit) GetSubject() []byte {
+	if m != nil {
+		return m.Subject
+	}
+	return nil
+}
+
+func (m *GitCommit) GetBody() []byte {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+func (m *GitCommit) GetAuthor() *CommitAuthor {
+	if m != nil {
+		return m.Author
+	}
+	return nil
+}
+
+func (m *GitCommit) GetCommitter() *CommitAuthor {
+	if m != nil {
+		return m.Committer
+	}
+	return nil
+}
+
+func (m *GitCommit) GetParentIds() []string {
+	if m != nil {
+		return m.ParentIds
+	}
+	return nil
+}
+
+type CommitAuthor 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 *CommitAuthor) Reset()                    { *m = CommitAuthor{} }
+func (m *CommitAuthor) String() string            { return proto.CompactTextString(m) }
+func (*CommitAuthor) ProtoMessage()               {}
+func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
+
+func (m *CommitAuthor) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *CommitAuthor) GetEmail() []byte {
+	if m != nil {
+		return m.Email
+	}
+	return nil
+}
+
+func (m *CommitAuthor) GetDate() *google_protobuf.Timestamp {
+	if m != nil {
+		return m.Date
+	}
+	return nil
+}
+
 type ExitStatus struct {
 	Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 }
@@ -43,7 +132,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 fileDescriptor4, []int{1} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -54,22 +143,34 @@ func (m *ExitStatus) GetValue() int32 {
 
 func init() {
 	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
+	proto.RegisterType((*GitCommit)(nil), "gitaly.GitCommit")
+	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
 	proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor4) }
-
-var fileDescriptor4 = []byte{
-	// 164 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0xce, 0x31, 0x0f, 0x82, 0x30,
-	0x10, 0x05, 0xe0, 0x14, 0x81, 0xe8, 0x89, 0x89, 0x69, 0x1c, 0x18, 0x11, 0x17, 0x26, 0x17, 0x7f,
-	0x83, 0x8b, 0x83, 0x31, 0xf5, 0x07, 0xe0, 0x19, 0x2f, 0xd0, 0xa4, 0xd8, 0xa6, 0x3d, 0x88, 0xfc,
-	0x7b, 0x23, 0xea, 0xf8, 0xbe, 0xf7, 0x86, 0x07, 0x59, 0x68, 0xd1, 0xd3, 0x63, 0xef, 0xbc, 0x65,
-	0x2b, 0xd3, 0x46, 0x33, 0x9a, 0xb1, 0xbc, 0x01, 0x28, 0x72, 0x36, 0x68, 0xb6, 0x7e, 0x94, 0x5b,
-	0xc8, 0x02, 0x5b, 0x8f, 0x0d, 0xd5, 0x4f, 0xec, 0x28, 0x8f, 0x0a, 0x51, 0x2d, 0xd4, 0xf2, 0x67,
-	0x67, 0xec, 0x48, 0xee, 0x60, 0xe5, 0xc9, 0x20, 0xeb, 0x81, 0x6a, 0x87, 0xdc, 0xe6, 0xb3, 0x69,
-	0x93, 0xfd, 0xf1, 0x82, 0xdc, 0x9e, 0xe2, 0xb9, 0x58, 0x47, 0x2a, 0xfe, 0xf4, 0x65, 0x09, 0x70,
-	0x7c, 0x69, 0xbe, 0x32, 0x72, 0x1f, 0xe4, 0x06, 0x92, 0x01, 0x4d, 0x4f, 0xb9, 0x28, 0x44, 0x95,
-	0xa8, 0x6f, 0xb8, 0xa7, 0xd3, 0xa9, 0xc3, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x53, 0x2c, 0xb6,
-	0xa4, 0x00, 0x00, 0x00,
+func init() { proto.RegisterFile("shared.proto", fileDescriptor7) }
+
+var fileDescriptor7 = []byte{
+	// 335 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0xc1, 0x4a, 0xc3, 0x40,
+	0x10, 0x25, 0x69, 0x1a, 0xcd, 0x34, 0x8a, 0x2c, 0x3d, 0x84, 0x82, 0x58, 0xe3, 0xa5, 0x07, 0x49,
+	0xa1, 0x7e, 0x81, 0x88, 0x88, 0x1e, 0x44, 0x56, 0xef, 0x75, 0xd2, 0xac, 0xc9, 0x4a, 0xd2, 0x0d,
+	0xbb, 0x93, 0x62, 0x7f, 0xd1, 0xaf, 0x92, 0xec, 0x36, 0xe8, 0xc9, 0xdb, 0xce, 0x9b, 0xf7, 0x66,
+	0xe6, 0xed, 0x83, 0xd8, 0x54, 0xa8, 0x45, 0x91, 0xb5, 0x5a, 0x91, 0x62, 0x61, 0x29, 0x09, 0xeb,
+	0xfd, 0xec, 0xa2, 0x54, 0xaa, 0xac, 0xc5, 0xd2, 0xa2, 0x79, 0xf7, 0xb1, 0x24, 0xd9, 0x08, 0x43,
+	0xd8, 0xb4, 0x8e, 0x98, 0xbe, 0x03, 0x70, 0xd1, 0x2a, 0x23, 0x49, 0xe9, 0x3d, 0xbb, 0x84, 0xd8,
+	0x90, 0xd2, 0x58, 0x8a, 0xf5, 0x16, 0x1b, 0x91, 0xf8, 0x73, 0x6f, 0x11, 0xf1, 0xc9, 0x01, 0x7b,
+	0xc6, 0x46, 0xb0, 0x2b, 0x38, 0xd1, 0xa2, 0x46, 0x92, 0x3b, 0xb1, 0x6e, 0x91, 0xaa, 0x64, 0x64,
+	0x39, 0xf1, 0x00, 0xbe, 0x20, 0x55, 0x4f, 0xc1, 0xb1, 0x77, 0xe6, 0xf3, 0xa0, 0xef, 0xa7, 0xdf,
+	0x1e, 0x44, 0x0f, 0x92, 0xee, 0x54, 0xd3, 0x48, 0x62, 0xa7, 0xe0, 0xcb, 0x22, 0xf1, 0xac, 0xc6,
+	0x97, 0x05, 0x4b, 0xe0, 0xc8, 0x74, 0xf9, 0xa7, 0xd8, 0x90, 0x5d, 0x16, 0xf3, 0xa1, 0x64, 0x0c,
+	0x82, 0x5c, 0x15, 0x7b, 0x3b, 0x3f, 0xe6, 0xf6, 0xcd, 0xae, 0x21, 0xc4, 0x8e, 0x2a, 0xa5, 0x93,
+	0x60, 0xee, 0x2d, 0x26, 0xab, 0x69, 0xe6, 0x7c, 0x66, 0x6e, 0xfa, 0xad, 0xed, 0xf1, 0x03, 0x87,
+	0xad, 0x20, 0xda, 0x58, 0x9c, 0x84, 0x4e, 0xc6, 0xff, 0x08, 0x7e, 0x69, 0xec, 0x1c, 0xa0, 0x45,
+	0x2d, 0xb6, 0xb4, 0x96, 0x85, 0x49, 0xc2, 0xf9, 0x68, 0x11, 0xf1, 0xc8, 0x21, 0x8f, 0x85, 0x49,
+	0x2b, 0x88, 0xff, 0x2a, 0xfb, 0x23, 0xed, 0x47, 0x79, 0xee, 0xc8, 0xfe, 0xcd, 0xa6, 0x30, 0x16,
+	0x0d, 0xca, 0xfa, 0x60, 0xc8, 0x15, 0x2c, 0x83, 0xa0, 0x40, 0x12, 0xd6, 0xce, 0x64, 0x35, 0xcb,
+	0x5c, 0x30, 0xd9, 0x10, 0x4c, 0xf6, 0x36, 0x04, 0xc3, 0x2d, 0x2f, 0x4d, 0x01, 0xee, 0xbf, 0x24,
+	0xbd, 0x12, 0x52, 0x67, 0xfa, 0x99, 0x3b, 0xac, 0x3b, 0xb7, 0x68, 0xcc, 0x5d, 0x91, 0x87, 0x56,
+	0x7d, 0xf3, 0x13, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x87, 0xe3, 0xb7, 0xfc, 0x01, 0x00, 0x00,
 }

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

@@ -24,7 +24,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 fileDescriptor5, []int{0} }
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
 
 func (m *InfoRefsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -40,7 +40,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 fileDescriptor5, []int{1} }
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
 
 func (m *InfoRefsResponse) GetData() []byte {
 	if m != nil {
@@ -59,7 +59,7 @@ type PostUploadPackRequest struct {
 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 (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
 
 func (m *PostUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -83,7 +83,7 @@ type PostUploadPackResponse struct {
 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 (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
 
 func (m *PostUploadPackResponse) GetData() []byte {
 	if m != nil {
@@ -106,7 +106,7 @@ type PostReceivePackRequest struct {
 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 (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
 
 func (m *PostReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -144,7 +144,7 @@ type PostReceivePackResponse struct {
 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 (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
 
 func (m *PostReceivePackResponse) GetData() []byte {
 	if m != nil {
@@ -170,33 +170,33 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for SmartHTTP service
+// Client API for SmartHTTPService service
 
-type SmartHTTPClient interface {
+type SmartHTTPServiceClient interface {
 	// The response body for GET /info/refs?service=git-upload-pack
-	InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error)
+	InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_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)
+	InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsReceivePackClient, error)
 	// Request and response body for POST /upload-pack
-	PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error)
+	PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostUploadPackClient, error)
 	// Request and response body for POST /receive-pack
-	PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error)
+	PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostReceivePackClient, error)
 }
 
-type smartHTTPClient struct {
+type smartHTTPServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewSmartHTTPClient(cc *grpc.ClientConn) SmartHTTPClient {
-	return &smartHTTPClient{cc}
+func NewSmartHTTPServiceClient(cc *grpc.ClientConn) SmartHTTPServiceClient {
+	return &smartHTTPServiceClient{cc}
 }
 
-func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTP/InfoRefsUploadPack", opts...)
+func (c *smartHTTPServiceClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTPService/InfoRefsUploadPack", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &smartHTTPInfoRefsUploadPackClient{stream}
+	x := &smartHTTPServiceInfoRefsUploadPackClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -206,16 +206,16 @@ func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRe
 	return x, nil
 }
 
-type SmartHTTP_InfoRefsUploadPackClient interface {
+type SmartHTTPService_InfoRefsUploadPackClient interface {
 	Recv() (*InfoRefsResponse, error)
 	grpc.ClientStream
 }
 
-type smartHTTPInfoRefsUploadPackClient struct {
+type smartHTTPServiceInfoRefsUploadPackClient struct {
 	grpc.ClientStream
 }
 
-func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) {
+func (x *smartHTTPServiceInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) {
 	m := new(InfoRefsResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -223,12 +223,12 @@ func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) {
 	return m, nil
 }
 
-func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTP/InfoRefsReceivePack", opts...)
+func (c *smartHTTPServiceClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTPService/InfoRefsReceivePack", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &smartHTTPInfoRefsReceivePackClient{stream}
+	x := &smartHTTPServiceInfoRefsReceivePackClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -238,16 +238,16 @@ func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsR
 	return x, nil
 }
 
-type SmartHTTP_InfoRefsReceivePackClient interface {
+type SmartHTTPService_InfoRefsReceivePackClient interface {
 	Recv() (*InfoRefsResponse, error)
 	grpc.ClientStream
 }
 
-type smartHTTPInfoRefsReceivePackClient struct {
+type smartHTTPServiceInfoRefsReceivePackClient struct {
 	grpc.ClientStream
 }
 
-func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) {
+func (x *smartHTTPServiceInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) {
 	m := new(InfoRefsResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -255,30 +255,30 @@ 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...)
+func (c *smartHTTPServiceClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTPService/PostUploadPack", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &smartHTTPPostUploadPackClient{stream}
+	x := &smartHTTPServicePostUploadPackClient{stream}
 	return x, nil
 }
 
-type SmartHTTP_PostUploadPackClient interface {
+type SmartHTTPService_PostUploadPackClient interface {
 	Send(*PostUploadPackRequest) error
 	Recv() (*PostUploadPackResponse, error)
 	grpc.ClientStream
 }
 
-type smartHTTPPostUploadPackClient struct {
+type smartHTTPServicePostUploadPackClient struct {
 	grpc.ClientStream
 }
 
-func (x *smartHTTPPostUploadPackClient) Send(m *PostUploadPackRequest) error {
+func (x *smartHTTPServicePostUploadPackClient) Send(m *PostUploadPackRequest) error {
 	return x.ClientStream.SendMsg(m)
 }
 
-func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) {
+func (x *smartHTTPServicePostUploadPackClient) Recv() (*PostUploadPackResponse, error) {
 	m := new(PostUploadPackResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -286,30 +286,30 @@ func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error)
 	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...)
+func (c *smartHTTPServiceClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTPService/PostReceivePack", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &smartHTTPPostReceivePackClient{stream}
+	x := &smartHTTPServicePostReceivePackClient{stream}
 	return x, nil
 }
 
-type SmartHTTP_PostReceivePackClient interface {
+type SmartHTTPService_PostReceivePackClient interface {
 	Send(*PostReceivePackRequest) error
 	Recv() (*PostReceivePackResponse, error)
 	grpc.ClientStream
 }
 
-type smartHTTPPostReceivePackClient struct {
+type smartHTTPServicePostReceivePackClient struct {
 	grpc.ClientStream
 }
 
-func (x *smartHTTPPostReceivePackClient) Send(m *PostReceivePackRequest) error {
+func (x *smartHTTPServicePostReceivePackClient) Send(m *PostReceivePackRequest) error {
 	return x.ClientStream.SendMsg(m)
 }
 
-func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error) {
+func (x *smartHTTPServicePostReceivePackClient) Recv() (*PostReceivePackResponse, error) {
 	m := new(PostReceivePackResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -317,84 +317,84 @@ func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error
 	return m, nil
 }
 
-// Server API for SmartHTTP service
+// Server API for SmartHTTPService service
 
-type SmartHTTPServer interface {
+type SmartHTTPServiceServer interface {
 	// The response body for GET /info/refs?service=git-upload-pack
-	InfoRefsUploadPack(*InfoRefsRequest, SmartHTTP_InfoRefsUploadPackServer) error
+	InfoRefsUploadPack(*InfoRefsRequest, SmartHTTPService_InfoRefsUploadPackServer) error
 	// The response body for GET /info/refs?service=git-receive-pack
-	InfoRefsReceivePack(*InfoRefsRequest, SmartHTTP_InfoRefsReceivePackServer) error
+	InfoRefsReceivePack(*InfoRefsRequest, SmartHTTPService_InfoRefsReceivePackServer) error
 	// Request and response body for POST /upload-pack
-	PostUploadPack(SmartHTTP_PostUploadPackServer) error
+	PostUploadPack(SmartHTTPService_PostUploadPackServer) error
 	// Request and response body for POST /receive-pack
-	PostReceivePack(SmartHTTP_PostReceivePackServer) error
+	PostReceivePack(SmartHTTPService_PostReceivePackServer) error
 }
 
-func RegisterSmartHTTPServer(s *grpc.Server, srv SmartHTTPServer) {
-	s.RegisterService(&_SmartHTTP_serviceDesc, srv)
+func RegisterSmartHTTPServiceServer(s *grpc.Server, srv SmartHTTPServiceServer) {
+	s.RegisterService(&_SmartHTTPService_serviceDesc, srv)
 }
 
-func _SmartHTTP_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _SmartHTTPService_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(InfoRefsRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(SmartHTTPServer).InfoRefsUploadPack(m, &smartHTTPInfoRefsUploadPackServer{stream})
+	return srv.(SmartHTTPServiceServer).InfoRefsUploadPack(m, &smartHTTPServiceInfoRefsUploadPackServer{stream})
 }
 
-type SmartHTTP_InfoRefsUploadPackServer interface {
+type SmartHTTPService_InfoRefsUploadPackServer interface {
 	Send(*InfoRefsResponse) error
 	grpc.ServerStream
 }
 
-type smartHTTPInfoRefsUploadPackServer struct {
+type smartHTTPServiceInfoRefsUploadPackServer struct {
 	grpc.ServerStream
 }
 
-func (x *smartHTTPInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error {
+func (x *smartHTTPServiceInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func _SmartHTTP_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _SmartHTTPService_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(InfoRefsRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(SmartHTTPServer).InfoRefsReceivePack(m, &smartHTTPInfoRefsReceivePackServer{stream})
+	return srv.(SmartHTTPServiceServer).InfoRefsReceivePack(m, &smartHTTPServiceInfoRefsReceivePackServer{stream})
 }
 
-type SmartHTTP_InfoRefsReceivePackServer interface {
+type SmartHTTPService_InfoRefsReceivePackServer interface {
 	Send(*InfoRefsResponse) error
 	grpc.ServerStream
 }
 
-type smartHTTPInfoRefsReceivePackServer struct {
+type smartHTTPServiceInfoRefsReceivePackServer struct {
 	grpc.ServerStream
 }
 
-func (x *smartHTTPInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error {
+func (x *smartHTTPServiceInfoRefsReceivePackServer) 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})
+func _SmartHTTPService_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SmartHTTPServiceServer).PostUploadPack(&smartHTTPServicePostUploadPackServer{stream})
 }
 
-type SmartHTTP_PostUploadPackServer interface {
+type SmartHTTPService_PostUploadPackServer interface {
 	Send(*PostUploadPackResponse) error
 	Recv() (*PostUploadPackRequest, error)
 	grpc.ServerStream
 }
 
-type smartHTTPPostUploadPackServer struct {
+type smartHTTPServicePostUploadPackServer struct {
 	grpc.ServerStream
 }
 
-func (x *smartHTTPPostUploadPackServer) Send(m *PostUploadPackResponse) error {
+func (x *smartHTTPServicePostUploadPackServer) Send(m *PostUploadPackResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) {
+func (x *smartHTTPServicePostUploadPackServer) Recv() (*PostUploadPackRequest, error) {
 	m := new(PostUploadPackRequest)
 	if err := x.ServerStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -402,25 +402,25 @@ func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) {
 	return m, nil
 }
 
-func _SmartHTTP_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SmartHTTPServer).PostReceivePack(&smartHTTPPostReceivePackServer{stream})
+func _SmartHTTPService_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SmartHTTPServiceServer).PostReceivePack(&smartHTTPServicePostReceivePackServer{stream})
 }
 
-type SmartHTTP_PostReceivePackServer interface {
+type SmartHTTPService_PostReceivePackServer interface {
 	Send(*PostReceivePackResponse) error
 	Recv() (*PostReceivePackRequest, error)
 	grpc.ServerStream
 }
 
-type smartHTTPPostReceivePackServer struct {
+type smartHTTPServicePostReceivePackServer struct {
 	grpc.ServerStream
 }
 
-func (x *smartHTTPPostReceivePackServer) Send(m *PostReceivePackResponse) error {
+func (x *smartHTTPServicePostReceivePackServer) Send(m *PostReceivePackResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) {
+func (x *smartHTTPServicePostReceivePackServer) Recv() (*PostReceivePackRequest, error) {
 	m := new(PostReceivePackRequest)
 	if err := x.ServerStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -428,30 +428,30 @@ func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error)
 	return m, nil
 }
 
-var _SmartHTTP_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.SmartHTTP",
-	HandlerType: (*SmartHTTPServer)(nil),
+var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.SmartHTTPService",
+	HandlerType: (*SmartHTTPServiceServer)(nil),
 	Methods:     []grpc.MethodDesc{},
 	Streams: []grpc.StreamDesc{
 		{
 			StreamName:    "InfoRefsUploadPack",
-			Handler:       _SmartHTTP_InfoRefsUploadPack_Handler,
+			Handler:       _SmartHTTPService_InfoRefsUploadPack_Handler,
 			ServerStreams: true,
 		},
 		{
 			StreamName:    "InfoRefsReceivePack",
-			Handler:       _SmartHTTP_InfoRefsReceivePack_Handler,
+			Handler:       _SmartHTTPService_InfoRefsReceivePack_Handler,
 			ServerStreams: true,
 		},
 		{
 			StreamName:    "PostUploadPack",
-			Handler:       _SmartHTTP_PostUploadPack_Handler,
+			Handler:       _SmartHTTPService_PostUploadPack_Handler,
 			ServerStreams: true,
 			ClientStreams: true,
 		},
 		{
 			StreamName:    "PostReceivePack",
-			Handler:       _SmartHTTP_PostReceivePack_Handler,
+			Handler:       _SmartHTTPService_PostReceivePack_Handler,
 			ServerStreams: true,
 			ClientStreams: true,
 		},
@@ -459,29 +459,29 @@ var _SmartHTTP_serviceDesc = grpc.ServiceDesc{
 	Metadata: "smarthttp.proto",
 }
 
-func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor5) }
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor8) }
 
-var fileDescriptor5 = []byte{
-	// 321 bytes of a gzipped FileDescriptorProto
+var fileDescriptor8 = []byte{
+	// 327 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x4b, 0xc3, 0x40,
-	0x10, 0x75, 0x6b, 0x2d, 0x74, 0xac, 0x56, 0xa6, 0x68, 0x4b, 0x40, 0x2d, 0x11, 0xa4, 0x07, 0x0d,
-	0x25, 0xfe, 0x06, 0xc1, 0xa2, 0x87, 0xb0, 0xb6, 0xe0, 0x2d, 0xac, 0xcd, 0x36, 0x0d, 0xae, 0xdd,
-	0x98, 0x5d, 0x85, 0xfe, 0x15, 0xff, 0x98, 0x7f, 0x47, 0x4c, 0xc8, 0x47, 0x13, 0xe3, 0x41, 0xf1,
-	0x16, 0xe6, 0xcd, 0xbc, 0xf7, 0x66, 0x5e, 0x16, 0xba, 0xea, 0x99, 0x45, 0x7a, 0xa9, 0x75, 0x68,
-	0x85, 0x91, 0xd4, 0x12, 0x5b, 0x7e, 0xa0, 0x99, 0x58, 0x1b, 0x1d, 0xb5, 0x64, 0x11, 0xf7, 0x92,
-	0xaa, 0x79, 0x0d, 0xdd, 0xc9, 0x6a, 0x21, 0x29, 0x5f, 0x28, 0xca, 0x5f, 0x5e, 0xb9, 0xd2, 0x68,
-	0x03, 0x44, 0x3c, 0x94, 0x2a, 0xd0, 0x32, 0x5a, 0x0f, 0xc8, 0x90, 0x8c, 0x76, 0x6d, 0xb4, 0x92,
-	0x69, 0x8b, 0x66, 0x08, 0x2d, 0x74, 0x99, 0xe7, 0x70, 0x90, 0xd3, 0xa8, 0x50, 0xae, 0x14, 0x47,
-	0x84, 0xa6, 0xc7, 0x34, 0x8b, 0x19, 0x3a, 0x34, 0xfe, 0x36, 0x5d, 0x38, 0x74, 0xa4, 0xd2, 0xb3,
-	0x50, 0x48, 0xe6, 0x39, 0x6c, 0xfe, 0xf4, 0x07, 0xd1, 0x4c, 0xa0, 0x51, 0x10, 0xb8, 0x80, 0xa3,
-	0xb2, 0xc0, 0x0f, 0x76, 0xde, 0x49, 0xd2, 0x4e, 0xf9, 0x9c, 0x07, 0x6f, 0xfc, 0x1f, 0x0c, 0x61,
-	0x0f, 0x76, 0x7c, 0xe1, 0x06, 0xde, 0x60, 0x7b, 0x48, 0x46, 0x6d, 0xda, 0xf4, 0xc5, 0xc4, 0xc3,
-	0x33, 0xd8, 0xf3, 0x85, 0x5b, 0xe0, 0x6f, 0xc6, 0x60, 0xc7, 0x17, 0x39, 0xb3, 0x79, 0x09, 0xfd,
-	0x8a, 0xb7, 0xfa, 0x5d, 0xec, 0x8f, 0x06, 0xb4, 0xef, 0xbf, 0x32, 0xbf, 0x99, 0x4e, 0x1d, 0xbc,
-	0x05, 0x4c, 0x03, 0xc9, 0x6f, 0x81, 0xfd, 0x74, 0x81, 0x52, 0xe6, 0xc6, 0xa0, 0x0a, 0x24, 0x52,
-	0xe6, 0xd6, 0x98, 0xe0, 0x1d, 0xf4, 0xf2, 0x7a, 0xe6, 0xe6, 0xb7, 0x6c, 0x33, 0xd8, 0xdf, 0x8c,
-	0x08, 0x8f, 0xd3, 0xfe, 0x6f, 0xff, 0x0d, 0xe3, 0xa4, 0x0e, 0x4e, 0x49, 0x47, 0x64, 0x4c, 0xf0,
-	0x01, 0xba, 0xa5, 0x73, 0xe1, 0xc6, 0x60, 0x35, 0x63, 0xe3, 0xb4, 0x16, 0x2f, 0x32, 0x3f, 0xb6,
-	0xe2, 0xa7, 0x72, 0xf5, 0x19, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x33, 0x8a, 0x1a, 0x53, 0x03, 0x00,
-	0x00,
+	0x10, 0x75, 0x6b, 0x2d, 0x38, 0x56, 0x5b, 0xa6, 0x68, 0x4b, 0x40, 0x2d, 0x11, 0xa4, 0x07, 0x2d,
+	0xa5, 0xfe, 0x06, 0xc1, 0xa2, 0x87, 0xb2, 0x6d, 0xc1, 0x5b, 0x59, 0x93, 0x6d, 0x1a, 0x5c, 0xbb,
+	0x71, 0x77, 0x2d, 0xf4, 0xaf, 0xf8, 0xe3, 0xfc, 0x2d, 0x62, 0x42, 0x3e, 0x9a, 0x18, 0x0f, 0x8a,
+	0xb7, 0x30, 0x6f, 0xe6, 0xbd, 0x37, 0xf3, 0xb2, 0xd0, 0xd0, 0x2f, 0x4c, 0x99, 0xa5, 0x31, 0x41,
+	0x3f, 0x50, 0xd2, 0x48, 0xac, 0x79, 0xbe, 0x61, 0x62, 0x63, 0xd5, 0xf5, 0x92, 0x29, 0xee, 0x46,
+	0x55, 0xfb, 0x16, 0x1a, 0xa3, 0xd5, 0x42, 0x52, 0xbe, 0xd0, 0x94, 0xbf, 0xbe, 0x71, 0x6d, 0x70,
+	0x08, 0xa0, 0x78, 0x20, 0xb5, 0x6f, 0xa4, 0xda, 0x74, 0x48, 0x97, 0xf4, 0x0e, 0x86, 0xd8, 0x8f,
+	0xa6, 0xfb, 0x34, 0x41, 0x68, 0xa6, 0xcb, 0xbe, 0x84, 0x66, 0x4a, 0xa3, 0x03, 0xb9, 0xd2, 0x1c,
+	0x11, 0xaa, 0x2e, 0x33, 0x2c, 0x64, 0xa8, 0xd3, 0xf0, 0xdb, 0x9e, 0xc3, 0xf1, 0x58, 0x6a, 0x33,
+	0x0b, 0x84, 0x64, 0xee, 0x98, 0x39, 0xcf, 0x7f, 0x10, 0x4d, 0x04, 0x2a, 0x19, 0x81, 0x2b, 0x38,
+	0xc9, 0x0b, 0xfc, 0x60, 0xe7, 0x9d, 0x44, 0xed, 0x94, 0x3b, 0xdc, 0x5f, 0xf3, 0x7f, 0x30, 0x84,
+	0x2d, 0xd8, 0xf3, 0xc4, 0xdc, 0x77, 0x3b, 0xbb, 0x5d, 0xd2, 0xdb, 0xa7, 0x55, 0x4f, 0x8c, 0x5c,
+	0xbc, 0x80, 0x43, 0x4f, 0xcc, 0x33, 0xfc, 0xd5, 0x10, 0xac, 0x7b, 0x22, 0x65, 0xb6, 0xaf, 0xa1,
+	0x5d, 0xf0, 0x56, 0xbe, 0xcb, 0xf0, 0xa3, 0x02, 0xcd, 0xc9, 0x57, 0xe6, 0x77, 0xd3, 0xe9, 0x78,
+	0xc2, 0xd5, 0xda, 0x77, 0x38, 0xde, 0x03, 0xc6, 0xb9, 0xa4, 0x27, 0xc1, 0x76, 0xbc, 0x47, 0x2e,
+	0x7a, 0xab, 0x53, 0x04, 0x22, 0x45, 0x7b, 0x67, 0x40, 0xf0, 0x01, 0x5a, 0x69, 0x3d, 0x31, 0xf5,
+	0x5b, 0xb6, 0x19, 0x1c, 0x6d, 0x27, 0x85, 0xa7, 0x71, 0xff, 0xb7, 0xbf, 0x88, 0x75, 0x56, 0x06,
+	0xc7, 0xa4, 0x3d, 0x32, 0x20, 0xf8, 0x08, 0x8d, 0xdc, 0xd5, 0x70, 0x6b, 0xb0, 0x18, 0xb5, 0x75,
+	0x5e, 0x8a, 0x67, 0x99, 0x9f, 0x6a, 0xe1, 0x8b, 0xb9, 0xf9, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xbe,
+	0x10, 0x08, 0x81, 0x5a, 0x03, 0x00, 0x00,
 }

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

@@ -27,7 +27,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 fileDescriptor6, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -56,7 +56,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 fileDescriptor6, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -93,7 +93,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 fileDescriptor6, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -136,7 +136,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 fileDescriptor6, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -174,47 +174,47 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for SSH service
+// Client API for SSHService service
 
-type SSHClient interface {
+type SSHServiceClient interface {
 	// To forward 'git upload-pack' to Gitaly for SSH sessions
-	SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error)
+	SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error)
 	// To forward 'git receive-pack' to Gitaly for SSH sessions
-	SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error)
+	SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error)
 }
 
-type sSHClient struct {
+type sSHServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewSSHClient(cc *grpc.ClientConn) SSHClient {
-	return &sSHClient{cc}
+func NewSSHServiceClient(cc *grpc.ClientConn) SSHServiceClient {
+	return &sSHServiceClient{cc}
 }
 
-func (c *sSHClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[0], c.cc, "/gitaly.SSH/SSHUploadPack", opts...)
+func (c *sSHServiceClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[0], c.cc, "/gitaly.SSHService/SSHUploadPack", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &sSHSSHUploadPackClient{stream}
+	x := &sSHServiceSSHUploadPackClient{stream}
 	return x, nil
 }
 
-type SSH_SSHUploadPackClient interface {
+type SSHService_SSHUploadPackClient interface {
 	Send(*SSHUploadPackRequest) error
 	Recv() (*SSHUploadPackResponse, error)
 	grpc.ClientStream
 }
 
-type sSHSSHUploadPackClient struct {
+type sSHServiceSSHUploadPackClient struct {
 	grpc.ClientStream
 }
 
-func (x *sSHSSHUploadPackClient) Send(m *SSHUploadPackRequest) error {
+func (x *sSHServiceSSHUploadPackClient) Send(m *SSHUploadPackRequest) error {
 	return x.ClientStream.SendMsg(m)
 }
 
-func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) {
+func (x *sSHServiceSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) {
 	m := new(SSHUploadPackResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -222,30 +222,30 @@ func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) {
 	return m, nil
 }
 
-func (c *sSHClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[1], c.cc, "/gitaly.SSH/SSHReceivePack", opts...)
+func (c *sSHServiceClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[1], c.cc, "/gitaly.SSHService/SSHReceivePack", opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &sSHSSHReceivePackClient{stream}
+	x := &sSHServiceSSHReceivePackClient{stream}
 	return x, nil
 }
 
-type SSH_SSHReceivePackClient interface {
+type SSHService_SSHReceivePackClient interface {
 	Send(*SSHReceivePackRequest) error
 	Recv() (*SSHReceivePackResponse, error)
 	grpc.ClientStream
 }
 
-type sSHSSHReceivePackClient struct {
+type sSHServiceSSHReceivePackClient struct {
 	grpc.ClientStream
 }
 
-func (x *sSHSSHReceivePackClient) Send(m *SSHReceivePackRequest) error {
+func (x *sSHServiceSSHReceivePackClient) Send(m *SSHReceivePackRequest) error {
 	return x.ClientStream.SendMsg(m)
 }
 
-func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) {
+func (x *sSHServiceSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) {
 	m := new(SSHReceivePackResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -253,38 +253,38 @@ func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) {
 	return m, nil
 }
 
-// Server API for SSH service
+// Server API for SSHService service
 
-type SSHServer interface {
+type SSHServiceServer interface {
 	// To forward 'git upload-pack' to Gitaly for SSH sessions
-	SSHUploadPack(SSH_SSHUploadPackServer) error
+	SSHUploadPack(SSHService_SSHUploadPackServer) error
 	// To forward 'git receive-pack' to Gitaly for SSH sessions
-	SSHReceivePack(SSH_SSHReceivePackServer) error
+	SSHReceivePack(SSHService_SSHReceivePackServer) error
 }
 
-func RegisterSSHServer(s *grpc.Server, srv SSHServer) {
-	s.RegisterService(&_SSH_serviceDesc, srv)
+func RegisterSSHServiceServer(s *grpc.Server, srv SSHServiceServer) {
+	s.RegisterService(&_SSHService_serviceDesc, srv)
 }
 
-func _SSH_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SSHServer).SSHUploadPack(&sSHSSHUploadPackServer{stream})
+func _SSHService_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SSHServiceServer).SSHUploadPack(&sSHServiceSSHUploadPackServer{stream})
 }
 
-type SSH_SSHUploadPackServer interface {
+type SSHService_SSHUploadPackServer interface {
 	Send(*SSHUploadPackResponse) error
 	Recv() (*SSHUploadPackRequest, error)
 	grpc.ServerStream
 }
 
-type sSHSSHUploadPackServer struct {
+type sSHServiceSSHUploadPackServer struct {
 	grpc.ServerStream
 }
 
-func (x *sSHSSHUploadPackServer) Send(m *SSHUploadPackResponse) error {
+func (x *sSHServiceSSHUploadPackServer) Send(m *SSHUploadPackResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) {
+func (x *sSHServiceSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) {
 	m := new(SSHUploadPackRequest)
 	if err := x.ServerStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -292,25 +292,25 @@ func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) {
 	return m, nil
 }
 
-func _SSH_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SSHServer).SSHReceivePack(&sSHSSHReceivePackServer{stream})
+func _SSHService_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SSHServiceServer).SSHReceivePack(&sSHServiceSSHReceivePackServer{stream})
 }
 
-type SSH_SSHReceivePackServer interface {
+type SSHService_SSHReceivePackServer interface {
 	Send(*SSHReceivePackResponse) error
 	Recv() (*SSHReceivePackRequest, error)
 	grpc.ServerStream
 }
 
-type sSHSSHReceivePackServer struct {
+type sSHServiceSSHReceivePackServer struct {
 	grpc.ServerStream
 }
 
-func (x *sSHSSHReceivePackServer) Send(m *SSHReceivePackResponse) error {
+func (x *sSHServiceSSHReceivePackServer) Send(m *SSHReceivePackResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) {
+func (x *sSHServiceSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) {
 	m := new(SSHReceivePackRequest)
 	if err := x.ServerStream.RecvMsg(m); err != nil {
 		return nil, err
@@ -318,20 +318,20 @@ func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) {
 	return m, nil
 }
 
-var _SSH_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.SSH",
-	HandlerType: (*SSHServer)(nil),
+var _SSHService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.SSHService",
+	HandlerType: (*SSHServiceServer)(nil),
 	Methods:     []grpc.MethodDesc{},
 	Streams: []grpc.StreamDesc{
 		{
 			StreamName:    "SSHUploadPack",
-			Handler:       _SSH_SSHUploadPack_Handler,
+			Handler:       _SSHService_SSHUploadPack_Handler,
 			ServerStreams: true,
 			ClientStreams: true,
 		},
 		{
 			StreamName:    "SSHReceivePack",
-			Handler:       _SSH_SSHReceivePack_Handler,
+			Handler:       _SSHService_SSHReceivePack_Handler,
 			ServerStreams: true,
 			ClientStreams: true,
 		},
@@ -339,27 +339,28 @@ var _SSH_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor6) }
-
-var fileDescriptor6 = []byte{
-	// 304 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4e, 0xf3, 0x30,
-	0x10, 0xfc, 0xfc, 0xf5, 0x47, 0xea, 0x36, 0xe5, 0xb0, 0x94, 0xaa, 0x8a, 0x00, 0x55, 0xe1, 0x92,
-	0x53, 0x84, 0xd2, 0x67, 0x40, 0x2a, 0x37, 0xe4, 0xa8, 0xe7, 0x10, 0x6a, 0x2b, 0xb5, 0xb0, 0xea,
-	0x60, 0x3b, 0xa8, 0x95, 0xe0, 0x49, 0x78, 0x09, 0x1e, 0x11, 0xc9, 0x09, 0x25, 0x29, 0xf4, 0x08,
-	0xb7, 0xcc, 0x4e, 0x76, 0x66, 0xd6, 0xbb, 0x30, 0x30, 0x66, 0x1d, 0x15, 0x5a, 0x59, 0x85, 0xfd,
-	0x5c, 0xd8, 0x4c, 0xee, 0x7c, 0xcf, 0xac, 0x33, 0xcd, 0x59, 0x55, 0x0d, 0xee, 0x61, 0x9c, 0x24,
-	0x8b, 0x65, 0x21, 0x55, 0xc6, 0xee, 0xb2, 0xd5, 0x23, 0xe5, 0x4f, 0x25, 0x37, 0x16, 0x63, 0x00,
-	0xcd, 0x0b, 0x65, 0x84, 0x55, 0x7a, 0x37, 0x25, 0x33, 0x12, 0x0e, 0x63, 0x8c, 0x2a, 0x89, 0x88,
-	0xee, 0x19, 0xda, 0xf8, 0x0b, 0xc7, 0xd0, 0x33, 0x96, 0x89, 0xcd, 0xf4, 0xff, 0x8c, 0x84, 0x1e,
-	0xad, 0x40, 0xf0, 0x02, 0x67, 0x07, 0x0e, 0xa6, 0x50, 0x1b, 0xc3, 0x71, 0x02, 0x7d, 0x63, 0x99,
-	0x2a, 0xad, 0x93, 0xf7, 0x68, 0x8d, 0xea, 0x3a, 0xd7, 0xba, 0xd6, 0xa9, 0x11, 0xce, 0x61, 0xc8,
-	0xb7, 0xc2, 0xa6, 0xc6, 0x66, 0xb6, 0x34, 0xd3, 0x4e, 0x3b, 0xd3, 0xcd, 0x56, 0xd8, 0xc4, 0x31,
-	0x14, 0xf8, 0xfe, 0x3b, 0x78, 0x23, 0xce, 0x9e, 0xf2, 0x15, 0x17, 0xcf, 0xfc, 0x57, 0x26, 0xc4,
-	0x53, 0xe8, 0xe5, 0x32, 0x15, 0xcc, 0x45, 0x1a, 0xd0, 0x6e, 0x2e, 0x6f, 0x19, 0x5e, 0xc1, 0x28,
-	0x97, 0x69, 0xc3, 0xa1, 0xeb, 0x48, 0x2f, 0x97, 0x5f, 0xda, 0xc1, 0x2b, 0x4c, 0x0e, 0xc3, 0xfd,
-	0xe1, 0xe3, 0xc4, 0xef, 0x04, 0x3a, 0x49, 0xb2, 0x40, 0x0a, 0xa3, 0xd6, 0x8a, 0xf0, 0xfc, 0xb3,
-	0xf1, 0xa7, 0xdb, 0xf0, 0x2f, 0x8e, 0xb0, 0x55, 0xf4, 0xe0, 0x5f, 0x48, 0xae, 0x09, 0x2e, 0xe1,
-	0xa4, 0x3d, 0x1a, 0x36, 0xdb, 0xbe, 0xef, 0xc3, 0xbf, 0x3c, 0x46, 0x37, 0x65, 0x1f, 0xfa, 0xee,
-	0x6c, 0xe7, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x3d, 0xb9, 0xce, 0xd9, 0x02, 0x00, 0x00,
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor9) }
+
+var fileDescriptor9 = []byte{
+	// 307 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcf, 0x4e, 0x32, 0x31,
+	0x10, 0xff, 0xfa, 0x09, 0x24, 0x0c, 0x8b, 0x87, 0x11, 0x09, 0x21, 0x6a, 0xc8, 0x7a, 0xe1, 0x44,
+	0x0c, 0x3c, 0x83, 0x09, 0xde, 0x4c, 0x1b, 0xce, 0xb8, 0xd2, 0xc9, 0xd2, 0xd8, 0xd0, 0xb5, 0x2d,
+	0x04, 0x12, 0x7d, 0x12, 0x1f, 0xc4, 0xd7, 0x33, 0xe9, 0xae, 0xb8, 0x8b, 0x72, 0xd4, 0xdb, 0xce,
+	0xfc, 0x76, 0x7e, 0x7f, 0x3a, 0x03, 0x4d, 0xe7, 0x96, 0xa3, 0xcc, 0x1a, 0x6f, 0xb0, 0x91, 0x2a,
+	0x9f, 0xe8, 0x5d, 0x3f, 0x72, 0xcb, 0xc4, 0x92, 0xcc, 0xbb, 0xf1, 0x03, 0x74, 0x84, 0x98, 0xce,
+	0x32, 0x6d, 0x12, 0x79, 0x9f, 0x2c, 0x9e, 0x38, 0x3d, 0xaf, 0xc9, 0x79, 0x1c, 0x03, 0x58, 0xca,
+	0x8c, 0x53, 0xde, 0xd8, 0x5d, 0x8f, 0x0d, 0xd8, 0xb0, 0x35, 0xc6, 0x51, 0x4e, 0x31, 0xe2, 0x7b,
+	0x84, 0x97, 0xfe, 0xc2, 0x0e, 0xd4, 0x9d, 0x97, 0x6a, 0xd5, 0xfb, 0x3f, 0x60, 0xc3, 0x88, 0xe7,
+	0x45, 0xfc, 0x02, 0xe7, 0x07, 0x0a, 0x2e, 0x33, 0x2b, 0x47, 0xd8, 0x85, 0x86, 0xf3, 0xd2, 0xac,
+	0x7d, 0xa0, 0x8f, 0x78, 0x51, 0x15, 0x7d, 0xb2, 0xb6, 0xe0, 0x29, 0x2a, 0x9c, 0x40, 0x8b, 0xb6,
+	0xca, 0xcf, 0x9d, 0x4f, 0xfc, 0xda, 0xf5, 0x4e, 0xaa, 0x9e, 0x6e, 0xb7, 0xca, 0x8b, 0x80, 0x70,
+	0xa0, 0xfd, 0x77, 0xfc, 0xc6, 0x82, 0x3c, 0xa7, 0x05, 0xa9, 0x0d, 0xfd, 0x4a, 0x42, 0x3c, 0x83,
+	0x7a, 0xaa, 0xe7, 0x4a, 0x06, 0x4b, 0x4d, 0x5e, 0x4b, 0xf5, 0x9d, 0xc4, 0x6b, 0x68, 0xa7, 0x7a,
+	0x5e, 0x52, 0xa8, 0x05, 0x30, 0x4a, 0xf5, 0x17, 0x77, 0xfc, 0x0a, 0xdd, 0x43, 0x73, 0x7f, 0xf8,
+	0x38, 0xe3, 0x77, 0x06, 0x20, 0xc4, 0x54, 0x90, 0xdd, 0xa8, 0x05, 0x21, 0x87, 0x76, 0x65, 0x53,
+	0x78, 0xf1, 0x39, 0xff, 0xd3, 0x89, 0xf4, 0x2f, 0x8f, 0xa0, 0x79, 0x82, 0xf8, 0xdf, 0x90, 0xdd,
+	0x30, 0x9c, 0xc1, 0x69, 0x35, 0x21, 0x96, 0xc7, 0xbe, 0xaf, 0xa5, 0x7f, 0x75, 0x0c, 0x2e, 0xd3,
+	0x3e, 0x36, 0xc2, 0xf5, 0x4e, 0x3e, 0x02, 0x00, 0x00, 0xff, 0xff, 0x79, 0x5b, 0x32, 0x2b, 0xe0,
+	0x02, 0x00, 0x00,
 }

vendor/vendor.json

@@ -146,12 +146,12 @@
 			"revisionTime": "2016-11-17T07:43:51Z"
 		},
 		{
-			"checksumSHA1": "6SVQZeJ2M//eFTZwDe1ArP7RF8g=",
+			"checksumSHA1": "kvKqkz5AAO34W1mB4t9bAZdPGEw=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "e302a46f7ccd889bfaa683d2ba06ffe06ca5875b",
-			"revisionTime": "2017-06-12T18:49:50Z",
-			"version": "v0.9.0",
-			"versionExact": "v0.9.0"
+			"revision": "e61d1eab6f19e153379184d378c72917b6d03dc3",
+			"revisionTime": "2017-07-07T23:49:54Z",
+			"version": "v0.15.0",
+			"versionExact": "v0.15.0"
 		},
 		{
 			"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",