Merge branch 'gitaly-upload-archive' into 'master'

Add Gitaly git-upload-archive migrated command

See merge request gitlab-org/gitlab-shell!192

.gitignore

@@ -14,3 +14,4 @@ hooks/*.d
 /go_build
 /bin/gitaly-upload-pack
 /bin/gitaly-receive-pack
+/bin/gitaly-upload-archive

CHANGELOG

+v7.1.0
+  - Migrate `git-upload-archive` to gitaly
+
 v7.0.0
   - Switch to structured logging (!193)
 

go/cmd/gitaly-upload-archive/main.go

+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"gitlab.com/gitlab-org/gitlab-shell/go/internal/handler"
+	"gitlab.com/gitlab-org/gitlab-shell/go/internal/logger"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+)
+
+func init() {
+	logger.ProgName = "gitaly-upload-archive"
+}
+
+type uploadArchiveHandler func(gitalyAddress string, request *pb.SSHUploadArchiveRequest) (int32, error)
+
+func main() {
+	if err := handler.Prepare(); err != nil {
+		logger.Fatal("preparation failed", err)
+	}
+
+	code, err := uploadArchive(handler.UploadArchive, os.Args)
+
+	if err != nil {
+		logger.Fatal("upload-archive failed", err)
+	}
+
+	os.Exit(int(code))
+}
+
+func uploadArchive(handler uploadArchiveHandler, args []string) (int32, error) {
+	if n := len(args); n != 3 {
+		return 0, fmt.Errorf("wrong number of arguments: expected 2 arguments, got %v", args)
+	}
+
+	var request pb.SSHUploadArchiveRequest
+	if err := json.Unmarshal([]byte(args[2]), &request); err != nil {
+		return 0, fmt.Errorf("unmarshaling request json failed: %v", err)
+	}
+
+	return handler(args[1], &request)
+}

go/cmd/gitaly-upload-archive/main_test.go

+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+)
+
+var testGitalyAddress = "unix:gitaly.socket"
+
+func TestUploadArchiveSuccess(t *testing.T) {
+	testRelativePath := "myrepo.git"
+	requestJSON := fmt.Sprintf(`{"repository":{"relative_path":"%s"}}`, testRelativePath)
+	mockHandler := func(gitalyAddress string, request *pb.SSHUploadArchiveRequest) (int32, error) {
+		if gitalyAddress != testGitalyAddress {
+			t.Fatalf("Expected gitaly address %s got %v", testGitalyAddress, gitalyAddress)
+		}
+		if relativePath := request.Repository.RelativePath; relativePath != testRelativePath {
+			t.Fatalf("Expected repository with relative path %s got %v", testRelativePath, request)
+		}
+		return 0, nil
+	}
+
+	code, err := uploadArchive(mockHandler, []string{"git-upload-archive", testGitalyAddress, requestJSON})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if code != 0 {
+		t.Fatalf("Expected exit code 0, got %v", code)
+	}
+}
+
+func TestUploadArchiveFailure(t *testing.T) {
+	mockHandler := func(_ string, _ *pb.SSHUploadArchiveRequest) (int32, error) {
+		t.Fatal("Expected handler not to be called")
+
+		return 0, nil
+	}
+
+	tests := []struct {
+		desc string
+		args []string
+		err  string
+	}{
+		{
+			desc: "With an invalid request json",
+			args: []string{"git-upload-archive", testGitalyAddress, "hello"},
+			err:  "unmarshaling request json failed",
+		},
+		{
+			desc: "With an invalid argument count",
+			args: []string{"git-upload-archive", testGitalyAddress, "{}", "extra arg"},
+			err:  "wrong number of arguments: expected 2 arguments",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.desc, func(t *testing.T) {
+			_, err := uploadArchive(mockHandler, test.args)
+
+			if !strings.Contains(err.Error(), test.err) {
+				t.Fatalf("Expected error %v, got %v", test.err, err)
+			}
+		})
+	}
+}

go/internal/handler/upload_archive.go

+package handler
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/client"
+)
+
+func UploadArchive(gitalyAddress string, request *pb.SSHUploadArchiveRequest) (int32, error) {
+	if gitalyAddress == "" {
+		return 0, fmt.Errorf("no gitaly_address given")
+	}
+
+	conn, err := client.Dial(gitalyAddress, dialOpts())
+	if err != nil {
+		return 0, err
+	}
+	defer conn.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	return client.UploadArchive(ctx, conn, os.Stdin, os.Stdout, os.Stderr, request)
+}

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

-0.75.0
+0.89.0

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

@@ -16,6 +16,7 @@ It is generated from these files:
 	ref.proto
 	remote.proto
 	repository-service.proto
+	server.proto
 	shared.proto
 	smarthttp.proto
 	ssh.proto
@@ -29,6 +30,10 @@ It has these top-level messages:
 	LFSPointer
 	GetLFSPointersRequest
 	GetLFSPointersResponse
+	GetNewLFSPointersRequest
+	GetNewLFSPointersResponse
+	GetAllLFSPointersRequest
+	GetAllLFSPointersResponse
 	CommitStatsRequest
 	CommitStatsResponse
 	CommitIsAncestorRequest
@@ -64,6 +69,8 @@ It has these top-level messages:
 	FilterShasWithSignaturesResponse
 	ExtractCommitSignatureRequest
 	ExtractCommitSignatureResponse
+	GetCommitSignaturesRequest
+	GetCommitSignaturesResponse
 	ListConflictFilesRequest
 	ConflictFileHeader
 	ConflictFile
@@ -116,6 +123,8 @@ It has these top-level messages:
 	UserCommitFilesResponse
 	UserRebaseRequest
 	UserRebaseResponse
+	UserSquashRequest
+	UserSquashResponse
 	FindDefaultBranchNameRequest
 	FindDefaultBranchNameResponse
 	FindAllBranchNamesRequest
@@ -156,8 +165,6 @@ It has these top-level messages:
 	UpdateRemoteMirrorResponse
 	RepositoryExistsRequest
 	RepositoryExistsResponse
-	RepositoryIsEmptyRequest
-	RepositoryIsEmptyResponse
 	RepackIncrementalRequest
 	RepackIncrementalResponse
 	RepackFullRequest
@@ -188,8 +195,20 @@ It has these top-level messages:
 	CreateForkResponse
 	IsRebaseInProgressRequest
 	IsRebaseInProgressResponse
+	IsSquashInProgressRequest
+	IsSquashInProgressResponse
 	CreateRepositoryFromURLRequest
 	CreateRepositoryFromURLResponse
+	CreateBundleRequest
+	CreateBundleResponse
+	WriteConfigRequest
+	WriteConfigResponse
+	CreateRepositoryFromBundleRequest
+	CreateRepositoryFromBundleResponse
+	FindLicenseRequest
+	FindLicenseResponse
+	ServerInfoRequest
+	ServerInfoResponse
 	Repository
 	GitCommit
 	CommitAuthor
@@ -207,6 +226,8 @@ It has these top-level messages:
 	SSHUploadPackResponse
 	SSHReceivePackRequest
 	SSHReceivePackResponse
+	SSHUploadArchiveRequest
+	SSHUploadArchiveResponse
 	WikiCommitDetails
 	WikiPageVersion
 	WikiPage
@@ -224,6 +245,8 @@ It has these top-level messages:
 	WikiFindFileResponse
 	WikiGetAllPagesRequest
 	WikiGetAllPagesResponse
+	WikiGetFormattedDataRequest
+	WikiGetFormattedDataResponse
 */
 package gitaly
 
@@ -318,8 +341,8 @@ func (m *GetBlobResponse) GetOid() string {
 
 type GetBlobsRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-	// Object IDs (SHA1) of the blobs we want to get
-	Oids []string `protobuf:"bytes,2,rep,name=oids" json:"oids,omitempty"`
+	// Revision/Path pairs of the blobs we want to get.
+	RevisionPaths []*GetBlobsRequest_RevisionPath `protobuf:"bytes,2,rep,name=revision_paths,json=revisionPaths" json:"revision_paths,omitempty"`
 	// Maximum number of bytes we want to receive. Use '-1' to get the full blobs no matter how big.
 	Limit int64 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
 }
@@ -336,9 +359,9 @@ func (m *GetBlobsRequest) GetRepository() *Repository {
 	return nil
 }
 
-func (m *GetBlobsRequest) GetOids() []string {
+func (m *GetBlobsRequest) GetRevisionPaths() []*GetBlobsRequest_RevisionPath {
 	if m != nil {
-		return m.Oids
+		return m.RevisionPaths
 	}
 	return nil
 }
@@ -350,13 +373,41 @@ func (m *GetBlobsRequest) GetLimit() int64 {
 	return 0
 }
 
+type GetBlobsRequest_RevisionPath struct {
+	Revision string `protobuf:"bytes,1,opt,name=revision" json:"revision,omitempty"`
+	Path     []byte `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+}
+
+func (m *GetBlobsRequest_RevisionPath) Reset()                    { *m = GetBlobsRequest_RevisionPath{} }
+func (m *GetBlobsRequest_RevisionPath) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobsRequest_RevisionPath) ProtoMessage()               {}
+func (*GetBlobsRequest_RevisionPath) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+func (m *GetBlobsRequest_RevisionPath) GetRevision() string {
+	if m != nil {
+		return m.Revision
+	}
+	return ""
+}
+
+func (m *GetBlobsRequest_RevisionPath) GetPath() []byte {
+	if m != nil {
+		return m.Path
+	}
+	return nil
+}
+
 type GetBlobsResponse struct {
 	// Blob size; present only on the first message per blob
 	Size int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
-	// Chunk of blob data
+	// Chunk of blob data, could span over multiple messages.
 	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
 	// Object ID of the current blob. Only present on the first message per blob. Empty if no blob was found.
-	Oid string `protobuf:"bytes,3,opt,name=oid" json:"oid,omitempty"`
+	Oid         string `protobuf:"bytes,3,opt,name=oid" json:"oid,omitempty"`
+	IsSubmodule bool   `protobuf:"varint,4,opt,name=is_submodule,json=isSubmodule" json:"is_submodule,omitempty"`
+	Mode        int32  `protobuf:"varint,5,opt,name=mode" json:"mode,omitempty"`
+	Revision    string `protobuf:"bytes,6,opt,name=revision" json:"revision,omitempty"`
+	Path        []byte `protobuf:"bytes,7,opt,name=path,proto3" json:"path,omitempty"`
 }
 
 func (m *GetBlobsResponse) Reset()                    { *m = GetBlobsResponse{} }
@@ -385,6 +436,34 @@ func (m *GetBlobsResponse) GetOid() string {
 	return ""
 }
 
+func (m *GetBlobsResponse) GetIsSubmodule() bool {
+	if m != nil {
+		return m.IsSubmodule
+	}
+	return false
+}
+
+func (m *GetBlobsResponse) GetMode() int32 {
+	if m != nil {
+		return m.Mode
+	}
+	return 0
+}
+
+func (m *GetBlobsResponse) GetRevision() string {
+	if m != nil {
+		return m.Revision
+	}
+	return ""
+}
+
+func (m *GetBlobsResponse) GetPath() []byte {
+	if m != nil {
+		return m.Path
+	}
+	return nil
+}
+
 type LFSPointer struct {
 	Size int64  `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
 	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
@@ -457,14 +536,124 @@ func (m *GetLFSPointersResponse) GetLfsPointers() []*LFSPointer {
 	return nil
 }
 
+type GetNewLFSPointersRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Revision   []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
+	Limit      int32       `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
+	// Note: When `not_in_all` is true, `not_in_refs` is ignored
+	NotInAll  bool     `protobuf:"varint,4,opt,name=not_in_all,json=notInAll" json:"not_in_all,omitempty"`
+	NotInRefs [][]byte `protobuf:"bytes,5,rep,name=not_in_refs,json=notInRefs,proto3" json:"not_in_refs,omitempty"`
+}
+
+func (m *GetNewLFSPointersRequest) Reset()                    { *m = GetNewLFSPointersRequest{} }
+func (m *GetNewLFSPointersRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetNewLFSPointersRequest) ProtoMessage()               {}
+func (*GetNewLFSPointersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *GetNewLFSPointersRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetNewLFSPointersRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+func (m *GetNewLFSPointersRequest) GetLimit() int32 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
+func (m *GetNewLFSPointersRequest) GetNotInAll() bool {
+	if m != nil {
+		return m.NotInAll
+	}
+	return false
+}
+
+func (m *GetNewLFSPointersRequest) GetNotInRefs() [][]byte {
+	if m != nil {
+		return m.NotInRefs
+	}
+	return nil
+}
+
+type GetNewLFSPointersResponse struct {
+	LfsPointers []*LFSPointer `protobuf:"bytes,1,rep,name=lfs_pointers,json=lfsPointers" json:"lfs_pointers,omitempty"`
+}
+
+func (m *GetNewLFSPointersResponse) Reset()                    { *m = GetNewLFSPointersResponse{} }
+func (m *GetNewLFSPointersResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetNewLFSPointersResponse) ProtoMessage()               {}
+func (*GetNewLFSPointersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *GetNewLFSPointersResponse) GetLfsPointers() []*LFSPointer {
+	if m != nil {
+		return m.LfsPointers
+	}
+	return nil
+}
+
+type GetAllLFSPointersRequest 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 *GetAllLFSPointersRequest) Reset()                    { *m = GetAllLFSPointersRequest{} }
+func (m *GetAllLFSPointersRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetAllLFSPointersRequest) ProtoMessage()               {}
+func (*GetAllLFSPointersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+func (m *GetAllLFSPointersRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetAllLFSPointersRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+type GetAllLFSPointersResponse struct {
+	LfsPointers []*LFSPointer `protobuf:"bytes,1,rep,name=lfs_pointers,json=lfsPointers" json:"lfs_pointers,omitempty"`
+}
+
+func (m *GetAllLFSPointersResponse) Reset()                    { *m = GetAllLFSPointersResponse{} }
+func (m *GetAllLFSPointersResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetAllLFSPointersResponse) ProtoMessage()               {}
+func (*GetAllLFSPointersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+
+func (m *GetAllLFSPointersResponse) GetLfsPointers() []*LFSPointer {
+	if m != nil {
+		return m.LfsPointers
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*GetBlobRequest)(nil), "gitaly.GetBlobRequest")
 	proto.RegisterType((*GetBlobResponse)(nil), "gitaly.GetBlobResponse")
 	proto.RegisterType((*GetBlobsRequest)(nil), "gitaly.GetBlobsRequest")
+	proto.RegisterType((*GetBlobsRequest_RevisionPath)(nil), "gitaly.GetBlobsRequest.RevisionPath")
 	proto.RegisterType((*GetBlobsResponse)(nil), "gitaly.GetBlobsResponse")
 	proto.RegisterType((*LFSPointer)(nil), "gitaly.LFSPointer")
 	proto.RegisterType((*GetLFSPointersRequest)(nil), "gitaly.GetLFSPointersRequest")
 	proto.RegisterType((*GetLFSPointersResponse)(nil), "gitaly.GetLFSPointersResponse")
+	proto.RegisterType((*GetNewLFSPointersRequest)(nil), "gitaly.GetNewLFSPointersRequest")
+	proto.RegisterType((*GetNewLFSPointersResponse)(nil), "gitaly.GetNewLFSPointersResponse")
+	proto.RegisterType((*GetAllLFSPointersRequest)(nil), "gitaly.GetAllLFSPointersRequest")
+	proto.RegisterType((*GetAllLFSPointersResponse)(nil), "gitaly.GetAllLFSPointersResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -482,12 +671,10 @@ type BlobServiceClient interface {
 	// 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)
-	// GetBlobsBySHA returns the contents of a blob objects referenced by their object
-	// ID. We use a stream to return a chunked arbitrarily large binary response.
-	// The blobs are sent in a continous stream, the caller is responsible for spliting
-	// them up into multiple blobs by their object IDs.
 	GetBlobs(ctx context.Context, in *GetBlobsRequest, opts ...grpc.CallOption) (BlobService_GetBlobsClient, error)
 	GetLFSPointers(ctx context.Context, in *GetLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetLFSPointersClient, error)
+	GetNewLFSPointers(ctx context.Context, in *GetNewLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetNewLFSPointersClient, error)
+	GetAllLFSPointers(ctx context.Context, in *GetAllLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetAllLFSPointersClient, error)
 }
 
 type blobServiceClient struct {
@@ -594,6 +781,70 @@ func (x *blobServiceGetLFSPointersClient) Recv() (*GetLFSPointersResponse, error
 	return m, nil
 }
 
+func (c *blobServiceClient) GetNewLFSPointers(ctx context.Context, in *GetNewLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetNewLFSPointersClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[3], c.cc, "/gitaly.BlobService/GetNewLFSPointers", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &blobServiceGetNewLFSPointersClient{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_GetNewLFSPointersClient interface {
+	Recv() (*GetNewLFSPointersResponse, error)
+	grpc.ClientStream
+}
+
+type blobServiceGetNewLFSPointersClient struct {
+	grpc.ClientStream
+}
+
+func (x *blobServiceGetNewLFSPointersClient) Recv() (*GetNewLFSPointersResponse, error) {
+	m := new(GetNewLFSPointersResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *blobServiceClient) GetAllLFSPointers(ctx context.Context, in *GetAllLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetAllLFSPointersClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[4], c.cc, "/gitaly.BlobService/GetAllLFSPointers", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &blobServiceGetAllLFSPointersClient{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_GetAllLFSPointersClient interface {
+	Recv() (*GetAllLFSPointersResponse, error)
+	grpc.ClientStream
+}
+
+type blobServiceGetAllLFSPointersClient struct {
+	grpc.ClientStream
+}
+
+func (x *blobServiceGetAllLFSPointersClient) Recv() (*GetAllLFSPointersResponse, error) {
+	m := new(GetAllLFSPointersResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for BlobService service
 
 type BlobServiceServer interface {
@@ -601,12 +852,10 @@ type BlobServiceServer interface {
 	// ID. We use a stream to return a chunked arbitrarily large binary
 	// response
 	GetBlob(*GetBlobRequest, BlobService_GetBlobServer) error
-	// GetBlobsBySHA returns the contents of a blob objects referenced by their object
-	// ID. We use a stream to return a chunked arbitrarily large binary response.
-	// The blobs are sent in a continous stream, the caller is responsible for spliting
-	// them up into multiple blobs by their object IDs.
 	GetBlobs(*GetBlobsRequest, BlobService_GetBlobsServer) error
 	GetLFSPointers(*GetLFSPointersRequest, BlobService_GetLFSPointersServer) error
+	GetNewLFSPointers(*GetNewLFSPointersRequest, BlobService_GetNewLFSPointersServer) error
+	GetAllLFSPointers(*GetAllLFSPointersRequest, BlobService_GetAllLFSPointersServer) error
 }
 
 func RegisterBlobServiceServer(s *grpc.Server, srv BlobServiceServer) {
@@ -676,6 +925,48 @@ func (x *blobServiceGetLFSPointersServer) Send(m *GetLFSPointersResponse) error
 	return x.ServerStream.SendMsg(m)
 }
 
+func _BlobService_GetNewLFSPointers_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetNewLFSPointersRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(BlobServiceServer).GetNewLFSPointers(m, &blobServiceGetNewLFSPointersServer{stream})
+}
+
+type BlobService_GetNewLFSPointersServer interface {
+	Send(*GetNewLFSPointersResponse) error
+	grpc.ServerStream
+}
+
+type blobServiceGetNewLFSPointersServer struct {
+	grpc.ServerStream
+}
+
+func (x *blobServiceGetNewLFSPointersServer) Send(m *GetNewLFSPointersResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _BlobService_GetAllLFSPointers_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetAllLFSPointersRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(BlobServiceServer).GetAllLFSPointers(m, &blobServiceGetAllLFSPointersServer{stream})
+}
+
+type BlobService_GetAllLFSPointersServer interface {
+	Send(*GetAllLFSPointersResponse) error
+	grpc.ServerStream
+}
+
+type blobServiceGetAllLFSPointersServer struct {
+	grpc.ServerStream
+}
+
+func (x *blobServiceGetAllLFSPointersServer) Send(m *GetAllLFSPointersResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _BlobService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.BlobService",
 	HandlerType: (*BlobServiceServer)(nil),
@@ -696,6 +987,16 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _BlobService_GetLFSPointers_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "GetNewLFSPointers",
+			Handler:       _BlobService_GetNewLFSPointers_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "GetAllLFSPointers",
+			Handler:       _BlobService_GetAllLFSPointers_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "blob.proto",
 }
@@ -703,28 +1004,41 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("blob.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 353 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0xcd, 0x4e, 0xe3, 0x30,
-	0x10, 0x5e, 0xd7, 0xdd, 0xfe, 0x4c, 0xab, 0xdd, 0x6a, 0xb4, 0x5b, 0x42, 0x24, 0x50, 0x94, 0x53,
-	0x4e, 0x15, 0x2a, 0xe2, 0x8a, 0x04, 0x87, 0x56, 0x88, 0x4a, 0x20, 0xf7, 0x01, 0xaa, 0x84, 0xb8,
-	0x60, 0xc9, 0xd4, 0x21, 0x36, 0x48, 0xe5, 0x7d, 0x79, 0x0f, 0x14, 0xa7, 0xf9, 0xa1, 0x55, 0x4f,
-	0xb9, 0x8d, 0x67, 0xe6, 0xfb, 0xc9, 0x17, 0x1b, 0x20, 0x92, 0x2a, 0x9a, 0x24, 0xa9, 0x32, 0x0a,
-	0x3b, 0xcf, 0xc2, 0x84, 0x72, 0xeb, 0x0e, 0xf5, 0x4b, 0x98, 0xf2, 0x38, 0xef, 0xfa, 0x12, 0xfe,
-	0xcc, 0xb9, 0xb9, 0x95, 0x2a, 0x62, 0xfc, 0xed, 0x9d, 0x6b, 0x83, 0x53, 0x80, 0x94, 0x27, 0x4a,
-	0x0b, 0xa3, 0xd2, 0xad, 0x43, 0x3c, 0x12, 0x0c, 0xa6, 0x38, 0xc9, 0xc1, 0x13, 0x56, 0x4e, 0x58,
-	0x6d, 0x0b, 0x47, 0x40, 0x95, 0x88, 0x9d, 0x96, 0x47, 0x82, 0x3e, 0xcb, 0x4a, 0xfc, 0x07, 0xbf,
-	0xa5, 0x78, 0x15, 0xc6, 0xa1, 0x1e, 0x09, 0x28, 0xcb, 0x0f, 0xfe, 0x3d, 0xfc, 0x2d, 0xd5, 0x74,
-	0xa2, 0x36, 0x9a, 0x23, 0x42, 0x5b, 0x8b, 0x4f, 0x6e, 0x85, 0x28, 0xb3, 0x75, 0xd6, 0x8b, 0x43,
-	0x13, 0x5a, 0xbe, 0x21, 0xb3, 0x75, 0x21, 0x41, 0x4b, 0x09, 0x5f, 0x95, 0x64, 0xba, 0x89, 0x77,
-	0x84, 0xb6, 0x12, 0xb1, 0x76, 0x5a, 0x1e, 0x0d, 0xfa, 0xcc, 0xd6, 0x47, 0xdc, 0x2f, 0x60, 0x54,
-	0x09, 0x36, 0xb6, 0x3f, 0x03, 0x58, 0xcc, 0x96, 0x8f, 0x4a, 0x6c, 0x0c, 0x4f, 0x1b, 0xf0, 0xac,
-	0xe1, 0xff, 0x9c, 0x9b, 0x8a, 0xaa, 0x51, 0x18, 0xa7, 0xd0, 0xcb, 0xae, 0xcc, 0xaa, 0x0a, 0xa4,
-	0x9b, 0x9d, 0xef, 0x62, 0xed, 0x3f, 0xc0, 0x78, 0x5f, 0x67, 0x97, 0xc1, 0x15, 0x0c, 0xe5, 0x5a,
-	0xaf, 0x92, 0x5d, 0xdf, 0x21, 0x1e, 0xad, 0x4b, 0x55, 0x10, 0x36, 0x90, 0x6b, 0x5d, 0xc0, 0xa7,
-	0x5f, 0x04, 0x06, 0x59, 0x98, 0x4b, 0x9e, 0x7e, 0x88, 0x27, 0x8e, 0xd7, 0xd0, 0xdd, 0xc5, 0x8b,
-	0xe3, 0x02, 0xfb, 0xf3, 0x6e, 0xba, 0x27, 0x07, 0xfd, 0xdc, 0x82, 0xff, 0xeb, 0x82, 0xe0, 0x0d,
-	0xf4, 0x8a, 0xdf, 0x83, 0xfb, 0x8b, 0x45, 0x28, 0xae, 0x73, 0x38, 0xa8, 0x51, 0x2c, 0xed, 0x6b,
-	0xa8, 0x7d, 0x23, 0x9e, 0xd5, 0xf6, 0x0f, 0x33, 0x76, 0xcf, 0x8f, 0x8d, 0x2b, 0xd2, 0xa8, 0x63,
-	0x5f, 0xda, 0xe5, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xeb, 0x6b, 0x28, 0x11, 0x8d, 0x03, 0x00,
-	0x00,
+	// 572 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0x66, 0xeb, 0xe6, 0x6f, 0x6c, 0x4a, 0x59, 0x41, 0xeb, 0x5a, 0x50, 0xb9, 0x16, 0x07, 0x9f,
+	0x22, 0x14, 0xc4, 0xb5, 0x52, 0x38, 0x34, 0xaa, 0x8a, 0xa0, 0xda, 0x5c, 0x91, 0x2c, 0x07, 0x6f,
+	0xc8, 0xa2, 0x8d, 0x37, 0x78, 0x37, 0x45, 0xe5, 0x6d, 0x78, 0x06, 0xee, 0x3c, 0x0f, 0x8f, 0x81,
+	0xbc, 0xfe, 0xc9, 0xe6, 0x8f, 0x8b, 0xe9, 0x6d, 0x76, 0x66, 0xe7, 0x9b, 0x6f, 0xe6, 0x9b, 0xb5,
+	0x01, 0x26, 0x5c, 0x4c, 0xfa, 0x8b, 0x4c, 0x28, 0x81, 0xdb, 0x5f, 0x98, 0x8a, 0xf9, 0xbd, 0xe7,
+	0xc8, 0x59, 0x9c, 0xd1, 0xa4, 0xf0, 0x06, 0x1c, 0x8e, 0x46, 0x54, 0xbd, 0xe3, 0x62, 0x42, 0xe8,
+	0xb7, 0x25, 0x95, 0x0a, 0x0f, 0x00, 0x32, 0xba, 0x10, 0x92, 0x29, 0x91, 0xdd, 0xbb, 0xc8, 0x47,
+	0xa1, 0x3d, 0xc0, 0xfd, 0x22, 0xb9, 0x4f, 0xea, 0x08, 0x31, 0x6e, 0xe1, 0x63, 0xb0, 0x04, 0x4b,
+	0xdc, 0x03, 0x1f, 0x85, 0x3d, 0x92, 0x9b, 0xf8, 0x19, 0xb4, 0x38, 0x9b, 0x33, 0xe5, 0x5a, 0x3e,
+	0x0a, 0x2d, 0x52, 0x1c, 0x82, 0x1b, 0x78, 0x52, 0x57, 0x93, 0x0b, 0x91, 0x4a, 0x8a, 0x31, 0x1c,
+	0x4a, 0xf6, 0x83, 0xea, 0x42, 0x16, 0xd1, 0x76, 0xee, 0x4b, 0x62, 0x15, 0x6b, 0x3c, 0x87, 0x68,
+	0xbb, 0x2a, 0x61, 0xd5, 0x25, 0x82, 0x3f, 0xa8, 0x46, 0x93, 0x4d, 0xc8, 0xdf, 0xc0, 0x51, 0x46,
+	0xef, 0x98, 0x64, 0x22, 0x8d, 0x16, 0xb1, 0x9a, 0x49, 0xf7, 0xc0, 0xb7, 0x42, 0x7b, 0xf0, 0xaa,
+	0xca, 0xdb, 0x28, 0xd2, 0x27, 0xe5, 0xed, 0xdb, 0x58, 0xcd, 0xc8, 0xe3, 0xcc, 0x38, 0xc9, 0xdd,
+	0x7d, 0x7b, 0x97, 0xe0, 0x98, 0x49, 0xd8, 0x83, 0x6e, 0x95, 0xa6, 0x49, 0xf6, 0x48, 0x7d, 0xce,
+	0x9b, 0xcf, 0x59, 0x54, 0xcd, 0xe7, 0x76, 0xf0, 0x0b, 0xc1, 0xf1, 0x8a, 0x45, 0xd3, 0xc9, 0xe1,
+	0x0b, 0x70, 0x98, 0x8c, 0xe4, 0x72, 0x32, 0x17, 0xc9, 0x92, 0x53, 0xf7, 0xd0, 0x47, 0x61, 0x97,
+	0xd8, 0x4c, 0x8e, 0x2b, 0x57, 0x0e, 0x34, 0x17, 0x09, 0x75, 0x5b, 0x3e, 0x0a, 0x5b, 0x44, 0xdb,
+	0x6b, 0xac, 0xdb, 0x7b, 0x58, 0x77, 0x0c, 0xd6, 0x57, 0x00, 0xef, 0xaf, 0xc6, 0xb7, 0x82, 0xa5,
+	0x8a, 0x66, 0x0d, 0x84, 0x9e, 0xc2, 0xf3, 0x11, 0x55, 0x2b, 0xa8, 0x46, 0x6a, 0x9f, 0x41, 0x37,
+	0x7f, 0x14, 0x11, 0x4b, 0x0a, 0x9d, 0x7b, 0xa4, 0x93, 0x9f, 0xaf, 0x13, 0x19, 0x7c, 0x84, 0x93,
+	0xcd, 0x3a, 0xe5, 0xa8, 0xdf, 0x82, 0xc3, 0xa7, 0x32, 0x5a, 0x94, 0x7e, 0x17, 0xe9, 0x05, 0xa9,
+	0x4b, 0xad, 0x52, 0x88, 0xcd, 0xa7, 0xb2, 0x4a, 0x0f, 0x7e, 0x23, 0x70, 0x47, 0x54, 0x7d, 0xa0,
+	0xdf, 0xff, 0x13, 0x79, 0x53, 0x81, 0x62, 0x66, 0x2b, 0x05, 0xd6, 0x36, 0xaf, 0x55, 0x6e, 0x1e,
+	0x7e, 0x01, 0x90, 0x0a, 0x15, 0xb1, 0x34, 0x8a, 0x39, 0x2f, 0x85, 0xee, 0xa6, 0x42, 0x5d, 0xa7,
+	0x43, 0xce, 0xf1, 0x39, 0xd8, 0x65, 0x34, 0xa3, 0x53, 0xe9, 0xb6, 0x7c, 0x2b, 0x74, 0x48, 0x4f,
+	0x87, 0x09, 0x9d, 0xca, 0x80, 0xc0, 0xd9, 0x0e, 0xfe, 0xcd, 0x86, 0xf2, 0x55, 0xcf, 0x64, 0xc8,
+	0xf9, 0xc3, 0xcf, 0xa4, 0xe4, 0xbf, 0x59, 0xab, 0x11, 0xff, 0xc1, 0x4f, 0x0b, 0xec, 0xfc, 0x21,
+	0x8e, 0x69, 0x76, 0xc7, 0x3e, 0x53, 0x7c, 0x09, 0x9d, 0xf2, 0x69, 0xe2, 0x93, 0x8d, 0x2f, 0x46,
+	0xd9, 0x96, 0x77, 0xba, 0xe5, 0x2f, 0x28, 0x04, 0x8f, 0x5e, 0x23, 0x3c, 0x84, 0x6e, 0xf5, 0xb4,
+	0xf1, 0xe9, 0x9e, 0x4f, 0x8e, 0xe7, 0x6e, 0x07, 0x0c, 0x88, 0xb1, 0xfe, 0x88, 0x1b, 0x3d, 0xe2,
+	0x97, 0xc6, 0xfd, 0xed, 0x39, 0x7b, 0xe7, 0xfb, 0xc2, 0x06, 0xe8, 0x27, 0x78, 0xba, 0xa5, 0x3d,
+	0xf6, 0x8d, 0xc4, 0x9d, 0x6b, 0xed, 0x5d, 0xfc, 0xe3, 0xc6, 0x16, 0xfa, 0xba, 0x32, 0x6b, 0xe8,
+	0x3b, 0x17, 0x64, 0x0d, 0x7d, 0xb7, 0xac, 0x39, 0xfa, 0xa4, 0xad, 0x7f, 0x6e, 0x6f, 0xfe, 0x06,
+	0x00, 0x00, 0xff, 0xff, 0x7a, 0x21, 0xd1, 0xac, 0x00, 0x07, 0x00, 0x00,
 }

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

@@ -350,6 +350,8 @@ type CountCommitsRequest struct {
 	Before     *google_protobuf.Timestamp `protobuf:"bytes,4,opt,name=before" json:"before,omitempty"`
 	Path       []byte                     `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
 	MaxCount   int32                      `protobuf:"varint,6,opt,name=max_count,json=maxCount" json:"max_count,omitempty"`
+	// all and revision are mutually exclusive
+	All bool `protobuf:"varint,7,opt,name=all" json:"all,omitempty"`
 }
 
 func (m *CountCommitsRequest) Reset()                    { *m = CountCommitsRequest{} }
@@ -399,6 +401,13 @@ func (m *CountCommitsRequest) GetMaxCount() int32 {
 	return 0
 }
 
+func (m *CountCommitsRequest) GetAll() bool {
+	if m != nil {
+		return m.All
+	}
+	return false
+}
+
 type CountCommitsResponse struct {
 	Count int32 `protobuf:"varint,1,opt,name=count" json:"count,omitempty"`
 }
@@ -489,6 +498,7 @@ 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"`
+	Recursive  bool        `protobuf:"varint,4,opt,name=recursive" json:"recursive,omitempty"`
 }
 
 func (m *GetTreeEntriesRequest) Reset()                    { *m = GetTreeEntriesRequest{} }
@@ -517,6 +527,13 @@ func (m *GetTreeEntriesRequest) GetPath() []byte {
 	return nil
 }
 
+func (m *GetTreeEntriesRequest) GetRecursive() bool {
+	if m != nil {
+		return m.Recursive
+	}
+	return false
+}
+
 type GetTreeEntriesResponse struct {
 	Entries []*TreeEntry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
 }
@@ -733,6 +750,8 @@ type FindCommitsRequest struct {
 	DisableWalk bool                       `protobuf:"varint,8,opt,name=disable_walk,json=disableWalk" json:"disable_walk,omitempty"`
 	After       *google_protobuf.Timestamp `protobuf:"bytes,9,opt,name=after" json:"after,omitempty"`
 	Before      *google_protobuf.Timestamp `protobuf:"bytes,10,opt,name=before" json:"before,omitempty"`
+	// all and revision are mutually exclusive
+	All bool `protobuf:"varint,11,opt,name=all" json:"all,omitempty"`
 }
 
 func (m *FindCommitsRequest) Reset()                    { *m = FindCommitsRequest{} }
@@ -810,6 +829,13 @@ func (m *FindCommitsRequest) GetBefore() *google_protobuf.Timestamp {
 	return nil
 }
 
+func (m *FindCommitsRequest) GetAll() bool {
+	if m != nil {
+		return m.All
+	}
+	return false
+}
+
 // A single 'page' of the result set
 type FindCommitsResponse struct {
 	Commits []*GitCommit `protobuf:"bytes,1,rep,name=commits" json:"commits,omitempty"`
@@ -1165,6 +1191,64 @@ func (m *ExtractCommitSignatureResponse) GetSignedText() []byte {
 	return nil
 }
 
+type GetCommitSignaturesRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	CommitIds  []string    `protobuf:"bytes,2,rep,name=commit_ids,json=commitIds" json:"commit_ids,omitempty"`
+}
+
+func (m *GetCommitSignaturesRequest) Reset()                    { *m = GetCommitSignaturesRequest{} }
+func (m *GetCommitSignaturesRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetCommitSignaturesRequest) ProtoMessage()               {}
+func (*GetCommitSignaturesRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{35} }
+
+func (m *GetCommitSignaturesRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetCommitSignaturesRequest) GetCommitIds() []string {
+	if m != nil {
+		return m.CommitIds
+	}
+	return nil
+}
+
+type GetCommitSignaturesResponse struct {
+	// Only present for a new commit signature data.
+	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
+	// See ExtractCommitSignatureResponse above for how these fields should be handled.
+	Signature  []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	SignedText []byte `protobuf:"bytes,3,opt,name=signed_text,json=signedText,proto3" json:"signed_text,omitempty"`
+}
+
+func (m *GetCommitSignaturesResponse) Reset()                    { *m = GetCommitSignaturesResponse{} }
+func (m *GetCommitSignaturesResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetCommitSignaturesResponse) ProtoMessage()               {}
+func (*GetCommitSignaturesResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{36} }
+
+func (m *GetCommitSignaturesResponse) GetCommitId() string {
+	if m != nil {
+		return m.CommitId
+	}
+	return ""
+}
+
+func (m *GetCommitSignaturesResponse) GetSignature() []byte {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+func (m *GetCommitSignaturesResponse) GetSignedText() []byte {
+	if m != nil {
+		return m.SignedText
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*CommitStatsRequest)(nil), "gitaly.CommitStatsRequest")
 	proto.RegisterType((*CommitStatsResponse)(nil), "gitaly.CommitStatsResponse")
@@ -1202,6 +1286,8 @@ func init() {
 	proto.RegisterType((*FilterShasWithSignaturesResponse)(nil), "gitaly.FilterShasWithSignaturesResponse")
 	proto.RegisterType((*ExtractCommitSignatureRequest)(nil), "gitaly.ExtractCommitSignatureRequest")
 	proto.RegisterType((*ExtractCommitSignatureResponse)(nil), "gitaly.ExtractCommitSignatureResponse")
+	proto.RegisterType((*GetCommitSignaturesRequest)(nil), "gitaly.GetCommitSignaturesRequest")
+	proto.RegisterType((*GetCommitSignaturesResponse)(nil), "gitaly.GetCommitSignaturesResponse")
 	proto.RegisterEnum("gitaly.TreeEntryResponse_ObjectType", TreeEntryResponse_ObjectType_name, TreeEntryResponse_ObjectType_value)
 	proto.RegisterEnum("gitaly.TreeEntry_EntryType", TreeEntry_EntryType_name, TreeEntry_EntryType_value)
 	proto.RegisterEnum("gitaly.FindAllCommitsRequest_Order", FindAllCommitsRequest_Order_name, FindAllCommitsRequest_Order_value)
@@ -1239,6 +1325,7 @@ type CommitServiceClient interface {
 	// arbitrarily large and signature verification is impossible without the
 	// full text.
 	ExtractCommitSignature(ctx context.Context, in *ExtractCommitSignatureRequest, opts ...grpc.CallOption) (CommitService_ExtractCommitSignatureClient, error)
+	GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error)
 }
 
 type commitServiceClient struct {
@@ -1654,6 +1741,38 @@ func (x *commitServiceExtractCommitSignatureClient) Recv() (*ExtractCommitSignat
 	return m, nil
 }
 
+func (c *commitServiceClient) GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[11], c.cc, "/gitaly.CommitService/GetCommitSignatures", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &commitServiceGetCommitSignaturesClient{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_GetCommitSignaturesClient interface {
+	Recv() (*GetCommitSignaturesResponse, error)
+	grpc.ClientStream
+}
+
+type commitServiceGetCommitSignaturesClient struct {
+	grpc.ClientStream
+}
+
+func (x *commitServiceGetCommitSignaturesClient) Recv() (*GetCommitSignaturesResponse, error) {
+	m := new(GetCommitSignaturesResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for CommitService service
 
 type CommitServiceServer interface {
@@ -1678,6 +1797,7 @@ type CommitServiceServer interface {
 	// arbitrarily large and signature verification is impossible without the
 	// full text.
 	ExtractCommitSignature(*ExtractCommitSignatureRequest, CommitService_ExtractCommitSignatureServer) error
+	GetCommitSignatures(*GetCommitSignaturesRequest, CommitService_GetCommitSignaturesServer) error
 }
 
 func RegisterCommitServiceServer(s *grpc.Server, srv CommitServiceServer) {
@@ -2028,6 +2148,27 @@ func (x *commitServiceExtractCommitSignatureServer) Send(m *ExtractCommitSignatu
 	return x.ServerStream.SendMsg(m)
 }
 
+func _CommitService_GetCommitSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetCommitSignaturesRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(CommitServiceServer).GetCommitSignatures(m, &commitServiceGetCommitSignaturesServer{stream})
+}
+
+type CommitService_GetCommitSignaturesServer interface {
+	Send(*GetCommitSignaturesResponse) error
+	grpc.ServerStream
+}
+
+type commitServiceGetCommitSignaturesServer struct {
+	grpc.ServerStream
+}
+
+func (x *commitServiceGetCommitSignaturesServer) Send(m *GetCommitSignaturesResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _CommitService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.CommitService",
 	HandlerType: (*CommitServiceServer)(nil),
@@ -2114,6 +2255,11 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _CommitService_ExtractCommitSignature_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "GetCommitSignatures",
+			Handler:       _CommitService_GetCommitSignatures_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "commit.proto",
 }
@@ -2121,103 +2267,109 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("commit.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
-	// 1559 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0x1a, 0x47,
-	0x14, 0xf6, 0x82, 0xc1, 0x70, 0xa0, 0x0e, 0x9e, 0xfc, 0xe1, 0x75, 0x12, 0x3b, 0xdb, 0x26, 0x25,
-	0x4a, 0x45, 0x2c, 0xaa, 0x56, 0xed, 0x55, 0x65, 0x27, 0xd8, 0x75, 0x6a, 0x87, 0x68, 0x8d, 0x14,
-	0xa5, 0x37, 0x68, 0xcc, 0x0e, 0x30, 0xf5, 0xc2, 0x92, 0xdd, 0x21, 0x36, 0xad, 0xd4, 0xfb, 0x4a,
-	0x7d, 0x92, 0x4a, 0x7d, 0x88, 0xbe, 0x42, 0x1f, 0xa3, 0x8f, 0x10, 0xf5, 0xa2, 0x9a, 0x9f, 0xdd,
-	0x59, 0x60, 0x71, 0x1a, 0x5b, 0xe4, 0x06, 0xed, 0x9c, 0x99, 0x39, 0xe7, 0x3b, 0x67, 0xce, 0x2f,
-	0x50, 0x6c, 0x7b, 0xfd, 0x3e, 0x65, 0xd5, 0xa1, 0xef, 0x31, 0x0f, 0x65, 0xbb, 0x94, 0x61, 0x77,
-	0x6c, 0x16, 0x83, 0x1e, 0xf6, 0x89, 0x23, 0xa9, 0xe6, 0x66, 0xd7, 0xf3, 0xba, 0x2e, 0x79, 0x22,
-	0x56, 0x27, 0xa3, 0xce, 0x13, 0x46, 0xfb, 0x24, 0x60, 0xb8, 0x3f, 0x94, 0x07, 0x2c, 0x07, 0xd0,
-	0x53, 0xc1, 0xe6, 0x98, 0x61, 0x16, 0xd8, 0xe4, 0xcd, 0x88, 0x04, 0x0c, 0xd5, 0x00, 0x7c, 0x32,
-	0xf4, 0x02, 0xca, 0x3c, 0x7f, 0x5c, 0x36, 0xb6, 0x8c, 0x4a, 0xa1, 0x86, 0xaa, 0x52, 0x42, 0xd5,
-	0x8e, 0x76, 0xec, 0xd8, 0x29, 0x64, 0x42, 0xce, 0x27, 0x6f, 0x69, 0x40, 0xbd, 0x41, 0x39, 0xb5,
-	0x65, 0x54, 0x8a, 0x76, 0xb4, 0xb6, 0xda, 0x70, 0x7d, 0x42, 0x4a, 0x30, 0xf4, 0x06, 0x01, 0x41,
-	0x25, 0x48, 0x7b, 0xd4, 0x11, 0xfc, 0xf3, 0x36, 0xff, 0x44, 0x77, 0x20, 0x8f, 0x1d, 0x87, 0x32,
-	0xea, 0x0d, 0x02, 0xc1, 0x25, 0x63, 0x6b, 0x02, 0xdf, 0x75, 0x88, 0x4b, 0xe4, 0x6e, 0x5a, 0xee,
-	0x46, 0x04, 0xeb, 0x37, 0x03, 0x6e, 0x4b, 0x29, 0x07, 0xc1, 0xce, 0xa0, 0x4d, 0x02, 0xe6, 0xf9,
-	0x57, 0x51, 0x68, 0x13, 0x0a, 0x58, 0xb1, 0x69, 0x51, 0x47, 0xa0, 0xc9, 0xdb, 0x10, 0x92, 0x0e,
-	0x1c, 0xb4, 0x0e, 0xb9, 0x76, 0x8f, 0xba, 0x0e, 0xdf, 0x4d, 0x8b, 0xdd, 0x15, 0xb1, 0x3e, 0x70,
-	0xac, 0x6d, 0x28, 0xcf, 0x42, 0x51, 0x5a, 0xdf, 0x80, 0xcc, 0x5b, 0xec, 0x8e, 0x88, 0x80, 0x91,
-	0xb3, 0xe5, 0xc2, 0xfa, 0xdd, 0x80, 0x52, 0xd3, 0x27, 0xa4, 0x3e, 0x60, 0xfe, 0x78, 0x41, 0xef,
-	0x80, 0x10, 0x2c, 0x0f, 0x31, 0xeb, 0x09, 0xb4, 0x45, 0x5b, 0x7c, 0x73, 0x38, 0x2e, 0xed, 0x53,
-	0x56, 0x5e, 0xde, 0x32, 0x2a, 0x69, 0x5b, 0x2e, 0xac, 0xbf, 0x0d, 0x58, 0x8b, 0xc1, 0x51, 0xd0,
-	0xbf, 0x81, 0x65, 0x36, 0x1e, 0x4a, 0xe4, 0xab, 0xb5, 0xcf, 0x42, 0x24, 0x33, 0x07, 0xab, 0x8d,
-	0x93, 0x9f, 0x48, 0x9b, 0x35, 0xc7, 0x43, 0x62, 0x8b, 0x1b, 0xe1, 0x53, 0xa7, 0xf4, 0x53, 0x23,
-	0x58, 0x0e, 0xe8, 0xcf, 0x44, 0x60, 0x49, 0xdb, 0xe2, 0x9b, 0xd3, 0xfa, 0x9e, 0x43, 0x04, 0x94,
-	0x8c, 0x2d, 0xbe, 0x39, 0xcd, 0xc1, 0x0c, 0x97, 0x33, 0x12, 0x33, 0xff, 0xb6, 0xbe, 0x02, 0xd0,
-	0x12, 0x10, 0x40, 0xf6, 0x69, 0xe3, 0xe8, 0xe8, 0xa0, 0x59, 0x5a, 0x42, 0x39, 0x58, 0xde, 0x3d,
-	0x6c, 0xec, 0x96, 0x0c, 0xfe, 0xd5, 0xb4, 0xeb, 0xf5, 0x52, 0x0a, 0xad, 0x40, 0xba, 0xb9, 0xb3,
-	0x5f, 0x4a, 0x5b, 0x1e, 0xdc, 0x94, 0xaf, 0x12, 0xec, 0x12, 0x76, 0x46, 0xc8, 0xe0, 0x2a, 0x76,
-	0x46, 0xb0, 0xdc, 0xf1, 0xbd, 0xbe, 0xb2, 0xb1, 0xf8, 0x46, 0xab, 0x90, 0x62, 0x9e, 0xb2, 0x6e,
-	0x8a, 0x79, 0x56, 0x1d, 0x6e, 0x4d, 0x0b, 0x54, 0x96, 0x7c, 0x0c, 0x2b, 0x32, 0x7c, 0x83, 0xb2,
-	0xb1, 0x95, 0xae, 0x14, 0x6a, 0x6b, 0xa1, 0xb8, 0x7d, 0xca, 0xe4, 0x1d, 0x3b, 0x3c, 0x61, 0xfd,
-	0x6b, 0xf0, 0xf8, 0x19, 0x0d, 0xd4, 0xc6, 0xa2, 0xc2, 0x14, 0x6d, 0x43, 0x06, 0x77, 0x18, 0xf1,
-	0x85, 0x06, 0x85, 0x9a, 0x59, 0x95, 0xd9, 0xa3, 0x1a, 0x66, 0x8f, 0x6a, 0x33, 0xcc, 0x1e, 0xb6,
-	0x3c, 0x88, 0x6a, 0x90, 0x3d, 0x21, 0x1d, 0xcf, 0x97, 0x4f, 0x76, 0xf1, 0x15, 0x75, 0x32, 0x72,
-	0xc2, 0x4c, 0xcc, 0x09, 0x37, 0x20, 0xdf, 0xc7, 0xe7, 0xad, 0x36, 0x57, 0xb2, 0x9c, 0x15, 0xaf,
-	0x9f, 0xeb, 0xe3, 0x73, 0xa1, 0xb4, 0xf5, 0x05, 0xdc, 0x98, 0xd4, 0x5e, 0x07, 0x92, 0xbc, 0x60,
-	0x88, 0x0b, 0x72, 0x61, 0xbd, 0x33, 0x20, 0x1f, 0x39, 0x64, 0x42, 0x8a, 0x59, 0x87, 0x9c, 0xef,
-	0x79, 0xac, 0xa5, 0xdd, 0x71, 0x85, 0xaf, 0x1b, 0xd2, 0x25, 0x67, 0xc2, 0xe3, 0x89, 0x72, 0xf9,
-	0x65, 0xe1, 0xf2, 0x1b, 0x33, 0x2e, 0x5f, 0x15, 0xbf, 0x31, 0x4f, 0x0f, 0x7d, 0x38, 0x13, 0xf3,
-	0xe1, 0xbb, 0x00, 0xf2, 0x2d, 0x85, 0xd4, 0xac, 0x90, 0x9a, 0x97, 0x14, 0x2e, 0x77, 0x03, 0xf2,
-	0x1d, 0x17, 0xb3, 0x96, 0x10, 0xbe, 0x22, 0x1f, 0x85, 0x13, 0x5e, 0x62, 0xd6, 0xb3, 0x1e, 0x43,
-	0x3e, 0x12, 0x11, 0xb9, 0xf7, 0x52, 0xe4, 0xde, 0x46, 0xcc, 0xfd, 0xd3, 0xd6, 0x2f, 0x70, 0x73,
-	0x9f, 0xb0, 0x10, 0x1c, 0x25, 0xc1, 0x47, 0xcc, 0x24, 0xdc, 0xdb, 0xa7, 0x85, 0x6b, 0x6f, 0x27,
-	0x92, 0x34, 0xed, 0xed, 0x3a, 0x75, 0x84, 0x27, 0xac, 0x13, 0x28, 0x1d, 0xd2, 0x80, 0xed, 0x51,
-	0x77, 0x61, 0xf0, 0xad, 0x47, 0xb0, 0x16, 0x93, 0xa1, 0xfd, 0x89, 0xeb, 0x21, 0x31, 0x16, 0x6d,
-	0xb9, 0xb0, 0xda, 0xb0, 0xb6, 0x47, 0x07, 0x8e, 0x8a, 0xc9, 0x05, 0xe1, 0xf9, 0x0e, 0x50, 0x5c,
-	0x88, 0x02, 0xf4, 0x08, 0xb2, 0xd2, 0x49, 0x94, 0x84, 0x84, 0x1c, 0xa1, 0x0e, 0x58, 0x2d, 0xb8,
-	0xcd, 0x15, 0x0a, 0xb3, 0xcd, 0xb8, 0x41, 0x9d, 0xab, 0x60, 0x8d, 0xd2, 0x75, 0x5a, 0x85, 0x8d,
-	0xb5, 0x0f, 0xe5, 0x59, 0x01, 0x97, 0x49, 0x66, 0xef, 0x0c, 0xb8, 0xc9, 0x75, 0xdd, 0x71, 0xdd,
-	0x05, 0xa7, 0xb3, 0x89, 0xa4, 0x92, 0x9e, 0x4c, 0x2a, 0xa2, 0xfc, 0x9c, 0xd2, 0x61, 0x58, 0x6a,
-	0xf8, 0x37, 0xfa, 0x16, 0x32, 0x9e, 0xef, 0x10, 0x5f, 0xc4, 0xee, 0x6a, 0xed, 0xd3, 0x50, 0x76,
-	0x22, 0xdc, 0x6a, 0x83, 0x1f, 0xb5, 0xe5, 0x0d, 0xeb, 0x01, 0x64, 0xc4, 0x9a, 0xc7, 0xe5, 0x8b,
-	0xc6, 0x8b, 0xba, 0x8a, 0xd0, 0xc6, 0xcb, 0x86, 0x2c, 0x45, 0xcf, 0x76, 0x9a, 0xf5, 0x52, 0x8a,
-	0x87, 0xc8, 0x34, 0xb3, 0xcb, 0xd8, 0xf0, 0x9f, 0x54, 0xdc, 0x5f, 0x16, 0x66, 0xc0, 0xa8, 0x35,
-	0x90, 0xc6, 0x93, 0x0b, 0x74, 0x0b, 0xb2, 0x5e, 0xa7, 0x13, 0x10, 0xa6, 0x6c, 0xa7, 0x56, 0x3a,
-	0x7c, 0x32, 0xb1, 0xf0, 0xe1, 0xa7, 0x3b, 0x9e, 0xeb, 0x7a, 0x67, 0x22, 0xed, 0xe5, 0x6c, 0xb5,
-	0xe2, 0xdd, 0x15, 0xb7, 0x79, 0xab, 0x4f, 0xfc, 0x2e, 0x09, 0x44, 0xd6, 0xcb, 0xd9, 0xc0, 0x49,
-	0x47, 0x82, 0x82, 0xee, 0x43, 0xd1, 0xa1, 0x01, 0x3e, 0x71, 0x49, 0xeb, 0x0c, 0xbb, 0xa7, 0xe5,
-	0x9c, 0x38, 0x51, 0x50, 0xb4, 0x57, 0xd8, 0x3d, 0xd5, 0xf5, 0x2a, 0xff, 0xe1, 0xf5, 0x0a, 0xfe,
-	0x6f, 0xbd, 0xb2, 0x76, 0xe1, 0xfa, 0x84, 0xad, 0x2f, 0xf3, 0x60, 0xbd, 0xb0, 0x11, 0x38, 0xc4,
-	0x83, 0xee, 0x08, 0x77, 0x17, 0x97, 0xd9, 0xfe, 0x8c, 0xba, 0xe0, 0x98, 0x28, 0x05, 0x79, 0x0f,
-	0xf2, 0x6e, 0x48, 0x54, 0xa0, 0x2b, 0xa1, 0xa8, 0x39, 0x77, 0xaa, 0x21, 0xc5, 0xd6, 0x57, 0xcd,
-	0xe7, 0x90, 0x0b, 0xc9, 0x3c, 0x8e, 0x06, 0xb8, 0x4f, 0x54, 0x85, 0x15, 0xdf, 0xdc, 0x13, 0xc4,
-	0x14, 0x22, 0xc0, 0xa5, 0x6c, 0xb9, 0x90, 0xe5, 0xda, 0xf5, 0x7c, 0xd5, 0x2b, 0xcb, 0x85, 0x35,
-	0x82, 0x6b, 0x36, 0x3e, 0xdb, 0x75, 0x71, 0x9f, 0x7c, 0xcc, 0x5a, 0xf5, 0x10, 0x4a, 0x5a, 0xac,
-	0x32, 0x4f, 0xd8, 0x69, 0x1a, 0xb1, 0x4e, 0xf3, 0x57, 0x28, 0x1f, 0xe2, 0x30, 0xed, 0xed, 0x79,
-	0x3e, 0x2f, 0xc9, 0x1f, 0x13, 0xe7, 0x1e, 0xac, 0x27, 0xc8, 0xff, 0xf0, 0xfa, 0xf0, 0x57, 0xe4,
-	0x16, 0xc1, 0xee, 0xf8, 0x88, 0x04, 0x01, 0x7f, 0xd2, 0x05, 0xe9, 0xa1, 0x13, 0x44, 0x7a, 0x3a,
-	0x41, 0xe8, 0x49, 0x23, 0x4a, 0x27, 0x49, 0xed, 0xe0, 0x0d, 0xc8, 0xbc, 0x19, 0x11, 0x7f, 0xac,
-	0x5a, 0x25, 0xb9, 0xe0, 0x25, 0x68, 0x56, 0x85, 0xcb, 0x44, 0x23, 0x85, 0xcd, 0x3d, 0xea, 0x32,
-	0xe2, 0x1f, 0xf7, 0x70, 0xf0, 0x8a, 0xb2, 0xde, 0x31, 0xed, 0x0e, 0x30, 0x1b, 0xf9, 0x57, 0x0b,
-	0x4b, 0x5e, 0x52, 0x7a, 0x38, 0x10, 0x55, 0xb3, 0x68, 0x8b, 0x6f, 0xeb, 0x6b, 0xd8, 0x9a, 0x2f,
-	0x4a, 0xfb, 0x9d, 0xb8, 0x67, 0xc4, 0xee, 0x0d, 0xe1, 0x6e, 0xfd, 0x9c, 0xf9, 0xb8, 0xad, 0xc0,
-	0x47, 0xd7, 0xae, 0x02, 0x70, 0x03, 0x54, 0xd3, 0xa9, 0xe7, 0xd9, 0x9c, 0x24, 0x1c, 0x38, 0x56,
-	0x0b, 0xee, 0xcd, 0x93, 0xa8, 0x70, 0xde, 0x81, 0x7c, 0x10, 0x12, 0x55, 0x90, 0x68, 0x82, 0x48,
-	0xe8, 0xb4, 0x3b, 0x20, 0x4e, 0x8b, 0x91, 0x73, 0xa6, 0x9c, 0x02, 0x24, 0xa9, 0x49, 0xce, 0x59,
-	0xed, 0x8f, 0x02, 0x7c, 0xa2, 0x58, 0x13, 0xff, 0x2d, 0x6d, 0x13, 0xf4, 0x0a, 0x4a, 0xd3, 0x53,
-	0x32, 0xda, 0x9c, 0x4c, 0x48, 0x33, 0xa3, 0xbc, 0xb9, 0x35, 0xff, 0x80, 0xc4, 0x69, 0x2d, 0xa1,
-	0x67, 0xf1, 0x11, 0xa0, 0x9c, 0x30, 0xa6, 0x4a, 0x56, 0xeb, 0x73, 0x07, 0x58, 0x6b, 0x69, 0xdb,
-	0x40, 0xc7, 0xb0, 0x3a, 0x39, 0xbd, 0xa1, 0xbb, 0x93, 0xb2, 0xa7, 0xc6, 0x48, 0xf3, 0xde, 0xbc,
-	0xed, 0x18, 0xd3, 0x1f, 0xa0, 0x18, 0x1f, 0x66, 0xd0, 0x86, 0xbe, 0x33, 0x33, 0xe0, 0x99, 0x77,
-	0x92, 0x37, 0x23, 0x3d, 0x8f, 0x61, 0x75, 0xb2, 0xe3, 0xd6, 0x08, 0x13, 0xc7, 0x00, 0x8d, 0x30,
-	0xb9, 0x51, 0x17, 0x08, 0x9f, 0x41, 0x3e, 0xea, 0x8d, 0xb5, 0xf1, 0xa6, 0x5b, 0x72, 0x6d, 0xbc,
-	0x99, 0x46, 0x5a, 0x70, 0xa9, 0x03, 0xe8, 0xaa, 0x89, 0xd6, 0xe3, 0xad, 0xd4, 0x44, 0x2b, 0x6d,
-	0x9a, 0x49, 0x5b, 0x91, 0x86, 0xdf, 0x43, 0x21, 0xf6, 0xcf, 0x11, 0x32, 0x27, 0x2d, 0x1c, 0xff,
-	0xd3, 0xca, 0xdc, 0x48, 0xdc, 0x8b, 0xdb, 0x6a, 0xb2, 0xf5, 0xd2, 0xb6, 0x4a, 0xec, 0xef, 0xb4,
-	0xad, 0x92, 0x3b, 0x36, 0xa1, 0xe5, 0x73, 0x28, 0xc4, 0x7a, 0x03, 0x94, 0xa0, 0xcb, 0x2c, 0xbc,
-	0x84, 0x66, 0x42, 0xf0, 0x6a, 0xc2, 0xb5, 0xa9, 0x22, 0x8c, 0xee, 0xcd, 0xad, 0xce, 0x92, 0xe7,
-	0xe6, 0x7b, 0xaa, 0xb7, 0xb5, 0x84, 0x76, 0x20, 0x17, 0x16, 0x3a, 0x74, 0x3b, 0xca, 0x0f, 0x93,
-	0x15, 0xd7, 0x2c, 0xcf, 0x6e, 0xc4, 0x80, 0xfd, 0x08, 0x6b, 0x33, 0x35, 0x08, 0x45, 0x61, 0x38,
-	0xaf, 0x3c, 0x9a, 0xf7, 0x2f, 0x38, 0x11, 0xc1, 0x7b, 0x1d, 0xa6, 0x00, 0x9d, 0xd3, 0xa7, 0x53,
-	0xc0, 0x4c, 0xc1, 0x9a, 0x4e, 0x01, 0xb3, 0xe5, 0x40, 0xc0, 0x7e, 0x2d, 0xe7, 0xc8, 0xf8, 0xc4,
-	0xa2, 0x59, 0xcf, 0x19, 0x96, 0x34, 0xeb, 0x79, 0xc3, 0x8e, 0x60, 0x1d, 0x40, 0x79, 0x5e, 0x56,
-	0x47, 0x9f, 0xeb, 0x77, 0xbe, 0xb0, 0xc4, 0x98, 0x95, 0xf7, 0x1f, 0x0c, 0x45, 0x56, 0x8c, 0x6d,
-	0x03, 0x9d, 0xc2, 0xad, 0xe4, 0x04, 0x8d, 0x1e, 0x84, 0x9c, 0x2e, 0x2c, 0x19, 0xe6, 0xc3, 0xf7,
-	0x1d, 0xd3, 0x1a, 0x9e, 0x64, 0x45, 0x43, 0xfc, 0xe5, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc0,
-	0x6e, 0x68, 0x46, 0x65, 0x16, 0x00, 0x00,
+	// 1650 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5f, 0x6f, 0x1a, 0xc7,
+	0x16, 0xf7, 0x82, 0xc1, 0x70, 0xe0, 0x3a, 0x78, 0xf2, 0x0f, 0xaf, 0x9d, 0xd8, 0x99, 0xdc, 0xe4,
+	0x3a, 0xca, 0x15, 0xb1, 0xb8, 0xba, 0x55, 0xfb, 0x54, 0xd9, 0x09, 0x76, 0x9d, 0xda, 0x21, 0x5a,
+	0x23, 0x45, 0xe9, 0x0b, 0x5a, 0xb3, 0x03, 0x4c, 0xbd, 0xb0, 0x64, 0x77, 0xb0, 0x4d, 0x1f, 0xfa,
+	0x5e, 0xa9, 0xca, 0x7b, 0x3f, 0x44, 0x3f, 0x44, 0xbf, 0x42, 0x3f, 0x4e, 0xd4, 0x87, 0x6a, 0xfe,
+	0xec, 0xce, 0x02, 0x8b, 0xdd, 0xd8, 0x22, 0x2f, 0x68, 0xe6, 0xcc, 0xec, 0x39, 0xbf, 0x73, 0xe6,
+	0xfc, 0x05, 0x8a, 0x2d, 0xaf, 0xd7, 0xa3, 0xac, 0x32, 0xf0, 0x3d, 0xe6, 0xa1, 0x6c, 0x87, 0x32,
+	0xdb, 0x1d, 0x99, 0xc5, 0xa0, 0x6b, 0xfb, 0xc4, 0x91, 0x54, 0x73, 0xa3, 0xe3, 0x79, 0x1d, 0x97,
+	0xbc, 0x10, 0xbb, 0x93, 0x61, 0xfb, 0x05, 0xa3, 0x3d, 0x12, 0x30, 0xbb, 0x37, 0x90, 0x17, 0xb0,
+	0x03, 0xe8, 0xa5, 0x60, 0x73, 0xcc, 0x6c, 0x16, 0x58, 0xe4, 0xc3, 0x90, 0x04, 0x0c, 0x55, 0x01,
+	0x7c, 0x32, 0xf0, 0x02, 0xca, 0x3c, 0x7f, 0x54, 0x36, 0x36, 0x8d, 0xad, 0x42, 0x15, 0x55, 0xa4,
+	0x84, 0x8a, 0x15, 0x9d, 0x58, 0xb1, 0x5b, 0xc8, 0x84, 0x9c, 0x4f, 0xce, 0x68, 0x40, 0xbd, 0x7e,
+	0x39, 0xb5, 0x69, 0x6c, 0x15, 0xad, 0x68, 0x8f, 0x5b, 0x70, 0x7b, 0x4c, 0x4a, 0x30, 0xf0, 0xfa,
+	0x01, 0x41, 0x25, 0x48, 0x7b, 0xd4, 0x11, 0xfc, 0xf3, 0x16, 0x5f, 0xa2, 0x75, 0xc8, 0xdb, 0x8e,
+	0x43, 0x19, 0xf5, 0xfa, 0x81, 0xe0, 0x92, 0xb1, 0x34, 0x81, 0x9f, 0x3a, 0xc4, 0x25, 0xf2, 0x34,
+	0x2d, 0x4f, 0x23, 0x02, 0xfe, 0xc5, 0x80, 0xfb, 0x52, 0xca, 0x41, 0xb0, 0xd3, 0x6f, 0x91, 0x80,
+	0x79, 0xfe, 0x4d, 0x14, 0xda, 0x80, 0x82, 0xad, 0xd8, 0x34, 0xa9, 0x23, 0xd0, 0xe4, 0x2d, 0x08,
+	0x49, 0x07, 0x0e, 0x5a, 0x85, 0x5c, 0xab, 0x4b, 0x5d, 0x87, 0x9f, 0xa6, 0xc5, 0xe9, 0x92, 0xd8,
+	0x1f, 0x38, 0x78, 0x1b, 0xca, 0xd3, 0x50, 0x94, 0xd6, 0x77, 0x20, 0x73, 0x66, 0xbb, 0x43, 0x22,
+	0x60, 0xe4, 0x2c, 0xb9, 0xc1, 0xbf, 0x1a, 0x50, 0x6a, 0xf8, 0x84, 0xd4, 0xfa, 0xcc, 0x1f, 0xcd,
+	0xe9, 0x1d, 0x10, 0x82, 0xc5, 0x81, 0xcd, 0xba, 0x02, 0x6d, 0xd1, 0x12, 0x6b, 0x0e, 0xc7, 0xa5,
+	0x3d, 0xca, 0xca, 0x8b, 0x9b, 0xc6, 0x56, 0xda, 0x92, 0x1b, 0xfc, 0xa7, 0x01, 0x2b, 0x31, 0x38,
+	0x0a, 0xfa, 0xd7, 0xb0, 0xc8, 0x46, 0x03, 0x89, 0x7c, 0xb9, 0xfa, 0xef, 0x10, 0xc9, 0xd4, 0xc5,
+	0x4a, 0xfd, 0xe4, 0x47, 0xd2, 0x62, 0x8d, 0xd1, 0x80, 0x58, 0xe2, 0x8b, 0xf0, 0xa9, 0x53, 0xfa,
+	0xa9, 0x11, 0x2c, 0x06, 0xf4, 0x27, 0x22, 0xb0, 0xa4, 0x2d, 0xb1, 0xe6, 0xb4, 0x9e, 0xe7, 0x10,
+	0x01, 0x25, 0x63, 0x89, 0x35, 0xa7, 0x39, 0x36, 0xb3, 0xcb, 0x19, 0x89, 0x99, 0xaf, 0xf1, 0xff,
+	0x01, 0xb4, 0x04, 0x04, 0x90, 0x7d, 0x59, 0x3f, 0x3a, 0x3a, 0x68, 0x94, 0x16, 0x50, 0x0e, 0x16,
+	0x77, 0x0f, 0xeb, 0xbb, 0x25, 0x83, 0xaf, 0x1a, 0x56, 0xad, 0x56, 0x4a, 0xa1, 0x25, 0x48, 0x37,
+	0x76, 0xf6, 0x4b, 0x69, 0xec, 0xc1, 0x5d, 0xf9, 0x2a, 0xc1, 0x2e, 0x61, 0xe7, 0x84, 0xf4, 0x6f,
+	0x62, 0x67, 0x04, 0x8b, 0x6d, 0xdf, 0xeb, 0x29, 0x1b, 0x8b, 0x35, 0x5a, 0x86, 0x14, 0xf3, 0x94,
+	0x75, 0x53, 0xcc, 0xc3, 0x35, 0xb8, 0x37, 0x29, 0x50, 0x59, 0xf2, 0x39, 0x2c, 0xc9, 0xf0, 0x0d,
+	0xca, 0xc6, 0x66, 0x7a, 0xab, 0x50, 0x5d, 0x09, 0xc5, 0xed, 0x53, 0x26, 0xbf, 0xb1, 0xc2, 0x1b,
+	0xf8, 0x63, 0x8a, 0xc7, 0xcf, 0xb0, 0xaf, 0x0e, 0xe6, 0x15, 0xa6, 0x68, 0x1b, 0x32, 0x76, 0x9b,
+	0x11, 0x5f, 0x68, 0x50, 0xa8, 0x9a, 0x15, 0x99, 0x3d, 0x2a, 0x61, 0xf6, 0xa8, 0x34, 0xc2, 0xec,
+	0x61, 0xc9, 0x8b, 0xa8, 0x0a, 0xd9, 0x13, 0xd2, 0xf6, 0x7c, 0xf9, 0x64, 0x97, 0x7f, 0xa2, 0x6e,
+	0x46, 0x4e, 0x98, 0x89, 0x39, 0xe1, 0x1a, 0xe4, 0x7b, 0xf6, 0x45, 0xb3, 0xc5, 0x95, 0x2c, 0x67,
+	0xc5, 0xeb, 0xe7, 0x7a, 0xf6, 0x85, 0x50, 0x9a, 0xfb, 0x8e, 0xed, 0xba, 0xe5, 0x25, 0x11, 0x2e,
+	0x7c, 0x89, 0xff, 0x0b, 0x77, 0xc6, 0xed, 0xa1, 0x43, 0x4b, 0xb2, 0x30, 0x04, 0x0b, 0xb9, 0xc1,
+	0x9f, 0x0c, 0xc8, 0x47, 0x2e, 0x9a, 0x90, 0x74, 0x56, 0x21, 0xe7, 0x7b, 0x1e, 0x6b, 0x6a, 0x07,
+	0x5d, 0xe2, 0xfb, 0xba, 0x74, 0xd2, 0xa9, 0x80, 0x79, 0xa1, 0x82, 0x60, 0x51, 0x04, 0xc1, 0xda,
+	0x54, 0x10, 0x54, 0xc4, 0x6f, 0xcc, 0xf7, 0x43, 0xaf, 0xce, 0xc4, 0xbc, 0xfa, 0x01, 0x80, 0x7c,
+	0x5d, 0x21, 0x35, 0x2b, 0xa4, 0xe6, 0x25, 0x85, 0xcb, 0x5d, 0x83, 0x7c, 0xdb, 0xb5, 0x59, 0x53,
+	0x08, 0x5f, 0x92, 0xcf, 0xc4, 0x09, 0x6f, 0x6d, 0xd6, 0xc5, 0xcf, 0x21, 0x1f, 0x89, 0x88, 0x1c,
+	0x7e, 0x21, 0x72, 0x78, 0x23, 0x16, 0x10, 0x69, 0xfc, 0x9b, 0x01, 0x77, 0xf7, 0x09, 0x0b, 0xd1,
+	0x51, 0x12, 0x7c, 0xc9, 0xe4, 0xb2, 0x0e, 0x79, 0x9f, 0xb4, 0x86, 0x7e, 0x40, 0xcf, 0xa4, 0xc1,
+	0x72, 0x96, 0x26, 0xf0, 0xf0, 0x98, 0x84, 0xa6, 0xc3, 0x83, 0x48, 0xd2, 0x64, 0x78, 0xe8, 0x5c,
+	0x13, 0xde, 0xc0, 0x27, 0x50, 0x3a, 0xa4, 0x01, 0xdb, 0xa3, 0xee, 0xdc, 0x94, 0xc3, 0xcf, 0x60,
+	0x25, 0x26, 0x43, 0xbb, 0x1b, 0xd7, 0x52, 0x62, 0x2c, 0x5a, 0x72, 0x83, 0x5b, 0xb0, 0xb2, 0x47,
+	0xfb, 0x8e, 0x0a, 0xe2, 0x39, 0xe1, 0xf9, 0x16, 0x50, 0x5c, 0x88, 0x02, 0xf4, 0x0c, 0xb2, 0xd2,
+	0x87, 0x94, 0x84, 0x84, 0xa4, 0xa2, 0x2e, 0xe0, 0x26, 0xdc, 0xe7, 0x0a, 0x85, 0xe9, 0x69, 0x54,
+	0xa7, 0xce, 0x4d, 0xb0, 0x46, 0xf9, 0x3d, 0xad, 0xa2, 0x0a, 0xef, 0x43, 0x79, 0x5a, 0xc0, 0x75,
+	0xb2, 0xdf, 0x27, 0x03, 0xee, 0x72, 0x5d, 0x77, 0x5c, 0x77, 0xce, 0xf9, 0x6f, 0x2c, 0x0b, 0xa5,
+	0x27, 0xb2, 0x10, 0xaf, 0x57, 0xa7, 0x74, 0x10, 0xd6, 0x26, 0xbe, 0x46, 0xdf, 0x40, 0xc6, 0xf3,
+	0x1d, 0xe2, 0x8b, 0xd0, 0x5e, 0xae, 0x3e, 0x0e, 0x65, 0x27, 0xc2, 0xad, 0xd4, 0xf9, 0x55, 0x4b,
+	0x7e, 0x81, 0x9f, 0x40, 0x46, 0xec, 0x79, 0xd8, 0xbe, 0xa9, 0xbf, 0xa9, 0xa9, 0x00, 0xae, 0xbf,
+	0xad, 0xcb, 0xda, 0xf5, 0x6a, 0xa7, 0x51, 0x2b, 0xa5, 0x78, 0x88, 0x4c, 0x32, 0xbb, 0x8e, 0x0d,
+	0xff, 0x4a, 0xc5, 0xfd, 0x65, 0x6e, 0x06, 0x8c, 0x7a, 0x09, 0x69, 0x3c, 0xb9, 0x41, 0xf7, 0x20,
+	0xeb, 0xb5, 0xdb, 0x01, 0x61, 0xca, 0x76, 0x6a, 0xa7, 0xc3, 0x27, 0x13, 0x0b, 0x1f, 0x7e, 0xbb,
+	0xed, 0xb9, 0xae, 0x77, 0x2e, 0xb2, 0x62, 0xce, 0x52, 0x3b, 0xde, 0x8e, 0x71, 0x9b, 0x37, 0x7b,
+	0xc4, 0xef, 0x90, 0x40, 0x55, 0x03, 0xe0, 0xa4, 0x23, 0x41, 0x41, 0x8f, 0xa0, 0xe8, 0xd0, 0xc0,
+	0x3e, 0x71, 0x49, 0xf3, 0xdc, 0x76, 0x4f, 0xcb, 0x39, 0x71, 0xa3, 0xa0, 0x68, 0xef, 0x6c, 0xf7,
+	0x54, 0x17, 0xb8, 0xfc, 0xe7, 0x17, 0x38, 0xf8, 0xc7, 0x05, 0x4e, 0xd5, 0xab, 0x82, 0xae, 0x57,
+	0xbb, 0x70, 0x7b, 0xcc, 0xfa, 0xd7, 0x79, 0xc2, 0x6e, 0xd8, 0x4b, 0x1c, 0xda, 0xfd, 0xce, 0xd0,
+	0xee, 0xcc, 0x2f, 0xd7, 0xfd, 0x1e, 0x35, 0xd2, 0x31, 0x51, 0x0a, 0xf2, 0x1e, 0xe4, 0xdd, 0x90,
+	0xa8, 0x40, 0x6f, 0x85, 0xa2, 0x66, 0x7c, 0x53, 0x09, 0x29, 0x96, 0xfe, 0xd4, 0x7c, 0x0d, 0xb9,
+	0x90, 0xcc, 0x23, 0xab, 0x6f, 0xf7, 0x88, 0x2a, 0xc9, 0x62, 0xcd, 0x7d, 0x43, 0x0c, 0x32, 0x02,
+	0x5c, 0xca, 0x92, 0x1b, 0x59, 0xdf, 0x5d, 0xcf, 0x57, 0xed, 0xb6, 0xdc, 0xe0, 0x21, 0xdc, 0xb2,
+	0xec, 0xf3, 0x5d, 0xd7, 0xee, 0x91, 0x2f, 0x58, 0xdb, 0xf0, 0x53, 0x28, 0x69, 0xb1, 0xca, 0x3c,
+	0x61, 0xb3, 0x6a, 0xc4, 0x9a, 0xd5, 0x9f, 0xa1, 0x7c, 0x68, 0x87, 0x89, 0x70, 0xcf, 0xf3, 0x79,
+	0x0d, 0xff, 0x92, 0x38, 0xf7, 0x60, 0x35, 0x41, 0xfe, 0xe7, 0x57, 0x8c, 0x3f, 0x22, 0xb7, 0x08,
+	0x76, 0x47, 0x47, 0x24, 0x08, 0xf8, 0x93, 0xce, 0x49, 0x0f, 0x9d, 0x32, 0xd2, 0x93, 0x29, 0x43,
+	0x0f, 0x2b, 0x51, 0x82, 0x49, 0xea, 0x28, 0xef, 0x40, 0xe6, 0xc3, 0x90, 0xf8, 0x23, 0xd5, 0x5b,
+	0xc9, 0x0d, 0x2f, 0x4a, 0xd3, 0x2a, 0x5c, 0x27, 0x1a, 0x29, 0x6c, 0xec, 0x51, 0x97, 0x11, 0xff,
+	0xb8, 0x6b, 0x07, 0xef, 0x28, 0xeb, 0x1e, 0xd3, 0x4e, 0xdf, 0x66, 0x43, 0xff, 0x66, 0x61, 0xc9,
+	0x8b, 0x4c, 0xd7, 0x0e, 0x44, 0x1d, 0x2d, 0x5a, 0x62, 0x8d, 0xbf, 0x82, 0xcd, 0xd9, 0xa2, 0xb4,
+	0xdf, 0x89, 0xef, 0x8c, 0xd8, 0x77, 0x03, 0x78, 0x50, 0xbb, 0x60, 0xbe, 0xdd, 0x52, 0xe0, 0xa3,
+	0xcf, 0x6e, 0x02, 0x70, 0x0d, 0x54, 0x97, 0xaa, 0x47, 0xe2, 0x9c, 0x24, 0x1c, 0x38, 0xb8, 0x09,
+	0x0f, 0x67, 0x49, 0x54, 0x38, 0xd7, 0x21, 0x1f, 0x84, 0x44, 0x15, 0x24, 0x9a, 0x20, 0x52, 0x3c,
+	0xed, 0xf4, 0x89, 0xd3, 0x64, 0xe4, 0x82, 0x29, 0xa7, 0x00, 0x49, 0x6a, 0x90, 0x0b, 0x86, 0x3d,
+	0x30, 0xf7, 0xc9, 0x24, 0xf3, 0x1b, 0x19, 0x5c, 0xf7, 0xe1, 0xd4, 0x09, 0x54, 0xfb, 0x92, 0x0f,
+	0x15, 0x0a, 0xf0, 0x08, 0xd6, 0x12, 0x05, 0x2a, 0x75, 0xc6, 0xac, 0x61, 0x8c, 0x5b, 0x63, 0x5c,
+	0xd7, 0xd4, 0x15, 0xba, 0xa6, 0x27, 0x75, 0xad, 0x7e, 0x2c, 0xc2, 0xbf, 0x94, 0x60, 0xe2, 0x9f,
+	0xd1, 0x16, 0x41, 0xef, 0xa0, 0x34, 0xf9, 0xa7, 0x02, 0xda, 0x18, 0x4f, 0xbe, 0x53, 0xff, 0x7c,
+	0x98, 0x9b, 0xb3, 0x2f, 0x48, 0x25, 0xf0, 0x02, 0x7a, 0x15, 0x9f, 0x8f, 0xca, 0x09, 0x53, 0xbd,
+	0x64, 0xb5, 0x3a, 0x73, 0xde, 0xc7, 0x0b, 0xdb, 0x06, 0x3a, 0x86, 0xe5, 0xf1, 0x61, 0x17, 0x3d,
+	0x18, 0x97, 0x3d, 0x31, 0x75, 0x9b, 0x0f, 0x67, 0x1d, 0xc7, 0x98, 0x7e, 0x0f, 0xc5, 0xf8, 0xa4,
+	0x87, 0xd6, 0xf4, 0x37, 0x53, 0xf3, 0xb0, 0xb9, 0x9e, 0x7c, 0x18, 0xe9, 0x79, 0x0c, 0xcb, 0xe3,
+	0xf3, 0x86, 0x46, 0x98, 0x38, 0x22, 0x69, 0x84, 0xc9, 0x63, 0x8a, 0x40, 0xf8, 0x0a, 0xf2, 0xd1,
+	0x64, 0xa0, 0x8d, 0x37, 0x39, 0x90, 0x68, 0xe3, 0x4d, 0x8d, 0x11, 0x82, 0x4b, 0x0d, 0x40, 0x77,
+	0x08, 0x68, 0x35, 0xde, 0x48, 0x8e, 0x0d, 0x12, 0xa6, 0x99, 0x74, 0x14, 0x69, 0xf8, 0x1d, 0x14,
+	0x62, 0x7f, 0xb4, 0x21, 0x73, 0xdc, 0xc2, 0xf1, 0xff, 0xf8, 0xcc, 0xb5, 0xc4, 0xb3, 0xb8, 0xad,
+	0xc6, 0x1b, 0x4f, 0x6d, 0xab, 0xc4, 0xee, 0x56, 0xdb, 0x2a, 0xb9, 0x5f, 0x15, 0x5a, 0xbe, 0x86,
+	0x42, 0xac, 0x0f, 0x42, 0x09, 0xba, 0x4c, 0xc3, 0x4b, 0x68, 0x9c, 0x04, 0xaf, 0x06, 0xdc, 0x9a,
+	0x68, 0x38, 0xd0, 0xc3, 0x99, 0x9d, 0x88, 0xe4, 0xb9, 0x71, 0x45, 0xa7, 0x82, 0x17, 0xd0, 0x0e,
+	0xe4, 0xc2, 0xa2, 0x8e, 0xee, 0x47, 0xb9, 0x63, 0xbc, 0xbb, 0x30, 0xcb, 0xd3, 0x07, 0x31, 0x60,
+	0x3f, 0xc0, 0xca, 0x54, 0xbd, 0x45, 0x51, 0x18, 0xce, 0x6a, 0x05, 0xcc, 0x47, 0x97, 0xdc, 0x88,
+	0xe0, 0xbd, 0x0f, 0x53, 0x80, 0xae, 0x5f, 0x93, 0x29, 0x60, 0xaa, 0x38, 0x4f, 0xa6, 0x80, 0xe9,
+	0xd2, 0x27, 0x60, 0xbf, 0x97, 0x53, 0x74, 0x7c, 0x5e, 0xd3, 0xac, 0x67, 0x8c, 0x8a, 0x9a, 0xf5,
+	0xac, 0x51, 0x4f, 0xb0, 0x0e, 0xa0, 0x3c, 0xab, 0x82, 0xa1, 0xff, 0xe8, 0x77, 0xbe, 0xb4, 0x9c,
+	0x9a, 0x5b, 0x57, 0x5f, 0x0c, 0x45, 0x6e, 0x19, 0xdb, 0x06, 0x3a, 0x85, 0x7b, 0xc9, 0xc5, 0x08,
+	0x3d, 0x09, 0x39, 0x5d, 0x5a, 0x1e, 0xcd, 0xa7, 0x57, 0x5d, 0x8b, 0x69, 0x78, 0x02, 0xb7, 0x13,
+	0xea, 0x04, 0xc2, 0xb1, 0xfc, 0x31, 0xa3, 0x6a, 0x99, 0x8f, 0x2f, 0xbd, 0xa3, 0x65, 0x9c, 0x64,
+	0xc5, 0xc8, 0xf1, 0xbf, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x80, 0x60, 0xe9, 0xf3, 0xf8, 0x17,
+	0x00, 0x00,
 }

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/helper/inforefs.go

+package helper
+
+import (
+	"io"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+)
+
+type InfoRefsClient interface {
+	Recv() (*pb.InfoRefsResponse, error)
+}
+
+type InfoRefsClientWriterTo struct {
+	InfoRefsClient
+}
+
+func (clientReader *InfoRefsClientWriterTo) WriteTo(w io.Writer) (total int64, err error) {
+	for {
+		response, err := clientReader.Recv()
+		if err == io.EOF {
+			return total, nil
+		} else if err != nil {
+			return total, err
+		}
+
+		n, err := w.Write(response.GetData())
+		total += int64(n)
+		if err != nil {
+			return total, err
+		}
+	}
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/helper/stream.go

+package helper
+
+import (
+	"io"
+)
+
+// NewReceiveReader turns receiver into an io.Reader. Errors from the
+// receiver function are passed on unmodified. This means receiver should
+// emit io.EOF when done.
+func NewReceiveReader(receiver func() ([]byte, error)) io.Reader {
+	return &receiveReader{receiver: receiver}
+}
+
+type receiveReader struct {
+	receiver func() ([]byte, error)
+	data     []byte
+	err      error
+}
+
+func (rr *receiveReader) Read(p []byte) (int, error) {
+	if len(rr.data) == 0 {
+		rr.data, rr.err = rr.receiver()
+	}
+	n := copy(p, rr.data)
+	rr.data = rr.data[n:]
+	if len(rr.data) == 0 {
+		return n, rr.err
+	}
+	return n, nil
+}
+
+// NewSendWriter turns sender into an io.Writer. The number of 'bytes
+// written' reported back is always len(p).
+func NewSendWriter(sender func(p []byte) error) io.Writer {
+	return &sendWriter{sender: sender}
+}
+
+type sendWriter struct {
+	sender func([]byte) error
+}
+
+func (sw *sendWriter) Write(p []byte) (int, error) {
+	return len(p), sw.sender(p)
+}

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

@@ -356,7 +356,8 @@ type UserMergeBranchResponse struct {
 	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
 	// Second message
 	// If set, the merge has been applied to the branch.
-	BranchUpdate *OperationBranchUpdate `protobuf:"bytes,3,opt,name=branch_update,json=branchUpdate" json:"branch_update,omitempty"`
+	BranchUpdate    *OperationBranchUpdate `protobuf:"bytes,3,opt,name=branch_update,json=branchUpdate" json:"branch_update,omitempty"`
+	PreReceiveError string                 `protobuf:"bytes,4,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
 }
 
 func (m *UserMergeBranchResponse) Reset()                    { *m = UserMergeBranchResponse{} }
@@ -378,6 +379,13 @@ func (m *UserMergeBranchResponse) GetBranchUpdate() *OperationBranchUpdate {
 	return nil
 }
 
+func (m *UserMergeBranchResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
+
 type OperationBranchUpdate struct {
 	// If this string is non-empty the branch has been updated.
 	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
@@ -1163,6 +1171,102 @@ func (m *UserRebaseResponse) GetGitError() string {
 	return ""
 }
 
+type UserSquashRequest struct {
+	Repository    *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	User          *User       `protobuf:"bytes,2,opt,name=user" json:"user,omitempty"`
+	SquashId      string      `protobuf:"bytes,3,opt,name=squash_id,json=squashId" json:"squash_id,omitempty"`
+	Branch        []byte      `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
+	StartSha      string      `protobuf:"bytes,5,opt,name=start_sha,json=startSha" json:"start_sha,omitempty"`
+	EndSha        string      `protobuf:"bytes,6,opt,name=end_sha,json=endSha" json:"end_sha,omitempty"`
+	Author        *User       `protobuf:"bytes,7,opt,name=author" json:"author,omitempty"`
+	CommitMessage []byte      `protobuf:"bytes,8,opt,name=commit_message,json=commitMessage,proto3" json:"commit_message,omitempty"`
+}
+
+func (m *UserSquashRequest) Reset()                    { *m = UserSquashRequest{} }
+func (m *UserSquashRequest) String() string            { return proto.CompactTextString(m) }
+func (*UserSquashRequest) ProtoMessage()               {}
+func (*UserSquashRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{24} }
+
+func (m *UserSquashRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *UserSquashRequest) GetUser() *User {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserSquashRequest) GetSquashId() string {
+	if m != nil {
+		return m.SquashId
+	}
+	return ""
+}
+
+func (m *UserSquashRequest) GetBranch() []byte {
+	if m != nil {
+		return m.Branch
+	}
+	return nil
+}
+
+func (m *UserSquashRequest) GetStartSha() string {
+	if m != nil {
+		return m.StartSha
+	}
+	return ""
+}
+
+func (m *UserSquashRequest) GetEndSha() string {
+	if m != nil {
+		return m.EndSha
+	}
+	return ""
+}
+
+func (m *UserSquashRequest) GetAuthor() *User {
+	if m != nil {
+		return m.Author
+	}
+	return nil
+}
+
+func (m *UserSquashRequest) GetCommitMessage() []byte {
+	if m != nil {
+		return m.CommitMessage
+	}
+	return nil
+}
+
+type UserSquashResponse struct {
+	SquashSha string `protobuf:"bytes,1,opt,name=squash_sha,json=squashSha" json:"squash_sha,omitempty"`
+	GitError  string `protobuf:"bytes,3,opt,name=git_error,json=gitError" json:"git_error,omitempty"`
+}
+
+func (m *UserSquashResponse) Reset()                    { *m = UserSquashResponse{} }
+func (m *UserSquashResponse) String() string            { return proto.CompactTextString(m) }
+func (*UserSquashResponse) ProtoMessage()               {}
+func (*UserSquashResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{25} }
+
+func (m *UserSquashResponse) GetSquashSha() string {
+	if m != nil {
+		return m.SquashSha
+	}
+	return ""
+}
+
+func (m *UserSquashResponse) GetGitError() string {
+	if m != nil {
+		return m.GitError
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterType((*UserCreateBranchRequest)(nil), "gitaly.UserCreateBranchRequest")
 	proto.RegisterType((*UserCreateBranchResponse)(nil), "gitaly.UserCreateBranchResponse")
@@ -1188,6 +1292,8 @@ func init() {
 	proto.RegisterType((*UserCommitFilesResponse)(nil), "gitaly.UserCommitFilesResponse")
 	proto.RegisterType((*UserRebaseRequest)(nil), "gitaly.UserRebaseRequest")
 	proto.RegisterType((*UserRebaseResponse)(nil), "gitaly.UserRebaseResponse")
+	proto.RegisterType((*UserSquashRequest)(nil), "gitaly.UserSquashRequest")
+	proto.RegisterType((*UserSquashResponse)(nil), "gitaly.UserSquashResponse")
 	proto.RegisterEnum("gitaly.UserCommitFilesActionHeader_ActionType", UserCommitFilesActionHeader_ActionType_name, UserCommitFilesActionHeader_ActionType_value)
 }
 
@@ -1212,6 +1318,7 @@ type OperationServiceClient interface {
 	UserRevert(ctx context.Context, in *UserRevertRequest, opts ...grpc.CallOption) (*UserRevertResponse, error)
 	UserCommitFiles(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserCommitFilesClient, error)
 	UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error)
+	UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error)
 }
 
 type operationServiceClient struct {
@@ -1359,6 +1466,15 @@ func (c *operationServiceClient) UserRebase(ctx context.Context, in *UserRebaseR
 	return out, nil
 }
 
+func (c *operationServiceClient) UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error) {
+	out := new(UserSquashResponse)
+	err := grpc.Invoke(ctx, "/gitaly.OperationService/UserSquash", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for OperationService service
 
 type OperationServiceServer interface {
@@ -1372,6 +1488,7 @@ type OperationServiceServer interface {
 	UserRevert(context.Context, *UserRevertRequest) (*UserRevertResponse, error)
 	UserCommitFiles(OperationService_UserCommitFilesServer) error
 	UserRebase(context.Context, *UserRebaseRequest) (*UserRebaseResponse, error)
+	UserSquash(context.Context, *UserSquashRequest) (*UserSquashResponse, error)
 }
 
 func RegisterOperationServiceServer(s *grpc.Server, srv OperationServiceServer) {
@@ -1574,6 +1691,24 @@ func _OperationService_UserRebase_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _OperationService_UserSquash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UserSquashRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(OperationServiceServer).UserSquash(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.OperationService/UserSquash",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(OperationServiceServer).UserSquash(ctx, req.(*UserSquashRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _OperationService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.OperationService",
 	HandlerType: (*OperationServiceServer)(nil),
@@ -1610,6 +1745,10 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "UserRebase",
 			Handler:    _OperationService_UserRebase_Handler,
 		},
+		{
+			MethodName: "UserSquash",
+			Handler:    _OperationService_UserSquash_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1630,90 +1769,97 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("operations.proto", fileDescriptor7) }
 
 var fileDescriptor7 = []byte{
-	// 1357 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
-	0x14, 0xf7, 0xda, 0xee, 0xc6, 0x79, 0x76, 0x1c, 0x7b, 0xfa, 0x81, 0xeb, 0x36, 0x4d, 0xba, 0xa5,
-	0x50, 0x2a, 0x64, 0xa1, 0x80, 0xe0, 0x54, 0x50, 0x3e, 0x1c, 0xd2, 0x42, 0xda, 0xb0, 0x4d, 0x0a,
-	0xb7, 0xd5, 0xc4, 0x1e, 0xec, 0x15, 0xb6, 0x77, 0x99, 0x9d, 0x44, 0x35, 0x42, 0x88, 0x0b, 0x70,
-	0xe5, 0xc4, 0x81, 0x13, 0x12, 0x37, 0x6e, 0x5c, 0x38, 0x70, 0xe0, 0xc4, 0x89, 0x6b, 0x0f, 0xfc,
-	0x3b, 0x68, 0x66, 0xde, 0xda, 0xbb, 0xeb, 0xdd, 0x28, 0x81, 0x44, 0x54, 0x88, 0xdb, 0xee, 0x7b,
-	0x6f, 0xde, 0xbc, 0xf7, 0x7b, 0x1f, 0xf3, 0x66, 0xa0, 0xe6, 0xf9, 0x8c, 0x53, 0xe1, 0x7a, 0xa3,
-	0xa0, 0xe5, 0x73, 0x4f, 0x78, 0xc4, 0xec, 0xb9, 0x82, 0x0e, 0xc6, 0xcd, 0x4a, 0xd0, 0xa7, 0x9c,
-	0x75, 0x35, 0xd5, 0xfa, 0xd9, 0x80, 0x17, 0xf6, 0x03, 0xc6, 0x37, 0x38, 0xa3, 0x82, 0xad, 0x73,
-	0x3a, 0xea, 0xf4, 0x6d, 0xf6, 0xe9, 0x21, 0x0b, 0x04, 0x59, 0x05, 0xe0, 0xcc, 0xf7, 0x02, 0x57,
-	0x78, 0x7c, 0xdc, 0x30, 0x56, 0x8c, 0x3b, 0xe5, 0x55, 0xd2, 0xd2, 0x6a, 0x5a, 0xf6, 0x84, 0x63,
-	0x47, 0xa4, 0xc8, 0x32, 0x94, 0x0f, 0x94, 0x12, 0x67, 0x44, 0x87, 0xac, 0x91, 0x5f, 0x31, 0xee,
-	0x54, 0x6c, 0xd0, 0xa4, 0x87, 0x74, 0xc8, 0xc8, 0x0a, 0x14, 0x0f, 0x03, 0xc6, 0x1b, 0x05, 0xa5,
-	0xae, 0x12, 0xaa, 0x93, 0x36, 0xd8, 0x8a, 0x23, 0x55, 0x04, 0x82, 0x72, 0xe1, 0xf8, 0x9e, 0x3b,
-	0x12, 0x8d, 0xa2, 0x56, 0xa1, 0x48, 0xbb, 0x92, 0x62, 0x8d, 0xa0, 0x31, 0x6b, 0x72, 0xe0, 0x7b,
-	0xa3, 0x80, 0x91, 0x97, 0xc0, 0xd4, 0x9b, 0xa1, 0xbd, 0xd5, 0x70, 0x03, 0x94, 0x43, 0x2e, 0xb9,
-	0x0b, 0x75, 0x9f, 0x33, 0x87, 0xb3, 0x0e, 0x73, 0x8f, 0x98, 0xc3, 0x38, 0xf7, 0xb8, 0xb2, 0x76,
-	0xde, 0x5e, 0xf4, 0x39, 0xb3, 0x35, 0xbd, 0x2d, 0xc9, 0xd6, 0xb7, 0x88, 0xd1, 0x26, 0x1b, 0xb0,
-	0xe7, 0x03, 0x23, 0x6b, 0x4b, 0x43, 0x10, 0xb7, 0x08, 0x21, 0x48, 0x75, 0xcd, 0x48, 0x77, 0xed,
-	0x1b, 0x03, 0x2e, 0x4d, 0x15, 0xed, 0xd1, 0xde, 0x3f, 0xf1, 0xeb, 0x2a, 0x94, 0x04, 0xed, 0x45,
-	0x9d, 0x9a, 0x13, 0xb4, 0x77, 0x42, 0x8f, 0x36, 0xe0, 0x72, 0xc2, 0x90, 0xbf, 0xe1, 0xce, 0x1f,
-	0xe8, 0x8e, 0x4e, 0x8d, 0x7f, 0xd1, 0x1d, 0xf2, 0x32, 0x2c, 0x0a, 0xca, 0x7b, 0x4c, 0x38, 0x9c,
-	0x1d, 0xb9, 0x81, 0xeb, 0x8d, 0x30, 0x91, 0xab, 0x9a, 0x6c, 0x23, 0x95, 0x34, 0x60, 0x6e, 0xc8,
-	0x82, 0x80, 0xf6, 0x58, 0xe3, 0x82, 0xde, 0x04, 0x7f, 0xad, 0xcf, 0x34, 0x22, 0x11, 0x5f, 0x10,
-	0x91, 0x25, 0x28, 0x08, 0xda, 0x43, 0x2f, 0xca, 0xe1, 0xe6, 0x52, 0x42, 0xd2, 0xc9, 0x15, 0x30,
-	0xd9, 0x53, 0x37, 0x10, 0x81, 0xb2, 0xba, 0x64, 0xe3, 0x5f, 0x3a, 0x90, 0x85, 0x74, 0x20, 0x9f,
-	0x19, 0x70, 0x45, 0x6e, 0xbe, 0xc3, 0x78, 0xef, 0x0c, 0x32, 0x3e, 0xc4, 0x2b, 0x9f, 0x89, 0xd7,
-	0x35, 0x98, 0xef, 0x78, 0xc3, 0xa1, 0x2b, 0x1c, 0xb7, 0x8b, 0x46, 0x95, 0x34, 0xe1, 0x7e, 0x57,
-	0x7a, 0x84, 0x45, 0xad, 0x31, 0x0c, 0x8b, 0x38, 0x13, 0x3b, 0x72, 0x09, 0x2e, 0x50, 0xdf, 0x1f,
-	0x8c, 0x1b, 0xa6, 0x82, 0x40, 0xff, 0x58, 0x5f, 0x62, 0x21, 0xc7, 0xbc, 0x42, 0x50, 0x63, 0x06,
-	0x18, 0x09, 0x03, 0xd6, 0x61, 0x01, 0x2b, 0xf6, 0xd0, 0xef, 0x52, 0xc1, 0x30, 0xf0, 0x4b, 0xa1,
-	0x23, 0x8f, 0xc2, 0x66, 0xab, 0x95, 0xee, 0x2b, 0x21, 0xbb, 0x72, 0x10, 0xf9, 0x7b, 0x50, 0x2c,
-	0xe5, 0x6b, 0x05, 0xeb, 0x0b, 0xb8, 0x9c, 0x2a, 0x7c, 0xfc, 0xfe, 0x37, 0xa1, 0x22, 0xd1, 0x74,
-	0x3a, 0x2a, 0x17, 0xba, 0x18, 0xd8, 0xb2, 0xa4, 0xe9, 0xf4, 0xe8, 0x92, 0xdb, 0x50, 0x45, 0x13,
-	0x43, 0xa1, 0x82, 0x12, 0x42, 0xc3, 0x51, 0xcc, 0xfa, 0xc1, 0x80, 0x8b, 0x12, 0x82, 0xad, 0xad,
-	0xe7, 0x35, 0xaa, 0xd6, 0xd7, 0x58, 0xc4, 0x53, 0x13, 0x31, 0x44, 0x33, 0x51, 0x30, 0x4e, 0x1d,
-	0x85, 0x53, 0xf5, 0xfd, 0xdf, 0xf2, 0x58, 0x81, 0x7d, 0xc6, 0xf9, 0x78, 0xd7, 0xed, 0x7c, 0x72,
-	0xbe, 0x68, 0xbd, 0x02, 0xa6, 0x06, 0x07, 0xd3, 0xab, 0x1e, 0xca, 0xbc, 0xeb, 0x8a, 0x0d, 0xc5,
-	0xb0, 0x51, 0x20, 0x79, 0x84, 0x14, 0x67, 0x8e, 0x90, 0xec, 0xd2, 0xb8, 0x0b, 0x75, 0x7d, 0xbc,
-	0x46, 0x15, 0x98, 0x4a, 0x66, 0x51, 0x31, 0xd6, 0xa7, 0x5a, 0xee, 0x41, 0x4d, 0xcb, 0x46, 0xbc,
-	0x9d, 0xcb, 0xf4, 0x56, 0x2f, 0x9f, 0x12, 0xac, 0x3f, 0xb1, 0x8b, 0x44, 0x01, 0x3c, 0xdb, 0x58,
-	0xea, 0x5c, 0x77, 0x04, 0x67, 0x89, 0x58, 0x6a, 0xc6, 0x1e, 0x67, 0x3a, 0x96, 0xb2, 0x82, 0x30,
-	0x13, 0xa3, 0x7d, 0xaf, 0xac, 0x69, 0x5a, 0x24, 0x35, 0x35, 0x8a, 0xe9, 0xa9, 0xf1, 0x6b, 0x1e,
-	0xea, 0x2a, 0x72, 0xec, 0x88, 0x49, 0x97, 0xff, 0x4f, 0x8b, 0x53, 0xa4, 0xc5, 0x33, 0x03, 0x48,
-	0x14, 0xbc, 0xff, 0x46, 0x4a, 0x7c, 0x9f, 0x87, 0x6b, 0x2a, 0xd9, 0xd5, 0xfa, 0x2d, 0x77, 0xc0,
-	0x82, 0xb5, 0x8e, 0x34, 0x77, 0x9b, 0xd1, 0x2e, 0xe3, 0x64, 0x0b, 0x4c, 0xaa, 0xfe, 0x95, 0x5f,
-	0xd5, 0xd5, 0x56, 0x34, 0xd4, 0x19, 0x8b, 0x5a, 0xfa, 0x67, 0x6f, 0xec, 0x33, 0x1b, 0x57, 0xcb,
-	0x9e, 0xfa, 0xb1, 0x3b, 0x60, 0x8e, 0x4f, 0x45, 0x1f, 0xe7, 0x92, 0x92, 0x24, 0xec, 0x52, 0xd1,
-	0x27, 0xb7, 0x60, 0xc1, 0x97, 0x03, 0x87, 0x77, 0x18, 0x68, 0x81, 0x82, 0x12, 0xa8, 0x84, 0x44,
-	0x25, 0x24, 0x8f, 0x0a, 0x1a, 0xb0, 0x37, 0xdf, 0x70, 0x3a, 0xde, 0x48, 0x30, 0x9c, 0xb1, 0xe5,
-	0x51, 0xa1, 0xa8, 0x1b, 0x9a, 0x68, 0x3d, 0x00, 0x98, 0x6e, 0x4f, 0x00, 0xcc, 0x0d, 0xbb, 0xbd,
-	0xb6, 0xd7, 0xae, 0xe5, 0x48, 0x15, 0x40, 0x7f, 0x3b, 0x9b, 0xf7, 0xed, 0x9a, 0x21, 0x79, 0xfb,
-	0xbb, 0x9b, 0x92, 0x97, 0x27, 0x25, 0x28, 0xee, 0x3c, 0x7a, 0xd2, 0xae, 0x15, 0x24, 0x75, 0xb3,
-	0xfd, 0x7e, 0x7b, 0xaf, 0x5d, 0x2b, 0x5a, 0xdf, 0x19, 0xd8, 0x4a, 0x93, 0x7e, 0x92, 0x7b, 0x60,
-	0xf6, 0x95, 0xaf, 0x18, 0xee, 0x5b, 0x27, 0x80, 0x65, 0x3b, 0x67, 0xe3, 0x22, 0xd2, 0x84, 0xb9,
-	0xd0, 0x09, 0x85, 0xc5, 0x76, 0xce, 0x0e, 0x09, 0xeb, 0x16, 0xac, 0xc8, 0x02, 0x72, 0x30, 0xca,
-	0x12, 0xa4, 0xc0, 0xd1, 0x28, 0x3a, 0x3e, 0x1d, 0x0f, 0x3c, 0xda, 0xb5, 0xbe, 0x2a, 0xc0, 0xf5,
-	0xc4, 0x4e, 0x58, 0xcd, 0x18, 0xb6, 0xf3, 0xa9, 0xe9, 0x44, 0xa1, 0x16, 0x66, 0x0a, 0xf5, 0x36,
-	0x54, 0xd1, 0xec, 0xb0, 0x5e, 0x75, 0x31, 0x2f, 0x68, 0xea, 0x0e, 0x56, 0xed, 0xab, 0x40, 0x50,
-	0x8c, 0x1e, 0x8a, 0xbe, 0xc7, 0xb5, 0x3a, 0x5d, 0xda, 0x35, 0xcd, 0x59, 0x53, 0x0c, 0xa5, 0xb4,
-	0x05, 0x17, 0xe3, 0xd2, 0x6c, 0x48, 0xdd, 0x01, 0x56, 0x79, 0x3d, 0x2a, 0xde, 0x96, 0x8c, 0xf4,
-	0x9e, 0x30, 0x77, 0xf2, 0x9e, 0x50, 0x3a, 0x79, 0x4f, 0xf8, 0x25, 0x3c, 0x2a, 0x66, 0xe2, 0x40,
-	0xde, 0x4e, 0x64, 0xc8, 0x8b, 0x19, 0x19, 0x12, 0x8b, 0x5b, 0x24, 0x45, 0xde, 0x9a, 0x14, 0x5e,
-	0x3e, 0xde, 0x50, 0xd2, 0x33, 0x2c, 0x17, 0x56, 0xda, 0xfa, 0x2d, 0xb8, 0x39, 0x9b, 0x3f, 0x5c,
-	0xef, 0x32, 0x49, 0xa0, 0x9f, 0xc2, 0x0b, 0x74, 0xd4, 0x90, 0x33, 0xec, 0x68, 0xcb, 0x50, 0x76,
-	0x47, 0x5d, 0xf6, 0x34, 0xd6, 0xcb, 0x40, 0x91, 0x8e, 0xe9, 0x51, 0x19, 0x63, 0xfd, 0x8f, 0x93,
-	0x63, 0x4b, 0x96, 0xfa, 0xb9, 0xcf, 0x7e, 0x5c, 0x6d, 0x13, 0x99, 0xfd, 0x34, 0xe1, 0x98, 0x89,
-	0x7e, 0x09, 0xb0, 0x08, 0x9c, 0xa0, 0x4f, 0x55, 0x1e, 0xcf, 0xdb, 0xf3, 0x9a, 0xf2, 0xb8, 0x4f,
-	0xc9, 0x3b, 0x50, 0xe7, 0x6c, 0xe8, 0x09, 0x16, 0xcd, 0x32, 0x33, 0xd3, 0xe0, 0x9a, 0x16, 0x9e,
-	0x52, 0x64, 0x7f, 0x44, 0x05, 0xb8, 0xbd, 0xce, 0xe6, 0x8a, 0x26, 0xea, 0x30, 0x58, 0x9f, 0x87,
-	0xc7, 0x93, 0x06, 0x69, 0x72, 0xeb, 0x02, 0xf4, 0x47, 0x9a, 0xa6, 0x27, 0x74, 0xf4, 0x50, 0x9a,
-	0x76, 0x8a, 0xc1, 0x52, 0x42, 0xd3, 0x4b, 0x1c, 0x3b, 0xa5, 0x1e, 0x9e, 0x39, 0xab, 0xbf, 0x9b,
-	0x50, 0x9b, 0x24, 0xc6, 0x63, 0xc6, 0x8f, 0xdc, 0x0e, 0x23, 0x1f, 0x42, 0x2d, 0xf9, 0xe4, 0x41,
-	0x96, 0x63, 0x79, 0x3c, 0xfb, 0x7e, 0xd3, 0x5c, 0xc9, 0x16, 0xd0, 0x3e, 0x59, 0xb9, 0x50, 0x71,
-	0xf4, 0x21, 0x21, 0xae, 0x38, 0xe5, 0xd1, 0x23, 0xae, 0x38, 0xed, 0x0d, 0xc2, 0xca, 0x91, 0x87,
-	0xb0, 0x10, 0xbb, 0xbd, 0x92, 0xeb, 0xb3, 0xd6, 0x4c, 0x2f, 0xe8, 0xcd, 0xa5, 0x0c, 0x6e, 0x52,
-	0xdf, 0xe4, 0x7d, 0x20, 0xae, 0x2f, 0xf9, 0x7e, 0x11, 0xd7, 0x37, 0xf3, 0xa8, 0x60, 0xe5, 0xc8,
-	0x47, 0xb0, 0x98, 0xb8, 0x0a, 0x92, 0x1b, 0xd1, 0x35, 0xb3, 0x37, 0xdf, 0xe6, 0x72, 0x26, 0x3f,
-	0xd4, 0x7a, 0xc7, 0x78, 0xcd, 0x20, 0xef, 0x41, 0x25, 0x7a, 0x7d, 0x21, 0xd7, 0xa2, 0xcb, 0x12,
-	0xf7, 0xae, 0xe6, 0xf5, 0x74, 0xe6, 0xc4, 0xcc, 0x0f, 0xa0, 0x1a, 0x9f, 0xa0, 0x49, 0x1c, 0xa9,
-	0xe4, 0xd5, 0xa4, 0x79, 0x23, 0x8b, 0x3d, 0x51, 0xd9, 0x06, 0x98, 0x4e, 0x5f, 0xe4, 0x6a, 0xac,
-	0x74, 0xa3, 0xe3, 0x6c, 0xb3, 0x99, 0xc6, 0x9a, 0xa8, 0x79, 0xa2, 0x01, 0x8c, 0xf4, 0xbd, 0x38,
-	0x80, 0xb3, 0x9d, 0x39, 0x0e, 0x60, 0x4a, 0xc3, 0x94, 0x00, 0x4e, 0xcd, 0x93, 0x95, 0x95, 0x34,
-	0x2f, 0xd2, 0xb6, 0x92, 0xe6, 0x45, 0x8b, 0xd5, 0xca, 0x1d, 0x98, 0xea, 0x7d, 0xf3, 0xf5, 0xbf,
-	0x02, 0x00, 0x00, 0xff, 0xff, 0x39, 0x0c, 0xa6, 0xa6, 0x09, 0x15, 0x00, 0x00,
+	// 1459 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4f, 0x73, 0xdb, 0x44,
+	0x14, 0xb7, 0x6c, 0x57, 0x76, 0x5e, 0x1c, 0xc7, 0xd9, 0xfe, 0x73, 0xdd, 0xa6, 0x49, 0xd5, 0x16,
+	0x4a, 0x87, 0xc9, 0x30, 0x81, 0x81, 0x53, 0x61, 0x9a, 0xc4, 0xa1, 0x2d, 0xb4, 0x0d, 0x6a, 0x5a,
+	0xb8, 0x69, 0xb6, 0xf6, 0x62, 0x6b, 0xb0, 0x2d, 0x75, 0xa5, 0x64, 0x6a, 0x86, 0xe1, 0x06, 0x1c,
+	0xb8, 0x70, 0xe2, 0xc0, 0x09, 0x86, 0x1b, 0xc3, 0x85, 0x0b, 0x07, 0x0e, 0x7c, 0x00, 0xae, 0x3d,
+	0xf0, 0x75, 0x98, 0xdd, 0xf7, 0x64, 0x4b, 0xb2, 0x94, 0x49, 0x21, 0x19, 0x3a, 0x0c, 0x37, 0xe9,
+	0xbd, 0xb7, 0x6f, 0xdf, 0xfb, 0xbd, 0x7f, 0xbb, 0x0b, 0x0d, 0xcf, 0x17, 0x92, 0x87, 0xae, 0x37,
+	0x0a, 0xd6, 0x7c, 0xe9, 0x85, 0x1e, 0x33, 0x7b, 0x6e, 0xc8, 0x07, 0xe3, 0x56, 0x2d, 0xe8, 0x73,
+	0x29, 0xba, 0x48, 0xb5, 0x7e, 0x31, 0xe0, 0xec, 0xc3, 0x40, 0xc8, 0x4d, 0x29, 0x78, 0x28, 0x36,
+	0x24, 0x1f, 0x75, 0xfa, 0xb6, 0x78, 0xb2, 0x27, 0x82, 0x90, 0xad, 0x03, 0x48, 0xe1, 0x7b, 0x81,
+	0x1b, 0x7a, 0x72, 0xdc, 0x34, 0x56, 0x8d, 0x6b, 0xf3, 0xeb, 0x6c, 0x0d, 0xd5, 0xac, 0xd9, 0x13,
+	0x8e, 0x1d, 0x93, 0x62, 0x2b, 0x30, 0xff, 0x58, 0x2b, 0x71, 0x46, 0x7c, 0x28, 0x9a, 0xc5, 0x55,
+	0xe3, 0x5a, 0xcd, 0x06, 0x24, 0xdd, 0xe3, 0x43, 0xc1, 0x56, 0xa1, 0xbc, 0x17, 0x08, 0xd9, 0x2c,
+	0x69, 0x75, 0xb5, 0x48, 0x9d, 0xb2, 0xc1, 0xd6, 0x1c, 0xa5, 0x22, 0x08, 0xb9, 0x0c, 0x1d, 0xdf,
+	0x73, 0x47, 0x61, 0xb3, 0x8c, 0x2a, 0x34, 0x69, 0x47, 0x51, 0xac, 0x11, 0x34, 0x67, 0x4d, 0x0e,
+	0x7c, 0x6f, 0x14, 0x08, 0xf6, 0x12, 0x98, 0xb8, 0x19, 0xd9, 0x5b, 0x8f, 0x36, 0x20, 0x39, 0xe2,
+	0xb2, 0xeb, 0xb0, 0xe4, 0x4b, 0xe1, 0x48, 0xd1, 0x11, 0xee, 0xbe, 0x70, 0x84, 0x94, 0x9e, 0xd4,
+	0xd6, 0xce, 0xd9, 0x8b, 0xbe, 0x14, 0x36, 0xd2, 0xdb, 0x8a, 0x6c, 0x7d, 0x43, 0x18, 0x6d, 0x89,
+	0x81, 0x78, 0x31, 0x30, 0xb2, 0xb6, 0x11, 0x82, 0xa4, 0x45, 0x04, 0x41, 0xa6, 0x6b, 0x46, 0xb6,
+	0x6b, 0x5f, 0x19, 0x70, 0x6a, 0xaa, 0x68, 0x97, 0xf7, 0xfe, 0x89, 0x5f, 0xe7, 0xa0, 0x1a, 0xf2,
+	0x5e, 0xdc, 0xa9, 0x4a, 0xc8, 0x7b, 0x87, 0xf4, 0x68, 0x13, 0x4e, 0xa7, 0x0c, 0xf9, 0x1b, 0xee,
+	0xfc, 0x41, 0xee, 0x60, 0x6a, 0xfc, 0x8b, 0xee, 0xb0, 0x97, 0x61, 0x31, 0xe4, 0xb2, 0x27, 0x42,
+	0x47, 0x8a, 0x7d, 0x37, 0x70, 0xbd, 0x11, 0x25, 0x72, 0x1d, 0xc9, 0x36, 0x51, 0x59, 0x13, 0x2a,
+	0x43, 0x11, 0x04, 0xbc, 0x27, 0x9a, 0x27, 0x70, 0x13, 0xfa, 0xb5, 0x3e, 0x45, 0x44, 0x62, 0xbe,
+	0x10, 0x22, 0xcb, 0x50, 0x0a, 0x79, 0x8f, 0xbc, 0x98, 0x8f, 0x36, 0x57, 0x12, 0x8a, 0xce, 0xce,
+	0x80, 0x29, 0x9e, 0xba, 0x41, 0x18, 0x68, 0xab, 0xab, 0x36, 0xfd, 0x65, 0x03, 0x59, 0xca, 0x06,
+	0xf2, 0x99, 0x01, 0x67, 0xd4, 0xe6, 0x77, 0x85, 0xec, 0x1d, 0x41, 0xc6, 0x47, 0x78, 0x15, 0x73,
+	0xf1, 0x3a, 0x0f, 0x73, 0x1d, 0x6f, 0x38, 0x74, 0x43, 0xc7, 0xed, 0x92, 0x51, 0x55, 0x24, 0xdc,
+	0xee, 0x2a, 0x8f, 0xa8, 0xa8, 0x11, 0xc3, 0xa8, 0x88, 0x73, 0xb1, 0x63, 0xa7, 0xe0, 0x04, 0xf7,
+	0xfd, 0xc1, 0xb8, 0x69, 0x6a, 0x08, 0xf0, 0xc7, 0xfa, 0x99, 0x0a, 0x39, 0xe1, 0x15, 0x81, 0x9a,
+	0x30, 0xc0, 0x48, 0x19, 0xb0, 0x01, 0x0b, 0x54, 0xb1, 0x7b, 0x7e, 0x97, 0x87, 0x82, 0x02, 0xbf,
+	0x1c, 0x39, 0x72, 0x3f, 0x6a, 0xb6, 0xa8, 0xf4, 0xa1, 0x16, 0xb2, 0x6b, 0x8f, 0x63, 0x7f, 0xd9,
+	0xf0, 0x97, 0x33, 0xe1, 0xbf, 0x53, 0xae, 0x16, 0x1b, 0x25, 0xeb, 0x73, 0x38, 0x9d, 0xa9, 0xf8,
+	0x60, 0x5b, 0x2f, 0x41, 0x4d, 0x21, 0xef, 0x74, 0x74, 0xde, 0x74, 0x29, 0x09, 0xe6, 0x15, 0x0d,
+	0x53, 0xa9, 0xcb, 0xae, 0x42, 0x9d, 0xdc, 0x89, 0x84, 0x4a, 0x5a, 0x88, 0x9c, 0x24, 0x31, 0xeb,
+	0x7b, 0x03, 0x4e, 0x2a, 0xb8, 0xb6, 0xb7, 0x5f, 0xd4, 0x0c, 0xb0, 0xbe, 0xa4, 0x82, 0x9f, 0x9a,
+	0x48, 0xe1, 0x9c, 0x89, 0x98, 0x71, 0x44, 0x11, 0xcb, 0x99, 0x11, 0xbf, 0x17, 0xa9, 0x5a, 0xfb,
+	0x42, 0xca, 0xf1, 0x8e, 0xdb, 0xf9, 0xe4, 0x78, 0xd1, 0x7a, 0x05, 0x4c, 0x04, 0x87, 0x52, 0x71,
+	0x29, 0x92, 0x79, 0xd7, 0x0d, 0x37, 0x35, 0xc3, 0x26, 0x81, 0xf4, 0xb8, 0x29, 0xcf, 0x8c, 0x9b,
+	0xfc, 0x32, 0xba, 0x0e, 0x4b, 0x38, 0x8a, 0xe3, 0x0a, 0x4c, 0x2d, 0xb3, 0xa8, 0x19, 0x1b, 0x53,
+	0x2d, 0x37, 0xa0, 0x81, 0xb2, 0x31, 0x6f, 0x2b, 0xb9, 0xde, 0xe2, 0xf2, 0x29, 0xc1, 0xfa, 0x93,
+	0x3a, 0x4e, 0x1c, 0xc0, 0xa3, 0x8d, 0x25, 0xe6, 0xba, 0x13, 0x4a, 0x91, 0x8a, 0x25, 0x32, 0x76,
+	0xa5, 0xc0, 0x58, 0xaa, 0x0a, 0xa2, 0x4c, 0x8c, 0xf7, 0xc8, 0x79, 0xa4, 0xa1, 0xc8, 0x73, 0x14,
+	0xb3, 0xf5, 0x5b, 0x11, 0x96, 0x74, 0xe4, 0xc4, 0xbe, 0x50, 0x2e, 0xff, 0x9f, 0x16, 0xcf, 0x91,
+	0x16, 0xcf, 0x0c, 0x60, 0x71, 0xf0, 0xfe, 0x1b, 0x29, 0xf1, 0x5d, 0x11, 0xce, 0xeb, 0x64, 0xd7,
+	0xeb, 0xb7, 0xdd, 0x81, 0x08, 0x6e, 0x76, 0x94, 0xb9, 0xb7, 0x04, 0xef, 0x0a, 0xc9, 0xb6, 0xc1,
+	0xe4, 0xfa, 0x5f, 0xfb, 0x55, 0x5f, 0x5f, 0x8b, 0x87, 0x3a, 0x67, 0xd1, 0x1a, 0xfe, 0xec, 0x8e,
+	0x7d, 0x61, 0xd3, 0x6a, 0xd5, 0x53, 0x3f, 0x76, 0x07, 0xc2, 0xf1, 0x79, 0xd8, 0xa7, 0x33, 0x4c,
+	0x55, 0x11, 0x76, 0x78, 0xd8, 0x67, 0x97, 0x61, 0xc1, 0x57, 0x87, 0x13, 0x6f, 0x2f, 0x40, 0x81,
+	0x92, 0x16, 0xa8, 0x45, 0x44, 0x2d, 0xa4, 0x46, 0x05, 0x0f, 0xc4, 0x9b, 0x6f, 0x38, 0x1d, 0x6f,
+	0x14, 0x0a, 0x3a, 0x8f, 0xab, 0x51, 0xa1, 0xa9, 0x9b, 0x48, 0xb4, 0xee, 0x00, 0x4c, 0xb7, 0x67,
+	0x00, 0xe6, 0xa6, 0xdd, 0xbe, 0xb9, 0xdb, 0x6e, 0x14, 0x58, 0x1d, 0x00, 0xbf, 0x9d, 0xad, 0xdb,
+	0x76, 0xc3, 0x50, 0xbc, 0x87, 0x3b, 0x5b, 0x8a, 0x57, 0x64, 0x55, 0x28, 0xdf, 0xbd, 0xff, 0xa8,
+	0xdd, 0x28, 0x29, 0xea, 0x56, 0xfb, 0xfd, 0xf6, 0x6e, 0xbb, 0x51, 0xb6, 0xbe, 0x35, 0xa8, 0x95,
+	0xa6, 0xfd, 0x64, 0x37, 0xc0, 0xec, 0x6b, 0x5f, 0x29, 0xdc, 0x97, 0x0f, 0x01, 0xcb, 0xad, 0x82,
+	0x4d, 0x8b, 0x58, 0x0b, 0x2a, 0x91, 0x13, 0x1a, 0x8b, 0x5b, 0x05, 0x3b, 0x22, 0x6c, 0x58, 0xb0,
+	0xaa, 0x0a, 0xc8, 0xa1, 0x28, 0x2b, 0x90, 0x02, 0x07, 0x51, 0x74, 0x7c, 0x3e, 0x1e, 0x78, 0xbc,
+	0x6b, 0x7d, 0x51, 0x82, 0x0b, 0xa9, 0x9d, 0xa8, 0x9a, 0x29, 0x6c, 0xc7, 0x53, 0xd3, 0xa9, 0x42,
+	0x2d, 0xcd, 0x14, 0xea, 0x55, 0xa8, 0x93, 0xd9, 0x51, 0xbd, 0x62, 0x31, 0x2f, 0x20, 0xf5, 0x2e,
+	0x55, 0xed, 0xab, 0xc0, 0x48, 0x8c, 0xef, 0x85, 0x7d, 0x4f, 0xa2, 0x3a, 0x2c, 0xed, 0x06, 0x72,
+	0x6e, 0x6a, 0x86, 0x56, 0xba, 0x06, 0x27, 0x93, 0xd2, 0x62, 0xc8, 0xdd, 0x01, 0x55, 0xf9, 0x52,
+	0x5c, 0xbc, 0xad, 0x18, 0xd9, 0x3d, 0xa1, 0x72, 0xf8, 0x9e, 0x50, 0x3d, 0x7c, 0x4f, 0xf8, 0x35,
+	0x1a, 0x15, 0x33, 0x71, 0x60, 0x6f, 0xa7, 0x32, 0xe4, 0x4a, 0x4e, 0x86, 0x24, 0xe2, 0x16, 0x4b,
+	0x91, 0xb7, 0x26, 0x85, 0x57, 0x4c, 0x36, 0x94, 0xec, 0x0c, 0x2b, 0x44, 0x95, 0xb6, 0x71, 0x19,
+	0x2e, 0xcd, 0xe6, 0x8f, 0xc4, 0x5d, 0x26, 0x09, 0xf4, 0x53, 0x74, 0xd9, 0x8e, 0x1b, 0x72, 0x84,
+	0x1d, 0x6d, 0x05, 0xe6, 0xdd, 0x51, 0x57, 0x3c, 0x4d, 0xf4, 0x32, 0xd0, 0xa4, 0x03, 0x7a, 0x54,
+	0xce, 0x15, 0xe0, 0xc7, 0xc9, 0xd8, 0x52, 0xa5, 0x7e, 0xec, 0x67, 0x3f, 0xa9, 0xb7, 0x89, 0x9d,
+	0xfd, 0x90, 0x70, 0xc0, 0xe9, 0x7f, 0x19, 0xa8, 0x08, 0x9c, 0xa0, 0xcf, 0x75, 0x1e, 0xcf, 0xd9,
+	0x73, 0x48, 0x79, 0xd0, 0xe7, 0xec, 0x1d, 0x58, 0x92, 0x62, 0xe8, 0x85, 0x22, 0x9e, 0x65, 0x66,
+	0xae, 0xc1, 0x0d, 0x14, 0x9e, 0x52, 0x54, 0x7f, 0x24, 0x05, 0xb4, 0x3d, 0x66, 0x73, 0x0d, 0x89,
+	0x18, 0x06, 0xeb, 0xb3, 0x68, 0x3c, 0x21, 0x48, 0x93, 0x1b, 0x1a, 0x90, 0x3f, 0xca, 0x34, 0x3c,
+	0xa1, 0x93, 0x87, 0xca, 0xb4, 0xe7, 0x38, 0x58, 0x2a, 0x68, 0x7a, 0xa9, 0xb1, 0x53, 0xed, 0xd1,
+	0xcc, 0xb1, 0x7e, 0xa0, 0x18, 0x3d, 0x78, 0xb2, 0xc7, 0x83, 0xe3, 0x3f, 0x9f, 0x07, 0x7a, 0x9b,
+	0x58, 0x8c, 0x90, 0x70, 0x40, 0x8c, 0xd4, 0x22, 0x5d, 0xe9, 0xd3, 0x10, 0x55, 0x35, 0x41, 0xc1,
+	0x70, 0x16, 0x2a, 0x62, 0xd4, 0xd5, 0x2c, 0x53, 0xb3, 0x4c, 0x31, 0xea, 0x2a, 0xc6, 0x15, 0x30,
+	0xb1, 0xe9, 0xd0, 0x49, 0x21, 0x69, 0x0e, 0xf1, 0x32, 0xda, 0x5e, 0x35, 0xa3, 0xed, 0x59, 0x2e,
+	0x46, 0x28, 0x82, 0x68, 0x1a, 0x21, 0xf2, 0x26, 0x16, 0x21, 0xa4, 0x28, 0x0b, 0x0e, 0x42, 0x1d,
+	0x6f, 0x67, 0xf6, 0x6c, 0x08, 0xd7, 0xbf, 0xae, 0x40, 0x63, 0x52, 0xa7, 0x0f, 0x84, 0xdc, 0x77,
+	0x3b, 0x82, 0x7d, 0x08, 0x8d, 0xf4, 0x6b, 0x15, 0x5b, 0x49, 0xb4, 0x95, 0xd9, 0xa7, 0xb7, 0xd6,
+	0x6a, 0xbe, 0x00, 0x3a, 0x60, 0x15, 0x22, 0xc5, 0xf1, 0x37, 0xa0, 0xa4, 0xe2, 0x8c, 0xf7, 0xaa,
+	0xa4, 0xe2, 0xac, 0xe7, 0x23, 0xab, 0xc0, 0xee, 0xc1, 0x42, 0xe2, 0xe1, 0x81, 0x5d, 0x98, 0xb5,
+	0x66, 0xfa, 0xb6, 0xd2, 0x5a, 0xce, 0xe1, 0xa6, 0xf5, 0x4d, 0x9e, 0x76, 0x92, 0xfa, 0xd2, 0x4f,
+	0x4f, 0x49, 0x7d, 0x33, 0xef, 0x41, 0x56, 0x81, 0x7d, 0x04, 0x8b, 0xa9, 0x5b, 0x3c, 0xbb, 0x18,
+	0x5f, 0x33, 0xfb, 0x68, 0xd1, 0x5a, 0xc9, 0xe5, 0x47, 0x5a, 0xaf, 0x19, 0xaf, 0x19, 0xec, 0x3d,
+	0xa8, 0xc5, 0x6f, 0x93, 0xec, 0x7c, 0x7c, 0x59, 0xea, 0x1a, 0xdc, 0xba, 0x90, 0xcd, 0x9c, 0x98,
+	0xf9, 0x01, 0xd4, 0x93, 0x17, 0x1a, 0x96, 0x44, 0x2a, 0x7d, 0x53, 0x6c, 0x5d, 0xcc, 0x63, 0x4f,
+	0x54, 0xb6, 0x01, 0xa6, 0x87, 0x61, 0x76, 0x2e, 0x51, 0x16, 0xf1, 0xdb, 0x45, 0xab, 0x95, 0xc5,
+	0x9a, 0xa8, 0x79, 0x84, 0x00, 0xc6, 0xc6, 0x50, 0x12, 0xc0, 0xd9, 0x41, 0x99, 0x04, 0x30, 0x63,
+	0x7e, 0x29, 0x00, 0xa7, 0xe6, 0xa9, 0x46, 0x97, 0x36, 0x2f, 0x36, 0x45, 0xd2, 0xe6, 0xc5, 0x7b,
+	0xe7, 0xd4, 0x4b, 0xac, 0xd8, 0xa4, 0x9a, 0x44, 0xa3, 0x4b, 0xaa, 0x49, 0x16, 0xb8, 0x55, 0x78,
+	0x6c, 0xea, 0x17, 0xee, 0xd7, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x36, 0x90, 0x2b, 0x73, 0x0b,
+	0x17, 0x00, 0x00,
 }

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

@@ -621,8 +621,10 @@ func (m *FindBranchResponse) GetBranch() *Branch {
 }
 
 type DeleteRefsRequest struct {
-	Repository       *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-	ExceptWithPrefix [][]byte    `protobuf:"bytes,2,rep,name=except_with_prefix,json=exceptWithPrefix,proto3" json:"except_with_prefix,omitempty"`
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// The following two fields are mutually exclusive
+	ExceptWithPrefix [][]byte `protobuf:"bytes,2,rep,name=except_with_prefix,json=exceptWithPrefix,proto3" json:"except_with_prefix,omitempty"`
+	Refs             [][]byte `protobuf:"bytes,3,rep,name=refs,proto3" json:"refs,omitempty"`
 }
 
 func (m *DeleteRefsRequest) Reset()                    { *m = DeleteRefsRequest{} }
@@ -644,7 +646,15 @@ func (m *DeleteRefsRequest) GetExceptWithPrefix() [][]byte {
 	return nil
 }
 
+func (m *DeleteRefsRequest) GetRefs() [][]byte {
+	if m != nil {
+		return m.Refs
+	}
+	return nil
+}
+
 type DeleteRefsResponse struct {
+	GitError string `protobuf:"bytes,1,opt,name=git_error,json=gitError" json:"git_error,omitempty"`
 }
 
 func (m *DeleteRefsResponse) Reset()                    { *m = DeleteRefsResponse{} }
@@ -652,9 +662,19 @@ func (m *DeleteRefsResponse) String() string            { return proto.CompactTe
 func (*DeleteRefsResponse) ProtoMessage()               {}
 func (*DeleteRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{25} }
 
+func (m *DeleteRefsResponse) GetGitError() string {
+	if m != nil {
+		return m.GitError
+	}
+	return ""
+}
+
 type ListBranchNamesContainingCommitRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 	CommitId   string      `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
+	// Limit the number of tag names to be returned
+	// If the limit is set to zero, all items will be returned
+	Limit uint32 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
 }
 
 func (m *ListBranchNamesContainingCommitRequest) Reset() {
@@ -680,6 +700,13 @@ func (m *ListBranchNamesContainingCommitRequest) GetCommitId() string {
 	return ""
 }
 
+func (m *ListBranchNamesContainingCommitRequest) GetLimit() uint32 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
 type ListBranchNamesContainingCommitResponse struct {
 	BranchNames [][]byte `protobuf:"bytes,2,rep,name=branch_names,json=branchNames,proto3" json:"branch_names,omitempty"`
 }
@@ -703,6 +730,9 @@ func (m *ListBranchNamesContainingCommitResponse) GetBranchNames() [][]byte {
 type ListTagNamesContainingCommitRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 	CommitId   string      `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
+	// Limit the number of tag names to be returned
+	// If the limit is set to zero, all items will be returned
+	Limit uint32 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
 }
 
 func (m *ListTagNamesContainingCommitRequest) Reset()         { *m = ListTagNamesContainingCommitRequest{} }
@@ -726,6 +756,13 @@ func (m *ListTagNamesContainingCommitRequest) GetCommitId() string {
 	return ""
 }
 
+func (m *ListTagNamesContainingCommitRequest) GetLimit() uint32 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
 type ListTagNamesContainingCommitResponse struct {
 	TagNames [][]byte `protobuf:"bytes,2,rep,name=tag_names,json=tagNames,proto3" json:"tag_names,omitempty"`
 }
@@ -805,8 +842,8 @@ type RefServiceClient interface {
 	DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*DeleteBranchResponse, error)
 	FindBranch(ctx context.Context, in *FindBranchRequest, opts ...grpc.CallOption) (*FindBranchResponse, error)
 	DeleteRefs(ctx context.Context, in *DeleteRefsRequest, opts ...grpc.CallOption) (*DeleteRefsResponse, error)
-	ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListBranchNamesContainingCommitResponse, error)
-	ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListTagNamesContainingCommitResponse, error)
+	ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListBranchNamesContainingCommitClient, error)
+	ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListTagNamesContainingCommitClient, error)
 }
 
 type refServiceClient struct {
@@ -1040,22 +1077,68 @@ func (c *refServiceClient) DeleteRefs(ctx context.Context, in *DeleteRefsRequest
 	return out, nil
 }
 
-func (c *refServiceClient) ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListBranchNamesContainingCommitResponse, error) {
-	out := new(ListBranchNamesContainingCommitResponse)
-	err := grpc.Invoke(ctx, "/gitaly.RefService/ListBranchNamesContainingCommit", in, out, c.cc, opts...)
+func (c *refServiceClient) ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListBranchNamesContainingCommitClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[5], c.cc, "/gitaly.RefService/ListBranchNamesContainingCommit", opts...)
 	if err != nil {
 		return nil, err
 	}
-	return out, nil
+	x := &refServiceListBranchNamesContainingCommitClient{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 RefService_ListBranchNamesContainingCommitClient interface {
+	Recv() (*ListBranchNamesContainingCommitResponse, error)
+	grpc.ClientStream
+}
+
+type refServiceListBranchNamesContainingCommitClient struct {
+	grpc.ClientStream
+}
+
+func (x *refServiceListBranchNamesContainingCommitClient) Recv() (*ListBranchNamesContainingCommitResponse, error) {
+	m := new(ListBranchNamesContainingCommitResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
 }
 
-func (c *refServiceClient) ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListTagNamesContainingCommitResponse, error) {
-	out := new(ListTagNamesContainingCommitResponse)
-	err := grpc.Invoke(ctx, "/gitaly.RefService/ListTagNamesContainingCommit", in, out, c.cc, opts...)
+func (c *refServiceClient) ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListTagNamesContainingCommitClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[6], c.cc, "/gitaly.RefService/ListTagNamesContainingCommit", opts...)
 	if err != nil {
 		return nil, err
 	}
-	return out, nil
+	x := &refServiceListTagNamesContainingCommitClient{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 RefService_ListTagNamesContainingCommitClient interface {
+	Recv() (*ListTagNamesContainingCommitResponse, error)
+	grpc.ClientStream
+}
+
+type refServiceListTagNamesContainingCommitClient struct {
+	grpc.ClientStream
+}
+
+func (x *refServiceListTagNamesContainingCommitClient) Recv() (*ListTagNamesContainingCommitResponse, error) {
+	m := new(ListTagNamesContainingCommitResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
 }
 
 // Server API for RefService service
@@ -1075,8 +1158,8 @@ type RefServiceServer interface {
 	DeleteBranch(context.Context, *DeleteBranchRequest) (*DeleteBranchResponse, error)
 	FindBranch(context.Context, *FindBranchRequest) (*FindBranchResponse, error)
 	DeleteRefs(context.Context, *DeleteRefsRequest) (*DeleteRefsResponse, error)
-	ListBranchNamesContainingCommit(context.Context, *ListBranchNamesContainingCommitRequest) (*ListBranchNamesContainingCommitResponse, error)
-	ListTagNamesContainingCommit(context.Context, *ListTagNamesContainingCommitRequest) (*ListTagNamesContainingCommitResponse, error)
+	ListBranchNamesContainingCommit(*ListBranchNamesContainingCommitRequest, RefService_ListBranchNamesContainingCommitServer) error
+	ListTagNamesContainingCommit(*ListTagNamesContainingCommitRequest, RefService_ListTagNamesContainingCommitServer) error
 }
 
 func RegisterRefServiceServer(s *grpc.Server, srv RefServiceServer) {
@@ -1314,40 +1397,46 @@ func _RefService_DeleteRefs_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
-func _RefService_ListBranchNamesContainingCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListBranchNamesContainingCommitRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RefServiceServer).ListBranchNamesContainingCommit(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.RefService/ListBranchNamesContainingCommit",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RefServiceServer).ListBranchNamesContainingCommit(ctx, req.(*ListBranchNamesContainingCommitRequest))
+func _RefService_ListBranchNamesContainingCommit_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(ListBranchNamesContainingCommitRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
 	}
-	return interceptor(ctx, in, info, handler)
+	return srv.(RefServiceServer).ListBranchNamesContainingCommit(m, &refServiceListBranchNamesContainingCommitServer{stream})
 }
 
-func _RefService_ListTagNamesContainingCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListTagNamesContainingCommitRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RefServiceServer).ListTagNamesContainingCommit(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.RefService/ListTagNamesContainingCommit",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RefServiceServer).ListTagNamesContainingCommit(ctx, req.(*ListTagNamesContainingCommitRequest))
+type RefService_ListBranchNamesContainingCommitServer interface {
+	Send(*ListBranchNamesContainingCommitResponse) error
+	grpc.ServerStream
+}
+
+type refServiceListBranchNamesContainingCommitServer struct {
+	grpc.ServerStream
+}
+
+func (x *refServiceListBranchNamesContainingCommitServer) Send(m *ListBranchNamesContainingCommitResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _RefService_ListTagNamesContainingCommit_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(ListTagNamesContainingCommitRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
 	}
-	return interceptor(ctx, in, info, handler)
+	return srv.(RefServiceServer).ListTagNamesContainingCommit(m, &refServiceListTagNamesContainingCommitServer{stream})
+}
+
+type RefService_ListTagNamesContainingCommitServer interface {
+	Send(*ListTagNamesContainingCommitResponse) error
+	grpc.ServerStream
+}
+
+type refServiceListTagNamesContainingCommitServer struct {
+	grpc.ServerStream
+}
+
+func (x *refServiceListTagNamesContainingCommitServer) Send(m *ListTagNamesContainingCommitResponse) error {
+	return x.ServerStream.SendMsg(m)
 }
 
 var _RefService_serviceDesc = grpc.ServiceDesc{
@@ -1382,14 +1471,6 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "DeleteRefs",
 			Handler:    _RefService_DeleteRefs_Handler,
 		},
-		{
-			MethodName: "ListBranchNamesContainingCommit",
-			Handler:    _RefService_ListBranchNamesContainingCommit_Handler,
-		},
-		{
-			MethodName: "ListTagNamesContainingCommit",
-			Handler:    _RefService_ListTagNamesContainingCommit_Handler,
-		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1417,6 +1498,16 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _RefService_FindAllTags_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "ListBranchNamesContainingCommit",
+			Handler:       _RefService_ListBranchNamesContainingCommit_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "ListTagNamesContainingCommit",
+			Handler:       _RefService_ListTagNamesContainingCommit_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "ref.proto",
 }
@@ -1424,82 +1515,85 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("ref.proto", fileDescriptor8) }
 
 var fileDescriptor8 = []byte{
-	// 1218 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xdd, 0x72, 0x22, 0x45,
-	0x14, 0xce, 0x10, 0x16, 0xe1, 0x80, 0x64, 0xd2, 0x89, 0x59, 0x32, 0xc4, 0x25, 0xe9, 0xdd, 0xcd,
-	0x4f, 0xb9, 0x45, 0x2c, 0xb6, 0xf4, 0x46, 0x2f, 0x24, 0x80, 0x1b, 0x76, 0x23, 0x49, 0x35, 0xb8,
-	0xa6, 0x4a, 0xad, 0xa9, 0x01, 0x1a, 0x32, 0x16, 0x30, 0x38, 0xd3, 0x64, 0x43, 0x59, 0x7a, 0xe5,
-	0x9d, 0xf7, 0x3e, 0x82, 0xaf, 0xe2, 0x85, 0x4f, 0xe2, 0x5b, 0x58, 0x74, 0xf7, 0xfc, 0x40, 0x06,
-	0x92, 0x12, 0xe3, 0x15, 0xcc, 0xe9, 0x73, 0xbe, 0xd3, 0xe7, 0xa7, 0xbf, 0x73, 0x20, 0x61, 0xd3,
-	0x4e, 0x7e, 0x68, 0x5b, 0xcc, 0x42, 0xb1, 0xae, 0xc9, 0x8c, 0xde, 0x58, 0x4b, 0x39, 0x57, 0x86,
-	0x4d, 0xdb, 0x42, 0xaa, 0xe5, 0xba, 0x96, 0xd5, 0xed, 0xd1, 0x63, 0xfe, 0xd5, 0x1c, 0x75, 0x8e,
-	0x99, 0xd9, 0xa7, 0x0e, 0x33, 0xfa, 0x43, 0xa1, 0x80, 0x09, 0xec, 0x7c, 0x69, 0x0e, 0xda, 0x65,
-	0xda, 0x31, 0x46, 0x3d, 0x76, 0x62, 0x1b, 0x83, 0xd6, 0x55, 0xcd, 0xe8, 0x53, 0x42, 0x7f, 0x1c,
-	0x51, 0x87, 0xa1, 0x02, 0x80, 0x4d, 0x87, 0x96, 0x63, 0x32, 0xcb, 0x1e, 0x67, 0x94, 0x5d, 0xe5,
-	0x30, 0x59, 0x40, 0x79, 0xe1, 0x2b, 0x4f, 0xbc, 0x13, 0x12, 0xd0, 0xc2, 0x2f, 0xe1, 0xc3, 0x39,
-	0x98, 0xce, 0xd0, 0x1a, 0x38, 0x14, 0x21, 0x88, 0x0e, 0x8c, 0x3e, 0xe5, 0x70, 0x29, 0xc2, 0xff,
-	0xe3, 0x73, 0xd8, 0x9e, 0x18, 0x15, 0x7b, 0x3d, 0xdf, 0xc0, 0x59, 0xe6, 0x16, 0x05, 0xd0, 0xc2,
-	0x00, 0xe5, 0x15, 0x36, 0xe1, 0xd1, 0xc4, 0xad, 0x93, 0x51, 0x76, 0x57, 0x0f, 0x53, 0x44, 0x7c,
-	0xe0, 0x33, 0xd8, 0x92, 0x36, 0x0d, 0xa3, 0xbb, 0xf4, 0x0d, 0x8e, 0xe1, 0xf1, 0x2d, 0xb4, 0x85,
-	0xee, 0x7f, 0x06, 0x34, 0x31, 0x20, 0xb4, 0xb3, 0x64, 0x09, 0x50, 0x16, 0x12, 0x2d, 0xab, 0xdf,
-	0x37, 0x99, 0x6e, 0xb6, 0x33, 0x91, 0x5d, 0xe5, 0x30, 0x41, 0xe2, 0x42, 0x50, 0x6d, 0xa3, 0x2d,
-	0x88, 0x0d, 0x6d, 0xda, 0x31, 0x6f, 0x32, 0xab, 0xbc, 0x00, 0xf2, 0x0b, 0x1f, 0xc1, 0xc6, 0x94,
-	0xfb, 0x05, 0xd5, 0xfa, 0x53, 0x81, 0xcc, 0x44, 0xf7, 0xcc, 0x6a, 0x19, 0x32, 0xbf, 0x4b, 0xe5,
-	0x0a, 0x7d, 0x01, 0xef, 0x39, 0x96, 0xcd, 0xf4, 0xe6, 0x98, 0x5f, 0x37, 0x5d, 0x38, 0x70, 0x0d,
-	0xe6, 0xb9, 0xc9, 0xd7, 0x2d, 0x9b, 0x9d, 0x8c, 0x49, 0xcc, 0xe1, 0xbf, 0xf8, 0x13, 0x88, 0x09,
-	0x09, 0x8a, 0x43, 0xb4, 0x56, 0xfc, 0xaa, 0xa2, 0xae, 0xa0, 0x35, 0x48, 0x7e, 0x7d, 0x51, 0x2e,
-	0x36, 0x2a, 0x65, 0xbd, 0x58, 0x2f, 0xa9, 0x0a, 0x52, 0x21, 0xe5, 0x0a, 0xca, 0x95, 0x7a, 0x49,
-	0x8d, 0xe0, 0x4b, 0xd1, 0x77, 0x33, 0x1e, 0x64, 0xe8, 0x9f, 0x41, 0xbc, 0x29, 0x65, 0xbc, 0x52,
-	0xc9, 0x42, 0x6e, 0xce, 0xb5, 0x5c, 0x13, 0xe2, 0x19, 0xe0, 0xdf, 0x22, 0xa2, 0xfe, 0x21, 0x5a,
-	0x61, 0x39, 0x5d, 0x5c, 0xb3, 0xe7, 0x90, 0x96, 0x87, 0xce, 0xa8, 0xf9, 0x03, 0x6d, 0x31, 0x59,
-	0xbb, 0xf7, 0x85, 0xb4, 0x2e, 0x84, 0xe8, 0x14, 0xa4, 0x40, 0x37, 0x46, 0xec, 0xca, 0xb2, 0x33,
-	0x51, 0x9e, 0xfd, 0xa7, 0x73, 0x6e, 0x5d, 0xe2, 0xba, 0x45, 0xae, 0x4a, 0x52, 0xad, 0xc0, 0x17,
-	0xaa, 0x81, 0x2a, 0x91, 0xc4, 0x0f, 0xa3, 0x76, 0xe6, 0xd1, 0xfd, 0xc1, 0xd6, 0x84, 0x55, 0xc9,
-	0xb5, 0xc5, 0xef, 0x20, 0xbb, 0x40, 0x3f, 0x34, 0x21, 0x9b, 0xf0, 0x88, 0xf6, 0x0d, 0xb3, 0xc7,
-	0x93, 0x91, 0x22, 0xe2, 0x03, 0xe5, 0x21, 0xda, 0x36, 0x18, 0xe5, 0xf1, 0x27, 0x0b, 0x5a, 0x5e,
-	0x30, 0x5c, 0xde, 0x65, 0xb8, 0x7c, 0xc3, 0x65, 0x38, 0xc2, 0xf5, 0xf0, 0xef, 0x8a, 0xf7, 0xa8,
-	0xff, 0x8b, 0x46, 0xcd, 0x41, 0xb2, 0x4f, 0xed, 0x2e, 0x6d, 0xeb, 0xd6, 0xa0, 0x27, 0x9a, 0x35,
-	0x4e, 0x40, 0x88, 0xce, 0x07, 0xbd, 0x31, 0x3a, 0x80, 0x35, 0xa9, 0xe0, 0xb5, 0xce, 0x2a, 0x7f,
-	0xe4, 0x69, 0x21, 0x76, 0x2f, 0x81, 0xff, 0x50, 0x3c, 0x7e, 0xb8, 0xd5, 0x78, 0x27, 0xb7, 0x1a,
-	0x6f, 0x3f, 0x98, 0xf5, 0x10, 0x93, 0xbc, 0xec, 0x30, 0xcf, 0x4e, 0x7b, 0x05, 0x31, 0x21, 0x0b,
-	0x4d, 0xee, 0x11, 0xc4, 0x98, 0x61, 0x77, 0x29, 0xe3, 0x21, 0x24, 0x0b, 0xeb, 0x2e, 0xfe, 0x2b,
-	0xb7, 0x6a, 0x44, 0x2a, 0xe0, 0x53, 0x41, 0x4b, 0x82, 0xc7, 0x96, 0x62, 0xc4, 0x4f, 0x05, 0xc3,
-	0x78, 0x48, 0x32, 0xda, 0x1c, 0x44, 0x99, 0xd1, 0x75, 0x23, 0x4d, 0xba, 0x20, 0x0d, 0xa3, 0x4b,
-	0xf8, 0x01, 0xbe, 0x04, 0x95, 0xd0, 0x4e, 0xe5, 0xc6, 0x74, 0xd8, 0x52, 0xc5, 0x53, 0x61, 0xd5,
-	0xa6, 0x1d, 0xd9, 0x4f, 0x93, 0xbf, 0xf8, 0x08, 0xd6, 0x03, 0xc8, 0x3e, 0x3b, 0x5f, 0x1b, 0xbd,
-	0x91, 0x48, 0x58, 0x9c, 0x88, 0x0f, 0xfc, 0x0b, 0x6c, 0x94, 0x6c, 0x6a, 0x30, 0xea, 0xbe, 0xe5,
-	0x7f, 0x7f, 0x0f, 0xb7, 0x20, 0x91, 0x40, 0x41, 0x72, 0x90, 0x74, 0x98, 0x61, 0x33, 0x7d, 0x68,
-	0x99, 0x03, 0xf7, 0x79, 0x03, 0x17, 0x5d, 0x4c, 0x24, 0xf8, 0x2f, 0x05, 0x36, 0xa7, 0x2f, 0xe0,
-	0xb1, 0x54, 0xcc, 0x61, 0x06, 0x1b, 0x39, 0xdc, 0x7b, 0xda, 0x7f, 0xa0, 0x61, 0xda, 0xf9, 0x3a,
-	0x57, 0x25, 0xd2, 0x04, 0xed, 0x43, 0x4c, 0x74, 0x8c, 0xec, 0x83, 0xb4, 0x6b, 0x2c, 0xcd, 0xe4,
-	0x29, 0xae, 0x41, 0x4c, 0x58, 0xa2, 0x18, 0x44, 0xce, 0xdf, 0xa8, 0x2b, 0x28, 0x0d, 0x50, 0x21,
-	0x44, 0xaf, 0x5c, 0x56, 0xeb, 0x8d, 0xba, 0xaa, 0x4c, 0xc8, 0x76, 0xf2, 0x5d, 0xad, 0xbd, 0x2d,
-	0x9e, 0x55, 0xcb, 0x6a, 0x04, 0x65, 0xe1, 0x71, 0x40, 0xa0, 0xd7, 0x1b, 0x45, 0xd2, 0xd0, 0x2f,
-	0xce, 0xab, 0xb5, 0x86, 0xba, 0x8a, 0xbf, 0x87, 0x8d, 0x32, 0xed, 0xd1, 0x07, 0xca, 0x26, 0xde,
-	0x82, 0xcd, 0x69, 0x78, 0x11, 0x3d, 0xfe, 0x16, 0xd6, 0x27, 0x1d, 0xf8, 0x30, 0x4e, 0x3f, 0x17,
-	0x0f, 0x65, 0xa6, 0x3c, 0x7e, 0x86, 0x95, 0x85, 0x19, 0x1e, 0xc1, 0xba, 0xb8, 0x32, 0xa1, 0x9d,
-	0xa5, 0xba, 0xfc, 0x05, 0x20, 0x7a, 0xd3, 0xa2, 0x43, 0xa6, 0xbf, 0x33, 0xd9, 0x95, 0x2e, 0x67,
-	0x7d, 0x84, 0x93, 0x90, 0x2a, 0x4e, 0xbe, 0x31, 0xd9, 0xd5, 0x85, 0x98, 0xfa, 0x9b, 0x80, 0x82,
-	0x6e, 0x65, 0x9e, 0xc6, 0xb0, 0x7f, 0x66, 0x3a, 0x81, 0xe5, 0xcd, 0x29, 0x59, 0x03, 0x66, 0x98,
-	0x03, 0x73, 0xd0, 0x95, 0xf4, 0xf0, 0x40, 0xeb, 0x09, 0x26, 0x70, 0x70, 0xa7, 0x6b, 0x99, 0xda,
-	0x3d, 0x48, 0x89, 0xe4, 0xe9, 0x62, 0x9b, 0x12, 0x31, 0x26, 0x9b, 0xbe, 0xe9, 0xeb, 0x68, 0x5c,
-	0x51, 0x23, 0xf8, 0x1a, 0x9e, 0x4e, 0x30, 0xdd, 0x3d, 0xec, 0x7f, 0x8b, 0xa5, 0x0a, 0xcf, 0x16,
-	0xfb, 0x95, 0x81, 0x64, 0x21, 0xc1, 0x8c, 0xee, 0x54, 0x14, 0x71, 0x26, 0x8d, 0x44, 0x08, 0x85,
-	0xbf, 0x13, 0x00, 0x84, 0x76, 0xea, 0xd4, 0xbe, 0x36, 0x5b, 0x14, 0x75, 0xe0, 0x83, 0xd0, 0x25,
-	0x1b, 0x3d, 0x0b, 0x0e, 0x8a, 0x79, 0x7b, 0xbd, 0xf6, 0xfc, 0x0e, 0x2d, 0xd9, 0x06, 0x2b, 0x48,
-	0xf7, 0xc8, 0x3f, 0x50, 0x10, 0xb4, 0x17, 0x3a, 0x8d, 0x82, 0x1b, 0xb3, 0x86, 0x17, 0xa9, 0xb8,
-	0xf0, 0x1f, 0x2b, 0xe8, 0x2d, 0xac, 0xcd, 0x6c, 0xc9, 0xe8, 0xc9, 0x8c, 0xe9, 0xcc, 0x32, 0xae,
-	0xe5, 0xe6, 0x9e, 0x07, 0x70, 0x4f, 0x21, 0x19, 0xd8, 0x66, 0x91, 0x16, 0xb4, 0x99, 0xde, 0xb0,
-	0xb5, 0x6c, 0xe8, 0x99, 0x97, 0x82, 0xef, 0x04, 0x67, 0x4c, 0xad, 0x88, 0x68, 0xf7, 0xae, 0xfd,
-	0x54, 0xdb, 0x5b, 0xa0, 0x11, 0x1a, 0xbf, 0x87, 0xfd, 0x64, 0xee, 0xac, 0x0f, 0x8f, 0x3f, 0x14,
-	0xf7, 0xb5, 0x88, 0x5f, 0xce, 0xda, 0xe9, 0xf8, 0xa7, 0x47, 0xf9, 0x74, 0xfc, 0x33, 0xc3, 0x99,
-	0x63, 0x9d, 0x40, 0xc2, 0x9b, 0x92, 0x28, 0xe3, 0x3f, 0x88, 0xe9, 0x91, 0xac, 0x6d, 0x87, 0x9c,
-	0x78, 0x59, 0x7c, 0x03, 0xa9, 0xe0, 0x3c, 0x42, 0xd9, 0xf0, 0x29, 0x25, 0x90, 0x76, 0x16, 0x8d,
-	0x30, 0x01, 0x16, 0xa4, 0x77, 0x1f, 0x2c, 0x64, 0xa6, 0xf8, 0x60, 0xa1, 0x13, 0x61, 0x05, 0x55,
-	0x00, 0x7c, 0xda, 0x46, 0xdb, 0xc1, 0x64, 0x4c, 0x03, 0x69, 0x61, 0x47, 0x41, 0x18, 0x9f, 0x48,
-	0x7d, 0x98, 0x5b, 0x9c, 0xee, 0xc3, 0x84, 0xf0, 0xee, 0x0a, 0xfa, 0x55, 0x81, 0xdc, 0x1d, 0xfc,
-	0x87, 0xf2, 0x2e, 0xc2, 0xfd, 0x38, 0x5a, 0x3b, 0xbe, 0xb7, 0xbe, 0x77, 0x8d, 0x9f, 0x60, 0x67,
-	0x11, 0x73, 0xa1, 0x8f, 0x82, 0x90, 0x77, 0xf0, 0xaa, 0xf6, 0xe2, 0x7e, 0xca, 0xae, 0xf3, 0x66,
-	0x8c, 0x6f, 0xf3, 0x2f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x58, 0x18, 0xe8, 0x58, 0xe0, 0x10,
+	// 1266 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xdd, 0x6e, 0x1a, 0xc7,
+	0x17, 0xf7, 0x62, 0xcc, 0x1f, 0x0e, 0x04, 0xaf, 0x27, 0xfe, 0x27, 0x64, 0x49, 0x83, 0x33, 0xf9,
+	0xb4, 0x1a, 0xe1, 0x96, 0xa8, 0xbd, 0x69, 0x2f, 0x8a, 0x81, 0xc6, 0x24, 0x2e, 0xb6, 0x06, 0x9a,
+	0x5a, 0x6a, 0xab, 0xd5, 0x02, 0xc3, 0x7a, 0x2b, 0x60, 0xe9, 0xee, 0x90, 0xd8, 0x17, 0xe9, 0x65,
+	0xa5, 0xaa, 0x95, 0x7a, 0xd7, 0x47, 0xe8, 0xab, 0xf4, 0xa2, 0xcf, 0xd2, 0x77, 0xa8, 0x76, 0x66,
+	0xf6, 0x03, 0xbc, 0x60, 0xab, 0xd4, 0xea, 0x15, 0x3b, 0x67, 0xce, 0xf9, 0xcd, 0xf9, 0x98, 0xf9,
+	0x9d, 0x03, 0x64, 0x1c, 0x3a, 0x28, 0x4f, 0x1c, 0x9b, 0xd9, 0x28, 0x65, 0x5a, 0xcc, 0x18, 0x9e,
+	0x6b, 0x39, 0xf7, 0xd4, 0x70, 0x68, 0x5f, 0x48, 0xb5, 0x92, 0x69, 0xdb, 0xe6, 0x90, 0xee, 0xf1,
+	0x55, 0x77, 0x3a, 0xd8, 0x63, 0xd6, 0x88, 0xba, 0xcc, 0x18, 0x4d, 0x84, 0x02, 0x26, 0x70, 0xf7,
+	0x73, 0x6b, 0xdc, 0xaf, 0xd3, 0x81, 0x31, 0x1d, 0xb2, 0x7d, 0xc7, 0x18, 0xf7, 0x4e, 0x5b, 0xc6,
+	0x88, 0x12, 0xfa, 0xfd, 0x94, 0xba, 0x0c, 0x55, 0x00, 0x1c, 0x3a, 0xb1, 0x5d, 0x8b, 0xd9, 0xce,
+	0x79, 0x41, 0xd9, 0x51, 0x9e, 0x66, 0x2b, 0xa8, 0x2c, 0xce, 0x2a, 0x93, 0x60, 0x87, 0x44, 0xb4,
+	0xf0, 0x73, 0x78, 0x6f, 0x01, 0xa6, 0x3b, 0xb1, 0xc7, 0x2e, 0x45, 0x08, 0x92, 0x63, 0x63, 0x44,
+	0x39, 0x5c, 0x8e, 0xf0, 0x6f, 0x7c, 0x04, 0x77, 0x3c, 0xa3, 0xea, 0x70, 0x18, 0x1a, 0xb8, 0xab,
+	0x78, 0x51, 0x01, 0x2d, 0x0e, 0x50, 0xba, 0xb0, 0x0d, 0x1b, 0xde, 0xb1, 0x6e, 0x41, 0xd9, 0x59,
+	0x7f, 0x9a, 0x23, 0x62, 0x81, 0x0f, 0xe1, 0x96, 0xb4, 0xe9, 0x18, 0xe6, 0xca, 0x1e, 0xec, 0xc1,
+	0xed, 0x0b, 0x68, 0x4b, 0x8f, 0x7f, 0x07, 0xc8, 0x33, 0x20, 0x74, 0xb0, 0x62, 0x09, 0x50, 0x11,
+	0x32, 0x3d, 0x7b, 0x34, 0xb2, 0x98, 0x6e, 0xf5, 0x0b, 0x89, 0x1d, 0xe5, 0x69, 0x86, 0xa4, 0x85,
+	0xa0, 0xd9, 0x47, 0xb7, 0x20, 0x35, 0x71, 0xe8, 0xc0, 0x3a, 0x2b, 0xac, 0xf3, 0x02, 0xc8, 0x15,
+	0xde, 0x85, 0x9b, 0x33, 0xc7, 0x2f, 0xa9, 0xd6, 0x1f, 0x0a, 0x14, 0x3c, 0xdd, 0x43, 0xbb, 0x67,
+	0xc8, 0xfc, 0xae, 0x94, 0x2b, 0xf4, 0x19, 0xfc, 0xcf, 0xb5, 0x1d, 0xa6, 0x77, 0xcf, 0xb9, 0xbb,
+	0xf9, 0xca, 0x13, 0xdf, 0x60, 0xd1, 0x31, 0xe5, 0xb6, 0xed, 0xb0, 0xfd, 0x73, 0x92, 0x72, 0xf9,
+	0x2f, 0xfe, 0x08, 0x52, 0x42, 0x82, 0xd2, 0x90, 0x6c, 0x55, 0xbf, 0x68, 0xa8, 0x6b, 0x68, 0x13,
+	0xb2, 0x5f, 0x1e, 0xd7, 0xab, 0x9d, 0x46, 0x5d, 0xaf, 0xb6, 0x6b, 0xaa, 0x82, 0x54, 0xc8, 0xf9,
+	0x82, 0x7a, 0xa3, 0x5d, 0x53, 0x13, 0xf8, 0x44, 0xdc, 0xbb, 0xb9, 0x13, 0x64, 0xe8, 0x9f, 0x40,
+	0xba, 0x2b, 0x65, 0xbc, 0x52, 0xd9, 0x4a, 0x69, 0x81, 0x5b, 0xbe, 0x09, 0x09, 0x0c, 0xf0, 0xcf,
+	0x09, 0x51, 0xff, 0x18, 0xad, 0xb8, 0x9c, 0x2e, 0xaf, 0xd9, 0x23, 0xc8, 0xcb, 0x4d, 0x77, 0xda,
+	0xfd, 0x8e, 0xf6, 0x98, 0xac, 0xdd, 0x0d, 0x21, 0x6d, 0x0b, 0x21, 0x3a, 0x00, 0x29, 0xd0, 0x8d,
+	0x29, 0x3b, 0xb5, 0x9d, 0x42, 0x92, 0x67, 0xff, 0xc1, 0x02, 0xaf, 0x6b, 0x5c, 0xb7, 0xca, 0x55,
+	0x49, 0xae, 0x17, 0x59, 0xa1, 0x16, 0xa8, 0x12, 0x49, 0xfc, 0x30, 0xea, 0x14, 0x36, 0xae, 0x0e,
+	0xb6, 0x29, 0xac, 0x6a, 0xbe, 0x2d, 0x7e, 0x0b, 0xc5, 0x25, 0xfa, 0xb1, 0x09, 0xd9, 0x86, 0x0d,
+	0x3a, 0x32, 0xac, 0x21, 0x4f, 0x46, 0x8e, 0x88, 0x05, 0x2a, 0x43, 0xb2, 0x6f, 0x30, 0xca, 0xe3,
+	0xcf, 0x56, 0xb4, 0xb2, 0x60, 0xb8, 0xb2, 0xcf, 0x70, 0xe5, 0x8e, 0xcf, 0x70, 0x84, 0xeb, 0xe1,
+	0xdf, 0x94, 0xe0, 0x51, 0xff, 0x1b, 0x17, 0xb5, 0x04, 0xd9, 0x11, 0x75, 0x4c, 0xda, 0xd7, 0xed,
+	0xf1, 0x50, 0x5c, 0xd6, 0x34, 0x01, 0x21, 0x3a, 0x1a, 0x0f, 0xcf, 0xd1, 0x13, 0xd8, 0x94, 0x0a,
+	0xc1, 0xd5, 0x59, 0xe7, 0x8f, 0x3c, 0x2f, 0xc4, 0xbe, 0x13, 0xf8, 0x77, 0x25, 0xe0, 0x87, 0x0b,
+	0x17, 0x6f, 0xff, 0xc2, 0xc5, 0x7b, 0x1c, 0xcd, 0x7a, 0x8c, 0x49, 0x59, 0xde, 0xb0, 0xc0, 0x4e,
+	0x7b, 0x01, 0x29, 0x21, 0x8b, 0x4d, 0xee, 0x2e, 0xa4, 0x98, 0xe1, 0x98, 0x94, 0xf1, 0x10, 0xb2,
+	0x95, 0x2d, 0x1f, 0xff, 0x85, 0x5f, 0x35, 0x22, 0x15, 0xf0, 0x81, 0xa0, 0x25, 0xc1, 0x63, 0x2b,
+	0x31, 0xe2, 0xc7, 0x82, 0x61, 0x02, 0x24, 0x19, 0x6d, 0x09, 0x92, 0xcc, 0x30, 0xfd, 0x48, 0xb3,
+	0x3e, 0x48, 0xc7, 0x30, 0x09, 0xdf, 0xc0, 0x27, 0xa0, 0x12, 0x3a, 0x68, 0x9c, 0x59, 0x2e, 0x5b,
+	0xa9, 0x78, 0x2a, 0xac, 0x3b, 0x74, 0x20, 0xef, 0x93, 0xf7, 0x89, 0x77, 0x61, 0x2b, 0x82, 0x1c,
+	0xb2, 0xf3, 0x1b, 0x63, 0x38, 0x15, 0x09, 0x4b, 0x13, 0xb1, 0xc0, 0x3f, 0xc0, 0xcd, 0x9a, 0x43,
+	0x0d, 0x46, 0xfd, 0xb7, 0xfc, 0xcf, 0xfd, 0xf0, 0x0b, 0x92, 0x88, 0x14, 0xa4, 0x04, 0x59, 0x97,
+	0x19, 0x0e, 0xd3, 0x27, 0xb6, 0x35, 0xf6, 0x9f, 0x37, 0x70, 0xd1, 0xb1, 0x27, 0xc1, 0x7f, 0x2a,
+	0xb0, 0x3d, 0xeb, 0x40, 0xc0, 0x52, 0x29, 0x97, 0x19, 0x6c, 0xea, 0xf2, 0xd3, 0xf3, 0xe1, 0x03,
+	0x8d, 0xd3, 0x2e, 0xb7, 0xb9, 0x2a, 0x91, 0x26, 0xe8, 0x31, 0xa4, 0xc4, 0x8d, 0x91, 0xf7, 0x20,
+	0xef, 0x1b, 0x4b, 0x33, 0xb9, 0x8b, 0x5b, 0x90, 0x12, 0x96, 0x28, 0x05, 0x89, 0xa3, 0x57, 0xea,
+	0x1a, 0xca, 0x03, 0x34, 0x08, 0xd1, 0x1b, 0x27, 0xcd, 0x76, 0xa7, 0xad, 0x2a, 0x1e, 0xd9, 0x7a,
+	0xeb, 0x66, 0xeb, 0x75, 0xf5, 0xb0, 0x59, 0x57, 0x13, 0xa8, 0x08, 0xb7, 0x23, 0x02, 0xbd, 0xdd,
+	0xa9, 0x92, 0x8e, 0x7e, 0x7c, 0xd4, 0x6c, 0x75, 0xd4, 0x75, 0xfc, 0x2d, 0xdc, 0xac, 0xd3, 0x21,
+	0xbd, 0xa6, 0x6c, 0xe2, 0x5b, 0xb0, 0x3d, 0x0b, 0x2f, 0xa2, 0xc7, 0x5f, 0xc3, 0x96, 0x77, 0x03,
+	0xaf, 0xe7, 0xd0, 0x4f, 0xc5, 0x43, 0x99, 0x2b, 0x4f, 0x98, 0x61, 0x65, 0x69, 0x86, 0x7f, 0x52,
+	0x60, 0x4b, 0xf8, 0x4c, 0xe8, 0x60, 0xa5, 0x6b, 0xfe, 0x0c, 0x10, 0x3d, 0xeb, 0xd1, 0x09, 0xd3,
+	0xdf, 0x5a, 0xec, 0x54, 0x97, 0xcd, 0x3e, 0xc1, 0x59, 0x48, 0x15, 0x3b, 0x5f, 0x59, 0xec, 0xf4,
+	0x98, 0xcb, 0xbd, 0x48, 0x1c, 0x3a, 0xf0, 0x59, 0x8a, 0x7f, 0xe3, 0x0f, 0x01, 0x45, 0x5d, 0x91,
+	0x91, 0x14, 0x21, 0x63, 0x5a, 0x4c, 0xa7, 0x8e, 0x63, 0x3b, 0xdc, 0x95, 0x0c, 0x49, 0x9b, 0x16,
+	0x6b, 0x78, 0x6b, 0xfc, 0xab, 0x02, 0x8f, 0x0f, 0x2d, 0x37, 0x32, 0xef, 0xb9, 0x35, 0x7b, 0xcc,
+	0x0c, 0x6b, 0x6c, 0x8d, 0x4d, 0xc9, 0x28, 0xd7, 0x35, 0xd1, 0x6c, 0xc3, 0xc6, 0xd0, 0x1a, 0x59,
+	0xe2, 0xd5, 0xdc, 0x20, 0x62, 0x81, 0x09, 0x3c, 0xb9, 0xd4, 0x21, 0x19, 0xd9, 0x7d, 0xc8, 0x89,
+	0x2a, 0xe8, 0x62, 0x2c, 0x13, 0xb9, 0xca, 0x76, 0x43, 0xd3, 0x97, 0xc9, 0xb4, 0xa2, 0x26, 0xf0,
+	0x2f, 0x0a, 0x3c, 0xf0, 0x40, 0xfd, 0x89, 0xee, 0x3f, 0x0e, 0xb1, 0x09, 0x0f, 0x97, 0x7b, 0x13,
+	0x56, 0x8e, 0x19, 0xe6, 0x4c, 0x70, 0x69, 0x26, 0x8d, 0x44, 0x64, 0x95, 0xbf, 0x32, 0x00, 0x84,
+	0x0e, 0xda, 0xd4, 0x79, 0x63, 0xf5, 0x28, 0x1a, 0xc0, 0xff, 0x63, 0x87, 0x78, 0xf4, 0x30, 0xda,
+	0x88, 0x16, 0xfd, 0x6f, 0xd0, 0x1e, 0x5d, 0xa2, 0x25, 0x9f, 0xe3, 0x1a, 0xd2, 0x83, 0xe6, 0x12,
+	0xa9, 0x13, 0xba, 0x1f, 0xdb, 0xed, 0xa2, 0x13, 0xb9, 0x86, 0x97, 0xa9, 0xf8, 0xf0, 0x1f, 0x28,
+	0xe8, 0x35, 0x6c, 0xce, 0x4d, 0xe1, 0xe8, 0xde, 0x9c, 0xe9, 0xdc, 0xb0, 0xaf, 0x95, 0x16, 0xee,
+	0x47, 0x70, 0x0f, 0x20, 0x1b, 0x99, 0x96, 0x91, 0x16, 0xb5, 0x99, 0x9d, 0xe0, 0xb5, 0x62, 0xec,
+	0x5e, 0x90, 0x82, 0x6f, 0x04, 0x27, 0xcd, 0x8c, 0xa0, 0x68, 0xe7, 0xb2, 0xf9, 0x57, 0xbb, 0xbf,
+	0x44, 0x23, 0x36, 0xfe, 0x00, 0xfb, 0xde, 0xc2, 0x59, 0x22, 0x3e, 0xfe, 0x58, 0xdc, 0x97, 0x22,
+	0x7e, 0xd9, 0xcb, 0x67, 0xe3, 0x9f, 0x1d, 0x15, 0x66, 0xe3, 0x9f, 0x6b, 0xfe, 0x1c, 0x6b, 0x1f,
+	0x32, 0x41, 0x17, 0x46, 0x85, 0xf0, 0x99, 0xcc, 0xb6, 0x7c, 0xed, 0x4e, 0xcc, 0x4e, 0x90, 0xc5,
+	0x57, 0x90, 0x8b, 0xf6, 0x3b, 0x54, 0x8c, 0xef, 0x82, 0x02, 0xe9, 0xee, 0xb2, 0x16, 0x29, 0xc0,
+	0xa2, 0xed, 0x23, 0x04, 0x8b, 0xe9, 0x59, 0x21, 0x58, 0x6c, 0xc7, 0x59, 0x43, 0x0d, 0x80, 0xb0,
+	0x2d, 0xa0, 0x3b, 0xd1, 0x64, 0xcc, 0x02, 0x69, 0x71, 0x5b, 0x51, 0x98, 0x90, 0x93, 0x43, 0x98,
+	0x0b, 0x2d, 0x23, 0x84, 0xb9, 0x48, 0xe1, 0x78, 0x0d, 0xfd, 0xa8, 0x40, 0xe9, 0x12, 0x5a, 0x44,
+	0x65, 0x1f, 0xe1, 0x6a, 0x84, 0xae, 0xed, 0x5d, 0x59, 0x3f, 0x52, 0xf4, 0x77, 0x70, 0x77, 0x19,
+	0x77, 0xa1, 0xf7, 0xa3, 0xa0, 0x97, 0xf0, 0xad, 0xf6, 0xec, 0x6a, 0xca, 0xe1, 0xf1, 0xdd, 0x14,
+	0xff, 0xc7, 0xf0, 0xfc, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0xfb, 0x20, 0x30, 0x44, 0x11,
 	0x00, 0x00,
 }

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

@@ -43,7 +43,7 @@ func (x GetArchiveRequest_Format) String() string {
 	return proto.EnumName(GetArchiveRequest_Format_name, int32(x))
 }
 func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{18, 0}
+	return fileDescriptor10, []int{16, 0}
 }
 
 type RepositoryExistsRequest struct {
@@ -78,38 +78,6 @@ func (m *RepositoryExistsResponse) GetExists() bool {
 	return false
 }
 
-type RepositoryIsEmptyRequest struct {
-	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
-}
-
-func (m *RepositoryIsEmptyRequest) Reset()                    { *m = RepositoryIsEmptyRequest{} }
-func (m *RepositoryIsEmptyRequest) String() string            { return proto.CompactTextString(m) }
-func (*RepositoryIsEmptyRequest) ProtoMessage()               {}
-func (*RepositoryIsEmptyRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
-
-func (m *RepositoryIsEmptyRequest) GetRepository() *Repository {
-	if m != nil {
-		return m.Repository
-	}
-	return nil
-}
-
-type RepositoryIsEmptyResponse struct {
-	IsEmpty bool `protobuf:"varint,1,opt,name=is_empty,json=isEmpty" json:"is_empty,omitempty"`
-}
-
-func (m *RepositoryIsEmptyResponse) Reset()                    { *m = RepositoryIsEmptyResponse{} }
-func (m *RepositoryIsEmptyResponse) String() string            { return proto.CompactTextString(m) }
-func (*RepositoryIsEmptyResponse) ProtoMessage()               {}
-func (*RepositoryIsEmptyResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
-
-func (m *RepositoryIsEmptyResponse) GetIsEmpty() bool {
-	if m != nil {
-		return m.IsEmpty
-	}
-	return false
-}
-
 type RepackIncrementalRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 }
@@ -117,7 +85,7 @@ type RepackIncrementalRequest struct {
 func (m *RepackIncrementalRequest) Reset()                    { *m = RepackIncrementalRequest{} }
 func (m *RepackIncrementalRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepackIncrementalRequest) ProtoMessage()               {}
-func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{4} }
+func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
 
 func (m *RepackIncrementalRequest) GetRepository() *Repository {
 	if m != nil {
@@ -132,7 +100,7 @@ type RepackIncrementalResponse struct {
 func (m *RepackIncrementalResponse) Reset()                    { *m = RepackIncrementalResponse{} }
 func (m *RepackIncrementalResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepackIncrementalResponse) ProtoMessage()               {}
-func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{5} }
+func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
 
 type RepackFullRequest struct {
 	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -142,7 +110,7 @@ type RepackFullRequest struct {
 func (m *RepackFullRequest) Reset()                    { *m = RepackFullRequest{} }
 func (m *RepackFullRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepackFullRequest) ProtoMessage()               {}
-func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{6} }
+func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{4} }
 
 func (m *RepackFullRequest) GetRepository() *Repository {
 	if m != nil {
@@ -164,7 +132,7 @@ type RepackFullResponse struct {
 func (m *RepackFullResponse) Reset()                    { *m = RepackFullResponse{} }
 func (m *RepackFullResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepackFullResponse) ProtoMessage()               {}
-func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{7} }
+func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{5} }
 
 type GarbageCollectRequest struct {
 	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -174,7 +142,7 @@ type GarbageCollectRequest struct {
 func (m *GarbageCollectRequest) Reset()                    { *m = GarbageCollectRequest{} }
 func (m *GarbageCollectRequest) String() string            { return proto.CompactTextString(m) }
 func (*GarbageCollectRequest) ProtoMessage()               {}
-func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{8} }
+func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{6} }
 
 func (m *GarbageCollectRequest) GetRepository() *Repository {
 	if m != nil {
@@ -196,7 +164,7 @@ type GarbageCollectResponse struct {
 func (m *GarbageCollectResponse) Reset()                    { *m = GarbageCollectResponse{} }
 func (m *GarbageCollectResponse) String() string            { return proto.CompactTextString(m) }
 func (*GarbageCollectResponse) ProtoMessage()               {}
-func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{9} }
+func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{7} }
 
 type RepositorySizeRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -205,7 +173,7 @@ type RepositorySizeRequest struct {
 func (m *RepositorySizeRequest) Reset()                    { *m = RepositorySizeRequest{} }
 func (m *RepositorySizeRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepositorySizeRequest) ProtoMessage()               {}
-func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{10} }
+func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{8} }
 
 func (m *RepositorySizeRequest) GetRepository() *Repository {
 	if m != nil {
@@ -222,7 +190,7 @@ type RepositorySizeResponse struct {
 func (m *RepositorySizeResponse) Reset()                    { *m = RepositorySizeResponse{} }
 func (m *RepositorySizeResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepositorySizeResponse) ProtoMessage()               {}
-func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{11} }
+func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{9} }
 
 func (m *RepositorySizeResponse) GetSize() int64 {
 	if m != nil {
@@ -239,7 +207,7 @@ type ApplyGitattributesRequest struct {
 func (m *ApplyGitattributesRequest) Reset()                    { *m = ApplyGitattributesRequest{} }
 func (m *ApplyGitattributesRequest) String() string            { return proto.CompactTextString(m) }
 func (*ApplyGitattributesRequest) ProtoMessage()               {}
-func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{12} }
+func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{10} }
 
 func (m *ApplyGitattributesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -261,7 +229,7 @@ type ApplyGitattributesResponse struct {
 func (m *ApplyGitattributesResponse) Reset()                    { *m = ApplyGitattributesResponse{} }
 func (m *ApplyGitattributesResponse) String() string            { return proto.CompactTextString(m) }
 func (*ApplyGitattributesResponse) ProtoMessage()               {}
-func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{13} }
+func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{11} }
 
 type FetchRemoteRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -271,12 +239,13 @@ type FetchRemoteRequest struct {
 	Timeout    int32       `protobuf:"varint,5,opt,name=timeout" json:"timeout,omitempty"`
 	SshKey     string      `protobuf:"bytes,6,opt,name=ssh_key,json=sshKey" json:"ssh_key,omitempty"`
 	KnownHosts string      `protobuf:"bytes,7,opt,name=known_hosts,json=knownHosts" json:"known_hosts,omitempty"`
+	NoPrune    bool        `protobuf:"varint,9,opt,name=no_prune,json=noPrune" json:"no_prune,omitempty"`
 }
 
 func (m *FetchRemoteRequest) Reset()                    { *m = FetchRemoteRequest{} }
 func (m *FetchRemoteRequest) String() string            { return proto.CompactTextString(m) }
 func (*FetchRemoteRequest) ProtoMessage()               {}
-func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{14} }
+func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{12} }
 
 func (m *FetchRemoteRequest) GetRepository() *Repository {
 	if m != nil {
@@ -327,13 +296,20 @@ func (m *FetchRemoteRequest) GetKnownHosts() string {
 	return ""
 }
 
+func (m *FetchRemoteRequest) GetNoPrune() bool {
+	if m != nil {
+		return m.NoPrune
+	}
+	return false
+}
+
 type FetchRemoteResponse struct {
 }
 
 func (m *FetchRemoteResponse) Reset()                    { *m = FetchRemoteResponse{} }
 func (m *FetchRemoteResponse) String() string            { return proto.CompactTextString(m) }
 func (*FetchRemoteResponse) ProtoMessage()               {}
-func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{15} }
+func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{13} }
 
 type CreateRepositoryRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -342,7 +318,7 @@ type CreateRepositoryRequest struct {
 func (m *CreateRepositoryRequest) Reset()                    { *m = CreateRepositoryRequest{} }
 func (m *CreateRepositoryRequest) String() string            { return proto.CompactTextString(m) }
 func (*CreateRepositoryRequest) ProtoMessage()               {}
-func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{16} }
+func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{14} }
 
 func (m *CreateRepositoryRequest) GetRepository() *Repository {
 	if m != nil {
@@ -357,7 +333,7 @@ type CreateRepositoryResponse struct {
 func (m *CreateRepositoryResponse) Reset()                    { *m = CreateRepositoryResponse{} }
 func (m *CreateRepositoryResponse) String() string            { return proto.CompactTextString(m) }
 func (*CreateRepositoryResponse) ProtoMessage()               {}
-func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{17} }
+func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{15} }
 
 type GetArchiveRequest struct {
 	Repository *Repository              `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -369,7 +345,7 @@ type GetArchiveRequest struct {
 func (m *GetArchiveRequest) Reset()                    { *m = GetArchiveRequest{} }
 func (m *GetArchiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetArchiveRequest) ProtoMessage()               {}
-func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{18} }
+func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{16} }
 
 func (m *GetArchiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -406,7 +382,7 @@ type GetArchiveResponse struct {
 func (m *GetArchiveResponse) Reset()                    { *m = GetArchiveResponse{} }
 func (m *GetArchiveResponse) String() string            { return proto.CompactTextString(m) }
 func (*GetArchiveResponse) ProtoMessage()               {}
-func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{19} }
+func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{17} }
 
 func (m *GetArchiveResponse) GetData() []byte {
 	if m != nil {
@@ -422,7 +398,7 @@ type HasLocalBranchesRequest struct {
 func (m *HasLocalBranchesRequest) Reset()                    { *m = HasLocalBranchesRequest{} }
 func (m *HasLocalBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*HasLocalBranchesRequest) ProtoMessage()               {}
-func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{20} }
+func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{18} }
 
 func (m *HasLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -438,7 +414,7 @@ type HasLocalBranchesResponse struct {
 func (m *HasLocalBranchesResponse) Reset()                    { *m = HasLocalBranchesResponse{} }
 func (m *HasLocalBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*HasLocalBranchesResponse) ProtoMessage()               {}
-func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{21} }
+func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{19} }
 
 func (m *HasLocalBranchesResponse) GetValue() bool {
 	if m != nil {
@@ -457,7 +433,7 @@ type FetchSourceBranchRequest struct {
 func (m *FetchSourceBranchRequest) Reset()                    { *m = FetchSourceBranchRequest{} }
 func (m *FetchSourceBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*FetchSourceBranchRequest) ProtoMessage()               {}
-func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{22} }
+func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{20} }
 
 func (m *FetchSourceBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -494,7 +470,7 @@ type FetchSourceBranchResponse struct {
 func (m *FetchSourceBranchResponse) Reset()                    { *m = FetchSourceBranchResponse{} }
 func (m *FetchSourceBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*FetchSourceBranchResponse) ProtoMessage()               {}
-func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{23} }
+func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{21} }
 
 func (m *FetchSourceBranchResponse) GetResult() bool {
 	if m != nil {
@@ -510,7 +486,7 @@ type FsckRequest struct {
 func (m *FsckRequest) Reset()                    { *m = FsckRequest{} }
 func (m *FsckRequest) String() string            { return proto.CompactTextString(m) }
 func (*FsckRequest) ProtoMessage()               {}
-func (*FsckRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{24} }
+func (*FsckRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{22} }
 
 func (m *FsckRequest) GetRepository() *Repository {
 	if m != nil {
@@ -526,7 +502,7 @@ type FsckResponse struct {
 func (m *FsckResponse) Reset()                    { *m = FsckResponse{} }
 func (m *FsckResponse) String() string            { return proto.CompactTextString(m) }
 func (*FsckResponse) ProtoMessage()               {}
-func (*FsckResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{25} }
+func (*FsckResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{23} }
 
 func (m *FsckResponse) GetError() []byte {
 	if m != nil {
@@ -547,7 +523,7 @@ type WriteRefRequest struct {
 func (m *WriteRefRequest) Reset()                    { *m = WriteRefRequest{} }
 func (m *WriteRefRequest) String() string            { return proto.CompactTextString(m) }
 func (*WriteRefRequest) ProtoMessage()               {}
-func (*WriteRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{26} }
+func (*WriteRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{24} }
 
 func (m *WriteRefRequest) GetRepository() *Repository {
 	if m != nil {
@@ -598,7 +574,7 @@ type WriteRefResponse struct {
 func (m *WriteRefResponse) Reset()                    { *m = WriteRefResponse{} }
 func (m *WriteRefResponse) String() string            { return proto.CompactTextString(m) }
 func (*WriteRefResponse) ProtoMessage()               {}
-func (*WriteRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{27} }
+func (*WriteRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{25} }
 
 func (m *WriteRefResponse) GetError() []byte {
 	if m != nil {
@@ -618,7 +594,7 @@ type FindMergeBaseRequest struct {
 func (m *FindMergeBaseRequest) Reset()                    { *m = FindMergeBaseRequest{} }
 func (m *FindMergeBaseRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindMergeBaseRequest) ProtoMessage()               {}
-func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{28} }
+func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{26} }
 
 func (m *FindMergeBaseRequest) GetRepository() *Repository {
 	if m != nil {
@@ -641,7 +617,7 @@ type FindMergeBaseResponse struct {
 func (m *FindMergeBaseResponse) Reset()                    { *m = FindMergeBaseResponse{} }
 func (m *FindMergeBaseResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindMergeBaseResponse) ProtoMessage()               {}
-func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{29} }
+func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{27} }
 
 func (m *FindMergeBaseResponse) GetBase() string {
 	if m != nil {
@@ -658,7 +634,7 @@ type CreateForkRequest struct {
 func (m *CreateForkRequest) Reset()                    { *m = CreateForkRequest{} }
 func (m *CreateForkRequest) String() string            { return proto.CompactTextString(m) }
 func (*CreateForkRequest) ProtoMessage()               {}
-func (*CreateForkRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{30} }
+func (*CreateForkRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{28} }
 
 func (m *CreateForkRequest) GetRepository() *Repository {
 	if m != nil {
@@ -680,7 +656,7 @@ type CreateForkResponse struct {
 func (m *CreateForkResponse) Reset()                    { *m = CreateForkResponse{} }
 func (m *CreateForkResponse) String() string            { return proto.CompactTextString(m) }
 func (*CreateForkResponse) ProtoMessage()               {}
-func (*CreateForkResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{31} }
+func (*CreateForkResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{29} }
 
 type IsRebaseInProgressRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -690,7 +666,7 @@ type IsRebaseInProgressRequest struct {
 func (m *IsRebaseInProgressRequest) Reset()                    { *m = IsRebaseInProgressRequest{} }
 func (m *IsRebaseInProgressRequest) String() string            { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressRequest) ProtoMessage()               {}
-func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{32} }
+func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{30} }
 
 func (m *IsRebaseInProgressRequest) GetRepository() *Repository {
 	if m != nil {
@@ -713,7 +689,7 @@ type IsRebaseInProgressResponse struct {
 func (m *IsRebaseInProgressResponse) Reset()                    { *m = IsRebaseInProgressResponse{} }
 func (m *IsRebaseInProgressResponse) String() string            { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressResponse) ProtoMessage()               {}
-func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{33} }
+func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{31} }
 
 func (m *IsRebaseInProgressResponse) GetInProgress() bool {
 	if m != nil {
@@ -722,6 +698,46 @@ func (m *IsRebaseInProgressResponse) GetInProgress() bool {
 	return false
 }
 
+type IsSquashInProgressRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	SquashId   string      `protobuf:"bytes,2,opt,name=squash_id,json=squashId" json:"squash_id,omitempty"`
+}
+
+func (m *IsSquashInProgressRequest) Reset()                    { *m = IsSquashInProgressRequest{} }
+func (m *IsSquashInProgressRequest) String() string            { return proto.CompactTextString(m) }
+func (*IsSquashInProgressRequest) ProtoMessage()               {}
+func (*IsSquashInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{32} }
+
+func (m *IsSquashInProgressRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *IsSquashInProgressRequest) GetSquashId() string {
+	if m != nil {
+		return m.SquashId
+	}
+	return ""
+}
+
+type IsSquashInProgressResponse struct {
+	InProgress bool `protobuf:"varint,1,opt,name=in_progress,json=inProgress" json:"in_progress,omitempty"`
+}
+
+func (m *IsSquashInProgressResponse) Reset()                    { *m = IsSquashInProgressResponse{} }
+func (m *IsSquashInProgressResponse) String() string            { return proto.CompactTextString(m) }
+func (*IsSquashInProgressResponse) ProtoMessage()               {}
+func (*IsSquashInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{33} }
+
+func (m *IsSquashInProgressResponse) GetInProgress() bool {
+	if m != nil {
+		return m.InProgress
+	}
+	return false
+}
+
 type CreateRepositoryFromURLRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 	Url        string      `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"`
@@ -758,11 +774,150 @@ func (*CreateRepositoryFromURLResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor10, []int{35}
 }
 
+type CreateBundleRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *CreateBundleRequest) Reset()                    { *m = CreateBundleRequest{} }
+func (m *CreateBundleRequest) String() string            { return proto.CompactTextString(m) }
+func (*CreateBundleRequest) ProtoMessage()               {}
+func (*CreateBundleRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{36} }
+
+func (m *CreateBundleRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type CreateBundleResponse struct {
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *CreateBundleResponse) Reset()                    { *m = CreateBundleResponse{} }
+func (m *CreateBundleResponse) String() string            { return proto.CompactTextString(m) }
+func (*CreateBundleResponse) ProtoMessage()               {}
+func (*CreateBundleResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{37} }
+
+func (m *CreateBundleResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type WriteConfigRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	FullPath   string      `protobuf:"bytes,2,opt,name=full_path,json=fullPath" json:"full_path,omitempty"`
+}
+
+func (m *WriteConfigRequest) Reset()                    { *m = WriteConfigRequest{} }
+func (m *WriteConfigRequest) String() string            { return proto.CompactTextString(m) }
+func (*WriteConfigRequest) ProtoMessage()               {}
+func (*WriteConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{38} }
+
+func (m *WriteConfigRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *WriteConfigRequest) GetFullPath() string {
+	if m != nil {
+		return m.FullPath
+	}
+	return ""
+}
+
+type WriteConfigResponse struct {
+	Error []byte `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
+}
+
+func (m *WriteConfigResponse) Reset()                    { *m = WriteConfigResponse{} }
+func (m *WriteConfigResponse) String() string            { return proto.CompactTextString(m) }
+func (*WriteConfigResponse) ProtoMessage()               {}
+func (*WriteConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{39} }
+
+func (m *WriteConfigResponse) GetError() []byte {
+	if m != nil {
+		return m.Error
+	}
+	return nil
+}
+
+type CreateRepositoryFromBundleRequest struct {
+	// Only available on the first message
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Data       []byte      `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *CreateRepositoryFromBundleRequest) Reset()         { *m = CreateRepositoryFromBundleRequest{} }
+func (m *CreateRepositoryFromBundleRequest) String() string { return proto.CompactTextString(m) }
+func (*CreateRepositoryFromBundleRequest) ProtoMessage()    {}
+func (*CreateRepositoryFromBundleRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor10, []int{40}
+}
+
+func (m *CreateRepositoryFromBundleRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CreateRepositoryFromBundleRequest) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type CreateRepositoryFromBundleResponse struct {
+}
+
+func (m *CreateRepositoryFromBundleResponse) Reset()         { *m = CreateRepositoryFromBundleResponse{} }
+func (m *CreateRepositoryFromBundleResponse) String() string { return proto.CompactTextString(m) }
+func (*CreateRepositoryFromBundleResponse) ProtoMessage()    {}
+func (*CreateRepositoryFromBundleResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor10, []int{41}
+}
+
+type FindLicenseRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *FindLicenseRequest) Reset()                    { *m = FindLicenseRequest{} }
+func (m *FindLicenseRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindLicenseRequest) ProtoMessage()               {}
+func (*FindLicenseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{42} }
+
+func (m *FindLicenseRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type FindLicenseResponse struct {
+	LicenseShortName string `protobuf:"bytes,1,opt,name=license_short_name,json=licenseShortName" json:"license_short_name,omitempty"`
+}
+
+func (m *FindLicenseResponse) Reset()                    { *m = FindLicenseResponse{} }
+func (m *FindLicenseResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindLicenseResponse) ProtoMessage()               {}
+func (*FindLicenseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{43} }
+
+func (m *FindLicenseResponse) GetLicenseShortName() string {
+	if m != nil {
+		return m.LicenseShortName
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
 	proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse")
-	proto.RegisterType((*RepositoryIsEmptyRequest)(nil), "gitaly.RepositoryIsEmptyRequest")
-	proto.RegisterType((*RepositoryIsEmptyResponse)(nil), "gitaly.RepositoryIsEmptyResponse")
 	proto.RegisterType((*RepackIncrementalRequest)(nil), "gitaly.RepackIncrementalRequest")
 	proto.RegisterType((*RepackIncrementalResponse)(nil), "gitaly.RepackIncrementalResponse")
 	proto.RegisterType((*RepackFullRequest)(nil), "gitaly.RepackFullRequest")
@@ -793,8 +948,18 @@ func init() {
 	proto.RegisterType((*CreateForkResponse)(nil), "gitaly.CreateForkResponse")
 	proto.RegisterType((*IsRebaseInProgressRequest)(nil), "gitaly.IsRebaseInProgressRequest")
 	proto.RegisterType((*IsRebaseInProgressResponse)(nil), "gitaly.IsRebaseInProgressResponse")
+	proto.RegisterType((*IsSquashInProgressRequest)(nil), "gitaly.IsSquashInProgressRequest")
+	proto.RegisterType((*IsSquashInProgressResponse)(nil), "gitaly.IsSquashInProgressResponse")
 	proto.RegisterType((*CreateRepositoryFromURLRequest)(nil), "gitaly.CreateRepositoryFromURLRequest")
 	proto.RegisterType((*CreateRepositoryFromURLResponse)(nil), "gitaly.CreateRepositoryFromURLResponse")
+	proto.RegisterType((*CreateBundleRequest)(nil), "gitaly.CreateBundleRequest")
+	proto.RegisterType((*CreateBundleResponse)(nil), "gitaly.CreateBundleResponse")
+	proto.RegisterType((*WriteConfigRequest)(nil), "gitaly.WriteConfigRequest")
+	proto.RegisterType((*WriteConfigResponse)(nil), "gitaly.WriteConfigResponse")
+	proto.RegisterType((*CreateRepositoryFromBundleRequest)(nil), "gitaly.CreateRepositoryFromBundleRequest")
+	proto.RegisterType((*CreateRepositoryFromBundleResponse)(nil), "gitaly.CreateRepositoryFromBundleResponse")
+	proto.RegisterType((*FindLicenseRequest)(nil), "gitaly.FindLicenseRequest")
+	proto.RegisterType((*FindLicenseResponse)(nil), "gitaly.FindLicenseResponse")
 	proto.RegisterEnum("gitaly.GetArchiveRequest_Format", GetArchiveRequest_Format_name, GetArchiveRequest_Format_value)
 }
 
@@ -810,7 +975,6 @@ const _ = grpc.SupportPackageIsVersion4
 
 type RepositoryServiceClient interface {
 	RepositoryExists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error)
-	RepositoryIsEmpty(ctx context.Context, in *RepositoryIsEmptyRequest, opts ...grpc.CallOption) (*RepositoryIsEmptyResponse, error)
 	RepackIncremental(ctx context.Context, in *RepackIncrementalRequest, opts ...grpc.CallOption) (*RepackIncrementalResponse, error)
 	RepackFull(ctx context.Context, in *RepackFullRequest, opts ...grpc.CallOption) (*RepackFullResponse, error)
 	GarbageCollect(ctx context.Context, in *GarbageCollectRequest, opts ...grpc.CallOption) (*GarbageCollectResponse, error)
@@ -826,7 +990,12 @@ type RepositoryServiceClient interface {
 	FindMergeBase(ctx context.Context, in *FindMergeBaseRequest, opts ...grpc.CallOption) (*FindMergeBaseResponse, error)
 	CreateFork(ctx context.Context, in *CreateForkRequest, opts ...grpc.CallOption) (*CreateForkResponse, error)
 	IsRebaseInProgress(ctx context.Context, in *IsRebaseInProgressRequest, opts ...grpc.CallOption) (*IsRebaseInProgressResponse, error)
+	IsSquashInProgress(ctx context.Context, in *IsSquashInProgressRequest, opts ...grpc.CallOption) (*IsSquashInProgressResponse, error)
 	CreateRepositoryFromURL(ctx context.Context, in *CreateRepositoryFromURLRequest, opts ...grpc.CallOption) (*CreateRepositoryFromURLResponse, error)
+	CreateBundle(ctx context.Context, in *CreateBundleRequest, opts ...grpc.CallOption) (RepositoryService_CreateBundleClient, error)
+	CreateRepositoryFromBundle(ctx context.Context, opts ...grpc.CallOption) (RepositoryService_CreateRepositoryFromBundleClient, error)
+	WriteConfig(ctx context.Context, in *WriteConfigRequest, opts ...grpc.CallOption) (*WriteConfigResponse, error)
+	FindLicense(ctx context.Context, in *FindLicenseRequest, opts ...grpc.CallOption) (*FindLicenseResponse, error)
 }
 
 type repositoryServiceClient struct {
@@ -846,15 +1015,6 @@ func (c *repositoryServiceClient) RepositoryExists(ctx context.Context, in *Repo
 	return out, nil
 }
 
-func (c *repositoryServiceClient) RepositoryIsEmpty(ctx context.Context, in *RepositoryIsEmptyRequest, opts ...grpc.CallOption) (*RepositoryIsEmptyResponse, error) {
-	out := new(RepositoryIsEmptyResponse)
-	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/RepositoryIsEmpty", in, out, c.cc, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *repositoryServiceClient) RepackIncremental(ctx context.Context, in *RepackIncrementalRequest, opts ...grpc.CallOption) (*RepackIncrementalResponse, error) {
 	out := new(RepackIncrementalResponse)
 	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/RepackIncremental", in, out, c.cc, opts...)
@@ -1013,6 +1173,15 @@ func (c *repositoryServiceClient) IsRebaseInProgress(ctx context.Context, in *Is
 	return out, nil
 }
 
+func (c *repositoryServiceClient) IsSquashInProgress(ctx context.Context, in *IsSquashInProgressRequest, opts ...grpc.CallOption) (*IsSquashInProgressResponse, error) {
+	out := new(IsSquashInProgressResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/IsSquashInProgress", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *repositoryServiceClient) CreateRepositoryFromURL(ctx context.Context, in *CreateRepositoryFromURLRequest, opts ...grpc.CallOption) (*CreateRepositoryFromURLResponse, error) {
 	out := new(CreateRepositoryFromURLResponse)
 	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/CreateRepositoryFromURL", in, out, c.cc, opts...)
@@ -1022,11 +1191,94 @@ func (c *repositoryServiceClient) CreateRepositoryFromURL(ctx context.Context, i
 	return out, nil
 }
 
+func (c *repositoryServiceClient) CreateBundle(ctx context.Context, in *CreateBundleRequest, opts ...grpc.CallOption) (RepositoryService_CreateBundleClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RepositoryService_serviceDesc.Streams[1], c.cc, "/gitaly.RepositoryService/CreateBundle", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &repositoryServiceCreateBundleClient{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 RepositoryService_CreateBundleClient interface {
+	Recv() (*CreateBundleResponse, error)
+	grpc.ClientStream
+}
+
+type repositoryServiceCreateBundleClient struct {
+	grpc.ClientStream
+}
+
+func (x *repositoryServiceCreateBundleClient) Recv() (*CreateBundleResponse, error) {
+	m := new(CreateBundleResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *repositoryServiceClient) CreateRepositoryFromBundle(ctx context.Context, opts ...grpc.CallOption) (RepositoryService_CreateRepositoryFromBundleClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RepositoryService_serviceDesc.Streams[2], c.cc, "/gitaly.RepositoryService/CreateRepositoryFromBundle", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &repositoryServiceCreateRepositoryFromBundleClient{stream}
+	return x, nil
+}
+
+type RepositoryService_CreateRepositoryFromBundleClient interface {
+	Send(*CreateRepositoryFromBundleRequest) error
+	CloseAndRecv() (*CreateRepositoryFromBundleResponse, error)
+	grpc.ClientStream
+}
+
+type repositoryServiceCreateRepositoryFromBundleClient struct {
+	grpc.ClientStream
+}
+
+func (x *repositoryServiceCreateRepositoryFromBundleClient) Send(m *CreateRepositoryFromBundleRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *repositoryServiceCreateRepositoryFromBundleClient) CloseAndRecv() (*CreateRepositoryFromBundleResponse, error) {
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	m := new(CreateRepositoryFromBundleResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *repositoryServiceClient) WriteConfig(ctx context.Context, in *WriteConfigRequest, opts ...grpc.CallOption) (*WriteConfigResponse, error) {
+	out := new(WriteConfigResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/WriteConfig", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *repositoryServiceClient) FindLicense(ctx context.Context, in *FindLicenseRequest, opts ...grpc.CallOption) (*FindLicenseResponse, error) {
+	out := new(FindLicenseResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/FindLicense", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for RepositoryService service
 
 type RepositoryServiceServer interface {
 	RepositoryExists(context.Context, *RepositoryExistsRequest) (*RepositoryExistsResponse, error)
-	RepositoryIsEmpty(context.Context, *RepositoryIsEmptyRequest) (*RepositoryIsEmptyResponse, error)
 	RepackIncremental(context.Context, *RepackIncrementalRequest) (*RepackIncrementalResponse, error)
 	RepackFull(context.Context, *RepackFullRequest) (*RepackFullResponse, error)
 	GarbageCollect(context.Context, *GarbageCollectRequest) (*GarbageCollectResponse, error)
@@ -1042,7 +1294,12 @@ type RepositoryServiceServer interface {
 	FindMergeBase(context.Context, *FindMergeBaseRequest) (*FindMergeBaseResponse, error)
 	CreateFork(context.Context, *CreateForkRequest) (*CreateForkResponse, error)
 	IsRebaseInProgress(context.Context, *IsRebaseInProgressRequest) (*IsRebaseInProgressResponse, error)
+	IsSquashInProgress(context.Context, *IsSquashInProgressRequest) (*IsSquashInProgressResponse, error)
 	CreateRepositoryFromURL(context.Context, *CreateRepositoryFromURLRequest) (*CreateRepositoryFromURLResponse, error)
+	CreateBundle(*CreateBundleRequest, RepositoryService_CreateBundleServer) error
+	CreateRepositoryFromBundle(RepositoryService_CreateRepositoryFromBundleServer) error
+	WriteConfig(context.Context, *WriteConfigRequest) (*WriteConfigResponse, error)
+	FindLicense(context.Context, *FindLicenseRequest) (*FindLicenseResponse, error)
 }
 
 func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
@@ -1067,24 +1324,6 @@ func _RepositoryService_RepositoryExists_Handler(srv interface{}, ctx context.Co
 	return interceptor(ctx, in, info, handler)
 }
 
-func _RepositoryService_RepositoryIsEmpty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(RepositoryIsEmptyRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RepositoryServiceServer).RepositoryIsEmpty(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.RepositoryService/RepositoryIsEmpty",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RepositoryServiceServer).RepositoryIsEmpty(ctx, req.(*RepositoryIsEmptyRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _RepositoryService_RepackIncremental_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(RepackIncrementalRequest)
 	if err := dec(in); err != nil {
@@ -1358,6 +1597,24 @@ func _RepositoryService_IsRebaseInProgress_Handler(srv interface{}, ctx context.
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RepositoryService_IsSquashInProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(IsSquashInProgressRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).IsSquashInProgress(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/IsSquashInProgress",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).IsSquashInProgress(ctx, req.(*IsSquashInProgressRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _RepositoryService_CreateRepositoryFromURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(CreateRepositoryFromURLRequest)
 	if err := dec(in); err != nil {
@@ -1376,6 +1633,89 @@ func _RepositoryService_CreateRepositoryFromURL_Handler(srv interface{}, ctx con
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RepositoryService_CreateBundle_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CreateBundleRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(RepositoryServiceServer).CreateBundle(m, &repositoryServiceCreateBundleServer{stream})
+}
+
+type RepositoryService_CreateBundleServer interface {
+	Send(*CreateBundleResponse) error
+	grpc.ServerStream
+}
+
+type repositoryServiceCreateBundleServer struct {
+	grpc.ServerStream
+}
+
+func (x *repositoryServiceCreateBundleServer) Send(m *CreateBundleResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _RepositoryService_CreateRepositoryFromBundle_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(RepositoryServiceServer).CreateRepositoryFromBundle(&repositoryServiceCreateRepositoryFromBundleServer{stream})
+}
+
+type RepositoryService_CreateRepositoryFromBundleServer interface {
+	SendAndClose(*CreateRepositoryFromBundleResponse) error
+	Recv() (*CreateRepositoryFromBundleRequest, error)
+	grpc.ServerStream
+}
+
+type repositoryServiceCreateRepositoryFromBundleServer struct {
+	grpc.ServerStream
+}
+
+func (x *repositoryServiceCreateRepositoryFromBundleServer) SendAndClose(m *CreateRepositoryFromBundleResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *repositoryServiceCreateRepositoryFromBundleServer) Recv() (*CreateRepositoryFromBundleRequest, error) {
+	m := new(CreateRepositoryFromBundleRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _RepositoryService_WriteConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(WriteConfigRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).WriteConfig(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/WriteConfig",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).WriteConfig(ctx, req.(*WriteConfigRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _RepositoryService_FindLicense_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FindLicenseRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).FindLicense(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/FindLicense",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).FindLicense(ctx, req.(*FindLicenseRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.RepositoryService",
 	HandlerType: (*RepositoryServiceServer)(nil),
@@ -1384,10 +1724,6 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "RepositoryExists",
 			Handler:    _RepositoryService_RepositoryExists_Handler,
 		},
-		{
-			MethodName: "RepositoryIsEmpty",
-			Handler:    _RepositoryService_RepositoryIsEmpty_Handler,
-		},
 		{
 			MethodName: "RepackIncremental",
 			Handler:    _RepositoryService_RepackIncremental_Handler,
@@ -1444,10 +1780,22 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "IsRebaseInProgress",
 			Handler:    _RepositoryService_IsRebaseInProgress_Handler,
 		},
+		{
+			MethodName: "IsSquashInProgress",
+			Handler:    _RepositoryService_IsSquashInProgress_Handler,
+		},
 		{
 			MethodName: "CreateRepositoryFromURL",
 			Handler:    _RepositoryService_CreateRepositoryFromURL_Handler,
 		},
+		{
+			MethodName: "WriteConfig",
+			Handler:    _RepositoryService_WriteConfig_Handler,
+		},
+		{
+			MethodName: "FindLicense",
+			Handler:    _RepositoryService_FindLicense_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1455,6 +1803,16 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _RepositoryService_GetArchive_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "CreateBundle",
+			Handler:       _RepositoryService_CreateBundle_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "CreateRepositoryFromBundle",
+			Handler:       _RepositoryService_CreateRepositoryFromBundle_Handler,
+			ClientStreams: true,
+		},
 	},
 	Metadata: "repository-service.proto",
 }
@@ -1462,84 +1820,97 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor10) }
 
 var fileDescriptor10 = []byte{
-	// 1250 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xdd, 0x6e, 0xdb, 0x36,
-	0x14, 0xb6, 0xe3, 0xc6, 0x49, 0x8e, 0xdd, 0xce, 0x61, 0x9d, 0x46, 0x56, 0x7f, 0x92, 0x72, 0xc3,
-	0x16, 0x60, 0x5b, 0x50, 0x38, 0xc0, 0xb0, 0x9b, 0xa1, 0x48, 0x8a, 0x3a, 0x35, 0xfa, 0x83, 0x4e,
-	0xed, 0x50, 0x20, 0xc0, 0x60, 0xc8, 0x32, 0x6d, 0x0b, 0x96, 0x45, 0x8f, 0xa4, 0xb3, 0xba, 0x4f,
-	0xb0, 0xe7, 0xda, 0x2b, 0xec, 0x11, 0x76, 0xd9, 0x97, 0x18, 0x44, 0xd2, 0xa2, 0x64, 0x49, 0xd9,
-	0x85, 0x30, 0xec, 0x4e, 0x3c, 0x24, 0xbf, 0x73, 0x78, 0x7e, 0x3f, 0x1b, 0x2c, 0x46, 0x16, 0x94,
-	0xfb, 0x82, 0xb2, 0xd5, 0xf7, 0x9c, 0xb0, 0x6b, 0xdf, 0x23, 0xa7, 0x0b, 0x46, 0x05, 0x45, 0xf5,
-	0x89, 0x2f, 0xdc, 0x60, 0x65, 0x37, 0xf9, 0xd4, 0x65, 0x64, 0xa4, 0xa4, 0xf8, 0x35, 0x1c, 0x3a,
-	0xf1, 0x8d, 0xe7, 0x1f, 0x7d, 0x2e, 0xb8, 0x43, 0x7e, 0x5b, 0x12, 0x2e, 0x50, 0x17, 0xc0, 0x80,
-	0x59, 0xd5, 0xe3, 0xea, 0x49, 0xa3, 0x8b, 0x4e, 0x15, 0xca, 0xa9, 0xb9, 0xe4, 0x24, 0x4e, 0xe1,
-	0x2e, 0x58, 0x59, 0x38, 0xbe, 0xa0, 0x21, 0x27, 0xe8, 0x1e, 0xd4, 0x89, 0x94, 0x48, 0xac, 0x5d,
-	0x47, 0xaf, 0xf0, 0x9b, 0xe4, 0x9d, 0x3e, 0x7f, 0x3e, 0x5f, 0x88, 0x55, 0x19, 0x1b, 0x7e, 0x80,
-	0x4e, 0x0e, 0x9e, 0x36, 0xa2, 0x03, 0xbb, 0x3e, 0x1f, 0x90, 0x48, 0xa6, 0xcd, 0xd8, 0xf1, 0xd5,
-	0x11, 0x6d, 0x87, 0xeb, 0xcd, 0xfa, 0xa1, 0xc7, 0xc8, 0x9c, 0x84, 0xc2, 0x0d, 0xca, 0xd8, 0x71,
-	0x5f, 0xda, 0xb1, 0x89, 0xa7, 0xec, 0xc0, 0x01, 0xec, 0xab, 0xcd, 0xde, 0x32, 0x28, 0xa3, 0x05,
-	0x7d, 0x09, 0xb7, 0x3d, 0x46, 0x5c, 0x41, 0x06, 0x43, 0x5f, 0xcc, 0xdd, 0x85, 0xb5, 0x25, 0x5f,
-	0xd5, 0x54, 0xc2, 0x0b, 0x29, 0xc3, 0x6d, 0x40, 0x49, 0x6d, 0xda, 0x86, 0x05, 0x1c, 0x5c, 0xba,
-	0x6c, 0xe8, 0x4e, 0xc8, 0x33, 0x1a, 0x04, 0xc4, 0x13, 0xff, 0xb9, 0x1d, 0x16, 0xdc, 0xdb, 0xd4,
-	0xa8, 0x6d, 0x79, 0x09, 0x07, 0x06, 0xf8, 0x9d, 0xff, 0x89, 0x94, 0xf1, 0xfc, 0x77, 0x70, 0x6f,
-	0x13, 0x4c, 0x87, 0x1f, 0xc1, 0x2d, 0xee, 0x7f, 0x22, 0x12, 0xa7, 0xe6, 0xc8, 0x6f, 0x3c, 0x83,
-	0xce, 0xf9, 0x62, 0x11, 0xac, 0x2e, 0x7d, 0xe1, 0x0a, 0xc1, 0xfc, 0xe1, 0x52, 0x90, 0x32, 0x45,
-	0x80, 0x6c, 0xd8, 0x65, 0xe4, 0xda, 0xe7, 0x3e, 0x0d, 0xa5, 0x17, 0x9a, 0x4e, 0xbc, 0xc6, 0x0f,
-	0xc0, 0xce, 0x53, 0xa6, 0xbd, 0xf0, 0x77, 0x15, 0x50, 0x8f, 0x08, 0x6f, 0xea, 0x90, 0x39, 0x15,
-	0x65, 0x7c, 0x10, 0x55, 0x1b, 0x93, 0x20, 0xd2, 0x84, 0x3d, 0x47, 0xaf, 0x50, 0x1b, 0xb6, 0xc7,
-	0x94, 0x79, 0xc4, 0xaa, 0xc9, 0xf8, 0xa8, 0x05, 0x3a, 0x84, 0x9d, 0x90, 0x0e, 0x84, 0x3b, 0xe1,
-	0xd6, 0x2d, 0x55, 0x9c, 0x21, 0x7d, 0xef, 0x4e, 0x38, 0xb2, 0x60, 0x47, 0xf8, 0x73, 0x42, 0x97,
-	0xc2, 0xda, 0x3e, 0xae, 0x9e, 0x6c, 0x3b, 0xeb, 0x65, 0x74, 0x85, 0xf3, 0xe9, 0x60, 0x46, 0x56,
-	0x56, 0x5d, 0x69, 0xe0, 0x7c, 0xfa, 0x92, 0xac, 0xd0, 0x11, 0x34, 0x66, 0x21, 0xfd, 0x3d, 0x1c,
-	0x4c, 0x69, 0x54, 0xec, 0x3b, 0x72, 0x13, 0xa4, 0xe8, 0x45, 0x24, 0xc1, 0x07, 0x70, 0x37, 0xf5,
-	0x48, 0xfd, 0xf8, 0xd7, 0x70, 0xf8, 0x4c, 0x26, 0x4b, 0xe2, 0x45, 0x25, 0x92, 0xc0, 0x06, 0x2b,
-	0x0b, 0xa7, 0x55, 0x7d, 0xae, 0xc2, 0xfe, 0x25, 0x11, 0xe7, 0xcc, 0x9b, 0xfa, 0xd7, 0xa5, 0xdc,
-	0x7c, 0x1f, 0xf6, 0x3c, 0x3a, 0x9f, 0xfb, 0x62, 0xe0, 0x8f, 0xb4, 0xa7, 0x77, 0x95, 0xa0, 0x3f,
-	0x8a, 0x62, 0xb0, 0x60, 0x64, 0xec, 0x7f, 0x94, 0xce, 0xde, 0x73, 0xf4, 0x0a, 0xfd, 0x08, 0xf5,
-	0x31, 0x65, 0x73, 0x57, 0x48, 0x67, 0xdf, 0xe9, 0x1e, 0xaf, 0x95, 0x64, 0x6c, 0x3a, 0xed, 0xc9,
-	0x73, 0x8e, 0x3e, 0x8f, 0xcf, 0xa0, 0xae, 0x24, 0x68, 0x07, 0x6a, 0x57, 0xfd, 0xb7, 0xad, 0x4a,
-	0xf4, 0xf1, 0xfe, 0xdc, 0x69, 0x55, 0x11, 0x40, 0xfd, 0xfd, 0xb9, 0x33, 0xb8, 0xbc, 0x6a, 0x6d,
-	0xa1, 0x06, 0xec, 0x44, 0xdf, 0x17, 0x57, 0xdd, 0x56, 0x0d, 0x9f, 0x00, 0x4a, 0x02, 0x9b, 0x52,
-	0x18, 0xb9, 0xc2, 0x95, 0xef, 0x6c, 0x3a, 0xf2, 0x3b, 0x0a, 0xc1, 0x0b, 0x97, 0xbf, 0xa2, 0x9e,
-	0x1b, 0x5c, 0x30, 0x37, 0xf4, 0xa6, 0xa5, 0x0a, 0x01, 0x3f, 0x01, 0x2b, 0x0b, 0xa7, 0xd5, 0xb7,
-	0x61, 0xfb, 0xda, 0x0d, 0x96, 0x44, 0x77, 0x61, 0xb5, 0xc0, 0x7f, 0x55, 0xc1, 0x92, 0xb9, 0xf1,
-	0x8e, 0x2e, 0x99, 0x47, 0xd4, 0xad, 0x32, 0xf1, 0x79, 0x0a, 0xfb, 0x5c, 0x42, 0x0d, 0x12, 0x57,
-	0xb7, 0x0a, 0xaf, 0xb6, 0xd4, 0x61, 0x27, 0xd5, 0xd7, 0x34, 0xc0, 0x50, 0x1a, 0x23, 0x43, 0xd9,
-	0x74, 0x9a, 0x3c, 0x61, 0x20, 0x7a, 0x08, 0x20, 0x5c, 0x36, 0x21, 0x62, 0xc0, 0xc8, 0x58, 0x06,
-	0xb5, 0xe9, 0xec, 0x29, 0x89, 0x43, 0xc6, 0xf8, 0x0c, 0x3a, 0x39, 0x8f, 0x32, 0x63, 0x91, 0x11,
-	0xbe, 0x0c, 0xc4, 0x7a, 0x2c, 0xaa, 0x15, 0x3e, 0x87, 0x46, 0x8f, 0x7b, 0xb3, 0x32, 0xfe, 0xff,
-	0x0a, 0x9a, 0x0a, 0xc2, 0xf8, 0x9c, 0x30, 0x46, 0x99, 0x8e, 0xb9, 0x5a, 0xe0, 0x3f, 0xab, 0xf0,
-	0xc5, 0x07, 0xe6, 0x47, 0x85, 0x32, 0x2e, 0xe3, 0xea, 0x16, 0xd4, 0xa2, 0xd7, 0xab, 0x8e, 0x17,
-	0x7d, 0xa6, 0x1a, 0x61, 0x2d, 0xdd, 0x08, 0xd1, 0x63, 0x68, 0xd2, 0x60, 0x34, 0x88, 0xf7, 0x95,
-	0xd3, 0x1a, 0x34, 0x18, 0x39, 0xeb, 0x23, 0x71, 0xab, 0xda, 0x4e, 0xb6, 0xaa, 0x36, 0x6c, 0xf3,
-	0x29, 0x09, 0x02, 0xd9, 0x75, 0x76, 0x1d, 0xb5, 0xc0, 0x27, 0xd0, 0x32, 0x6f, 0xb8, 0xf1, 0xb9,
-	0x53, 0x68, 0xf7, 0xfc, 0x70, 0xf4, 0x9a, 0xb0, 0x09, 0xb9, 0x70, 0x79, 0xa9, 0xea, 0x7f, 0x00,
-	0x7b, 0xeb, 0x07, 0x70, 0x6b, 0xeb, 0xb8, 0x16, 0x85, 0x3d, 0x16, 0xe0, 0x6f, 0xe1, 0x60, 0x43,
-	0x93, 0x29, 0xbd, 0xa1, 0xcb, 0x55, 0xea, 0xef, 0x39, 0xf2, 0x1b, 0xff, 0x51, 0x85, 0x7d, 0xd5,
-	0xaf, 0x7a, 0x94, 0xcd, 0xfe, 0xcf, 0x94, 0x8f, 0xd8, 0x42, 0xd2, 0x92, 0x98, 0xb1, 0x74, 0xfa,
-	0xdc, 0x21, 0x91, 0xb1, 0xfd, 0xf0, 0x2d, 0xa3, 0x13, 0x46, 0x38, 0x2f, 0xd9, 0x3a, 0x99, 0x84,
-	0x4b, 0xb4, 0x4e, 0x25, 0xe8, 0x8f, 0xf0, 0x4f, 0x60, 0xe7, 0x69, 0xd3, 0x0e, 0x3c, 0x82, 0x86,
-	0x1f, 0x0e, 0x16, 0x5a, 0xac, 0x0b, 0x07, 0xfc, 0xf8, 0x20, 0x1e, 0xc3, 0xa3, 0xcd, 0xe6, 0xdf,
-	0x63, 0x74, 0xfe, 0x8b, 0xf3, 0xaa, 0x64, 0x86, 0x2f, 0x59, 0xa0, 0x6d, 0x8d, 0x3e, 0xf1, 0x63,
-	0x38, 0x2a, 0xd4, 0xa3, 0x6c, 0xed, 0x7e, 0x6e, 0x48, 0xaa, 0xb7, 0x66, 0x23, 0x8a, 0x93, 0xa3,
-	0x0f, 0xd0, 0xda, 0x24, 0xca, 0xe8, 0x28, 0xab, 0x3e, 0xc5, 0xc8, 0xed, 0xe3, 0xe2, 0x03, 0x3a,
-	0x48, 0x15, 0x74, 0x95, 0xd4, 0xa6, 0xd9, 0x2f, 0xca, 0xb9, 0x98, 0x26, 0xda, 0xf6, 0xe3, 0x1b,
-	0x4e, 0x6c, 0x60, 0xa7, 0x19, 0x6d, 0x0a, 0x3b, 0x97, 0x3c, 0xa7, 0xb0, 0x0b, 0xe8, 0x70, 0x05,
-	0x3d, 0x07, 0x30, 0x14, 0x15, 0x75, 0xd2, 0x57, 0x12, 0x24, 0xd9, 0xb6, 0xf3, 0xb6, 0x62, 0x98,
-	0x9f, 0xe1, 0x4e, 0x9a, 0x61, 0xa2, 0x87, 0xf1, 0x70, 0xcd, 0xe3, 0xba, 0xf6, 0xa3, 0xa2, 0xed,
-	0x24, 0x64, 0x9a, 0x4d, 0x1a, 0xc8, 0x5c, 0xca, 0x6a, 0x20, 0xf3, 0x49, 0x28, 0xae, 0xa0, 0x5f,
-	0x01, 0x65, 0x59, 0x20, 0x8a, 0xfd, 0x54, 0x48, 0x47, 0x6d, 0x7c, 0xd3, 0x91, 0x18, 0xfe, 0x05,
-	0x34, 0x12, 0x04, 0x0b, 0xc5, 0x1e, 0xcb, 0x52, 0x4b, 0xfb, 0x7e, 0xee, 0x5e, 0x8c, 0xf4, 0x01,
-	0x5a, 0x9b, 0xf9, 0x6d, 0xd2, 0xb4, 0x80, 0xad, 0x99, 0x34, 0x2d, 0xe4, 0x5f, 0x15, 0x74, 0x09,
-	0x60, 0x38, 0x89, 0x09, 0x77, 0x86, 0x00, 0x99, 0x70, 0x67, 0x29, 0x0c, 0xae, 0x3c, 0xa9, 0x46,
-	0x16, 0x6e, 0x72, 0x0c, 0x63, 0x61, 0x01, 0x99, 0x31, 0x16, 0x16, 0xd1, 0x13, 0x95, 0xec, 0x99,
-	0xa1, 0x6d, 0x92, 0xbd, 0x88, 0xa4, 0x98, 0x64, 0x2f, 0x9c, 0xf8, 0xb8, 0x82, 0xce, 0xe0, 0x56,
-	0x34, 0x98, 0xd1, 0xdd, 0xf8, 0xb0, 0x99, 0xf4, 0x76, 0x3b, 0x2d, 0x8c, 0x2f, 0x3d, 0x85, 0xdd,
-	0xf5, 0x88, 0x43, 0x87, 0xeb, 0x33, 0x1b, 0x83, 0xdb, 0xb6, 0xb2, 0x1b, 0x31, 0xc0, 0x1b, 0xb8,
-	0x9d, 0x9a, 0x47, 0xe8, 0x41, 0xac, 0x29, 0x67, 0x20, 0xda, 0x0f, 0x0b, 0x76, 0x93, 0x25, 0x6b,
-	0xe6, 0x84, 0x89, 0x61, 0x66, 0x8a, 0x99, 0x18, 0xe6, 0x8c, 0x15, 0x59, 0x0c, 0xd9, 0x56, 0x6f,
-	0x8a, 0xa1, 0x70, 0xe8, 0x98, 0x62, 0x28, 0x9e, 0x14, 0xb8, 0x82, 0x82, 0xec, 0xcf, 0x0a, 0xdd,
-	0xa2, 0xd1, 0xd7, 0x45, 0x89, 0x9a, 0x9e, 0x15, 0xf6, 0x37, 0xff, 0x7a, 0x6e, 0xad, 0x6d, 0x58,
-	0x97, 0x7f, 0xab, 0x9c, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xef, 0x87, 0x20, 0x75, 0x88, 0x11,
+	// 1458 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5f, 0x6f, 0xdb, 0xb6,
+	0x16, 0xb7, 0xf3, 0xd7, 0x3e, 0x71, 0x7b, 0x1d, 0x26, 0x69, 0x14, 0x25, 0x6d, 0x12, 0xde, 0xe2,
+	0xde, 0xdc, 0xb6, 0x37, 0x28, 0x92, 0x97, 0xbd, 0x0c, 0x45, 0x12, 0x34, 0x7f, 0xd6, 0xa6, 0xc8,
+	0x94, 0x0e, 0x05, 0x02, 0x0c, 0x82, 0x22, 0xd3, 0xb6, 0x60, 0x59, 0x74, 0x49, 0x3a, 0x6d, 0xfa,
+	0xbc, 0x87, 0x7d, 0xae, 0x3d, 0xee, 0x75, 0x1f, 0x63, 0x5f, 0x62, 0x10, 0x29, 0x89, 0x92, 0x25,
+	0x79, 0x05, 0xb4, 0x61, 0x6f, 0xe2, 0x21, 0xf9, 0x3b, 0x87, 0xe7, 0xf0, 0x1c, 0xfe, 0x8e, 0xc0,
+	0x60, 0x64, 0x44, 0xb9, 0x27, 0x28, 0xbb, 0xff, 0x3f, 0x27, 0xec, 0xce, 0x73, 0xc9, 0xfe, 0x88,
+	0x51, 0x41, 0xd1, 0x42, 0xcf, 0x13, 0x8e, 0x7f, 0x6f, 0xb6, 0x78, 0xdf, 0x61, 0xa4, 0xa3, 0xa4,
+	0xf8, 0x12, 0xd6, 0xad, 0x64, 0xc7, 0xeb, 0xcf, 0x1e, 0x17, 0xdc, 0x22, 0x1f, 0xc7, 0x84, 0x0b,
+	0x74, 0x00, 0xa0, 0xc1, 0x8c, 0xfa, 0x4e, 0x7d, 0x6f, 0xe9, 0x00, 0xed, 0x2b, 0x94, 0x7d, 0xbd,
+	0xc9, 0x4a, 0xad, 0xc2, 0x07, 0x60, 0xe4, 0xe1, 0xf8, 0x88, 0x06, 0x9c, 0xa0, 0x47, 0xb0, 0x40,
+	0xa4, 0x44, 0x62, 0x35, 0xac, 0x68, 0x84, 0xdf, 0xc9, 0x3d, 0x8e, 0x3b, 0xb8, 0x08, 0x5c, 0x46,
+	0x86, 0x24, 0x10, 0x8e, 0x5f, 0xc5, 0x86, 0x4d, 0xd8, 0x28, 0xc0, 0x53, 0x46, 0x60, 0x1f, 0x96,
+	0xd5, 0xe4, 0xe9, 0xd8, 0xaf, 0xa2, 0x05, 0xfd, 0x1b, 0x1e, 0xb8, 0x8c, 0x38, 0x82, 0xd8, 0xb7,
+	0x9e, 0x18, 0x3a, 0x23, 0x63, 0x46, 0x1e, 0xaa, 0xa5, 0x84, 0xc7, 0x52, 0x86, 0x57, 0x01, 0xa5,
+	0xb5, 0x45, 0x36, 0x8c, 0x60, 0xed, 0xcc, 0x61, 0xb7, 0x4e, 0x8f, 0x9c, 0x50, 0xdf, 0x27, 0xae,
+	0xf8, 0xdb, 0xed, 0x30, 0xe0, 0xd1, 0xa4, 0xc6, 0xc8, 0x96, 0x37, 0xb0, 0xa6, 0x81, 0xaf, 0xbd,
+	0x2f, 0xa4, 0x8a, 0xe7, 0x5f, 0xc0, 0xa3, 0x49, 0xb0, 0x28, 0xf6, 0x08, 0xe6, 0xb8, 0xf7, 0x85,
+	0x48, 0x9c, 0x59, 0x4b, 0x7e, 0xe3, 0x01, 0x6c, 0x1c, 0x8d, 0x46, 0xfe, 0xfd, 0x99, 0x27, 0x1c,
+	0x21, 0x98, 0x77, 0x3b, 0x16, 0xa4, 0xca, 0xe5, 0x43, 0x26, 0x34, 0x18, 0xb9, 0xf3, 0xb8, 0x47,
+	0x03, 0xe9, 0x85, 0x96, 0x95, 0x8c, 0xf1, 0x16, 0x98, 0x45, 0xca, 0x22, 0x2f, 0xfc, 0x34, 0x03,
+	0xe8, 0x94, 0x08, 0xb7, 0x6f, 0x91, 0x21, 0x15, 0x55, 0x7c, 0x10, 0xde, 0x72, 0x26, 0x41, 0xa4,
+	0x09, 0x4d, 0x2b, 0x1a, 0xa1, 0x55, 0x98, 0xef, 0x52, 0xe6, 0x12, 0x63, 0x56, 0xc6, 0x47, 0x0d,
+	0xd0, 0x3a, 0x2c, 0x06, 0xd4, 0x16, 0x4e, 0x8f, 0x1b, 0x73, 0x2a, 0x29, 0x02, 0xfa, 0xde, 0xe9,
+	0x71, 0x64, 0xc0, 0xa2, 0xf0, 0x86, 0x84, 0x8e, 0x85, 0x31, 0xbf, 0x53, 0xdf, 0x9b, 0xb7, 0xe2,
+	0x61, 0xb8, 0x85, 0xf3, 0xbe, 0x3d, 0x20, 0xf7, 0xc6, 0x82, 0xd2, 0xc0, 0x79, 0xff, 0x0d, 0xb9,
+	0x47, 0xdb, 0xb0, 0x34, 0x08, 0xe8, 0xa7, 0xc0, 0xee, 0xd3, 0x30, 0xc9, 0x16, 0xe5, 0x24, 0x48,
+	0xd1, 0x79, 0x28, 0x41, 0x1b, 0xd0, 0x08, 0xa8, 0x3d, 0x62, 0xe3, 0x80, 0x18, 0x4d, 0xa9, 0x6d,
+	0x31, 0xa0, 0x57, 0xe1, 0xf0, 0xbb, 0xb9, 0x46, 0xa3, 0xdd, 0xc4, 0x6b, 0xb0, 0x92, 0xf1, 0x42,
+	0xe4, 0x9d, 0x4b, 0x58, 0x3f, 0x91, 0xb7, 0x29, 0x75, 0xe4, 0x0a, 0xb7, 0xc4, 0x04, 0x23, 0x0f,
+	0x17, 0xa9, 0xfa, 0xbd, 0x0e, 0xcb, 0x67, 0x44, 0x1c, 0x31, 0xb7, 0xef, 0xdd, 0x55, 0x8a, 0xc3,
+	0x26, 0x34, 0x5d, 0x3a, 0x1c, 0x7a, 0xc2, 0xf6, 0x3a, 0x51, 0x28, 0x1a, 0x4a, 0x70, 0xd1, 0x09,
+	0x83, 0x34, 0x62, 0xa4, 0xeb, 0x7d, 0x96, 0xd1, 0x68, 0x5a, 0xd1, 0x08, 0x7d, 0x03, 0x0b, 0x5d,
+	0xca, 0x86, 0x8e, 0x90, 0xd1, 0x78, 0x78, 0xb0, 0x13, 0x2b, 0xc9, 0xd9, 0xb4, 0x7f, 0x2a, 0xd7,
+	0x59, 0xd1, 0x7a, 0x7c, 0x08, 0x0b, 0x4a, 0x82, 0x16, 0x61, 0xf6, 0xe6, 0xe2, 0xaa, 0x5d, 0x0b,
+	0x3f, 0xde, 0x1f, 0x59, 0xed, 0x3a, 0x02, 0x58, 0x78, 0x7f, 0x64, 0xd9, 0x67, 0x37, 0xed, 0x19,
+	0xb4, 0x04, 0x8b, 0xe1, 0xf7, 0xf1, 0xcd, 0x41, 0x7b, 0x16, 0xef, 0x01, 0x4a, 0x03, 0xeb, 0x5c,
+	0xe9, 0x38, 0xc2, 0x91, 0xe7, 0x6c, 0x59, 0xf2, 0x3b, 0x0c, 0xc1, 0xb9, 0xc3, 0xdf, 0x52, 0xd7,
+	0xf1, 0x8f, 0x99, 0x13, 0xb8, 0xfd, 0x4a, 0x99, 0x82, 0x5f, 0x82, 0x91, 0x87, 0x8b, 0xd4, 0xaf,
+	0xc2, 0xfc, 0x9d, 0xe3, 0x8f, 0x49, 0x54, 0xa5, 0xd5, 0x00, 0xff, 0x56, 0x07, 0x43, 0xde, 0x8d,
+	0x6b, 0x3a, 0x66, 0x2e, 0x51, 0xbb, 0xaa, 0xc4, 0xe7, 0x15, 0x2c, 0x73, 0x09, 0x65, 0xa7, 0xb6,
+	0xce, 0x94, 0x6e, 0x6d, 0xab, 0xc5, 0x56, 0xa6, 0xf0, 0x45, 0x00, 0xb7, 0xd2, 0x18, 0x19, 0xca,
+	0x96, 0xd5, 0xe2, 0x29, 0x03, 0xd1, 0x63, 0x00, 0xe1, 0xb0, 0x1e, 0x11, 0x36, 0x23, 0x5d, 0x19,
+	0xd4, 0x96, 0xd5, 0x54, 0x12, 0x8b, 0x74, 0xf1, 0x21, 0x6c, 0x14, 0x1c, 0x4a, 0xbf, 0x57, 0x8c,
+	0xf0, 0xb1, 0x2f, 0xe2, 0xf7, 0x4a, 0x8d, 0xf0, 0x11, 0x2c, 0x9d, 0x72, 0x77, 0x50, 0xc5, 0xff,
+	0x4f, 0xa1, 0xa5, 0x20, 0xb4, 0xcf, 0x09, 0x63, 0x94, 0x45, 0x31, 0x57, 0x03, 0xfc, 0x4b, 0x1d,
+	0xfe, 0xf5, 0x81, 0x79, 0x61, 0xa2, 0x74, 0xab, 0xb8, 0xba, 0x0d, 0xb3, 0xe1, 0xe9, 0x55, 0x49,
+	0x0c, 0x3f, 0x33, 0x95, 0x72, 0x36, 0x5b, 0x29, 0xd1, 0x2e, 0xb4, 0xa8, 0xdf, 0xb1, 0x93, 0x79,
+	0xe5, 0xb4, 0x25, 0xea, 0x77, 0xac, 0x78, 0x49, 0x52, 0xcb, 0xe6, 0xd3, 0xb5, 0x6c, 0x15, 0xe6,
+	0x79, 0x9f, 0xf8, 0xbe, 0x2c, 0x4b, 0x0d, 0x4b, 0x0d, 0xf0, 0x1e, 0xb4, 0xf5, 0x19, 0xa6, 0x1e,
+	0xb7, 0x0f, 0xab, 0xa7, 0x5e, 0xd0, 0xb9, 0x24, 0xac, 0x47, 0x8e, 0x1d, 0x5e, 0x29, 0xfb, 0xb7,
+	0xa0, 0x19, 0x1f, 0x80, 0x1b, 0x33, 0x3b, 0xb3, 0x61, 0xd8, 0x13, 0x01, 0x7e, 0x0e, 0x6b, 0x13,
+	0x9a, 0x74, 0xea, 0xdd, 0x3a, 0x5c, 0x5d, 0xfd, 0xa6, 0x25, 0xbf, 0xf1, 0xcf, 0x75, 0x58, 0x56,
+	0xf5, 0xea, 0x94, 0xb2, 0xc1, 0x3f, 0x79, 0xe5, 0x43, 0x3a, 0x91, 0xb6, 0x24, 0xa1, 0x34, 0x1b,
+	0x17, 0xdc, 0x22, 0xa1, 0xb1, 0x17, 0xc1, 0x15, 0xa3, 0x3d, 0x46, 0x38, 0xaf, 0x58, 0x3a, 0x99,
+	0x84, 0x4b, 0x95, 0x4e, 0x25, 0xb8, 0xe8, 0xe0, 0x6f, 0xc1, 0x2c, 0xd2, 0x16, 0x39, 0x70, 0x1b,
+	0x96, 0xbc, 0xc0, 0x1e, 0x45, 0xe2, 0x28, 0x71, 0xc0, 0x4b, 0x16, 0x2a, 0x63, 0xaf, 0x3f, 0x8e,
+	0x1d, 0xde, 0xff, 0xcb, 0x8c, 0xe5, 0x12, 0x2e, 0x65, 0xac, 0x12, 0xc4, 0xc6, 0xe6, 0xb5, 0x7d,
+	0xad, 0xb1, 0x5d, 0x78, 0x32, 0xf9, 0x52, 0x9d, 0x32, 0x3a, 0xfc, 0xc1, 0x7a, 0x5b, 0x31, 0x1d,
+	0xc7, 0xcc, 0x8f, 0x6c, 0x0d, 0x3f, 0xf1, 0x2e, 0x6c, 0x97, 0xea, 0x89, 0x82, 0x7c, 0x01, 0x2b,
+	0x6a, 0xc9, 0xf1, 0x38, 0xe8, 0xf8, 0x95, 0x58, 0xda, 0x33, 0x58, 0xcd, 0x42, 0x4d, 0x79, 0x77,
+	0x08, 0x20, 0x99, 0xbd, 0x27, 0x34, 0xe8, 0x7a, 0xbd, 0x8a, 0x71, 0xea, 0x8e, 0x7d, 0xdf, 0x1e,
+	0x39, 0xa2, 0x1f, 0xc7, 0x29, 0x14, 0x5c, 0x39, 0xa2, 0x8f, 0x9f, 0xc3, 0x4a, 0x46, 0xcd, 0xd4,
+	0x3a, 0x31, 0x80, 0xdd, 0x22, 0x6f, 0x55, 0x76, 0x4c, 0xe2, 0x80, 0x99, 0x94, 0x03, 0x9e, 0x02,
+	0x9e, 0xa6, 0x2c, 0x8a, 0xce, 0x39, 0xa0, 0xb0, 0xa0, 0xbc, 0xf5, 0x5c, 0x12, 0x54, 0x2a, 0x5c,
+	0xf8, 0x04, 0x56, 0x32, 0x48, 0x91, 0x27, 0x5e, 0x00, 0xf2, 0x95, 0xc8, 0xe6, 0x7d, 0xca, 0x84,
+	0x1d, 0x38, 0xc3, 0xb8, 0x4c, 0xb5, 0xa3, 0x99, 0xeb, 0x70, 0xe2, 0x9d, 0x33, 0x24, 0x07, 0xbf,
+	0x3e, 0x94, 0x5d, 0x4e, 0x4c, 0xc4, 0x55, 0x1b, 0x88, 0x3e, 0x40, 0x7b, 0xb2, 0x37, 0x43, 0xdb,
+	0x79, 0x73, 0x32, 0x4d, 0xa0, 0xb9, 0x53, 0xbe, 0x20, 0x3a, 0x7b, 0x0d, 0xdd, 0xc4, 0x3d, 0x55,
+	0xaa, 0xe1, 0x42, 0xe9, 0x8d, 0x85, 0xbd, 0x9d, 0xb9, 0x3b, 0x65, 0x45, 0x82, 0xfd, 0x1a, 0x40,
+	0x77, 0x50, 0x68, 0x23, 0xbb, 0x25, 0xd5, 0xc3, 0x99, 0x66, 0xd1, 0x54, 0x02, 0xf3, 0x3d, 0x3c,
+	0xcc, 0x36, 0x40, 0xe8, 0x71, 0x42, 0xed, 0x8a, 0x5a, 0x31, 0xf3, 0x49, 0xd9, 0x74, 0x1a, 0x32,
+	0xdb, 0xec, 0x68, 0xc8, 0xc2, 0x8e, 0x4a, 0x43, 0x16, 0xf7, 0x48, 0xb8, 0x86, 0x7e, 0x04, 0x94,
+	0x6f, 0x52, 0x50, 0xe2, 0xa7, 0xd2, 0x6e, 0xc9, 0xc4, 0xd3, 0x96, 0x24, 0xf0, 0xe7, 0xb0, 0x94,
+	0xa2, 0xf7, 0x28, 0xf1, 0x58, 0xbe, 0xf3, 0x31, 0x37, 0x0b, 0xe7, 0x12, 0xa4, 0x0f, 0xd0, 0x9e,
+	0xcc, 0x0a, 0x7d, 0x95, 0x4a, 0x7a, 0x05, 0x7d, 0x95, 0x4a, 0xd9, 0x7f, 0x0d, 0x9d, 0x01, 0x68,
+	0x46, 0xac, 0xc3, 0x9d, 0xa3, 0xdf, 0x3a, 0xdc, 0x79, 0x02, 0x8d, 0x6b, 0x2f, 0xeb, 0xa1, 0x85,
+	0x93, 0x0c, 0x57, 0x5b, 0x58, 0x42, 0xa5, 0xb5, 0x85, 0x65, 0xe4, 0x58, 0x5d, 0xf6, 0x1c, 0x65,
+	0xd4, 0x97, 0xbd, 0x8c, 0x22, 0xeb, 0xcb, 0x5e, 0xca, 0x37, 0x71, 0x0d, 0x1d, 0xc2, 0x5c, 0x48,
+	0x0b, 0xd1, 0x4a, 0xb2, 0x58, 0xf3, 0x4c, 0x73, 0x35, 0x2b, 0x4c, 0x36, 0xbd, 0x82, 0x46, 0x4c,
+	0xb0, 0xd0, 0x7a, 0xbc, 0x66, 0x82, 0x36, 0x9a, 0x46, 0x7e, 0x22, 0x01, 0x78, 0x07, 0x0f, 0x32,
+	0x6c, 0x08, 0x6d, 0x25, 0x9a, 0x0a, 0xe8, 0x98, 0xf9, 0xb8, 0x64, 0x36, 0x9d, 0xb2, 0x9a, 0xa5,
+	0xe8, 0x18, 0xe6, 0x38, 0x94, 0x8e, 0x61, 0x01, 0xa9, 0x91, 0xc9, 0x90, 0x27, 0x1a, 0x3a, 0x19,
+	0x4a, 0x29, 0x8f, 0x4e, 0x86, 0x72, 0x9e, 0x12, 0xc3, 0x4f, 0x52, 0x83, 0x34, 0x7c, 0x09, 0x49,
+	0x49, 0xc3, 0x97, 0x31, 0x0b, 0x5c, 0x43, 0x7e, 0xbe, 0x67, 0x8e, 0x9e, 0x74, 0xf4, 0x9f, 0xb2,
+	0x3c, 0xc8, 0x72, 0x0b, 0xf3, 0xbf, 0x7f, 0xba, 0x2e, 0xd1, 0x76, 0x09, 0xad, 0xf4, 0x93, 0x8e,
+	0x36, 0xb3, 0x5b, 0x33, 0x4f, 0xa3, 0xb9, 0x55, 0x3c, 0x99, 0x4a, 0x9e, 0x4f, 0x60, 0x96, 0x3f,
+	0x7a, 0xe8, 0x7f, 0xd3, 0xec, 0xca, 0xaa, 0x7a, 0xf6, 0x35, 0x4b, 0x63, 0xc5, 0x7b, 0xf5, 0xb0,
+	0x42, 0xa5, 0x78, 0x80, 0xae, 0x50, 0x79, 0x0e, 0xa2, 0x2b, 0x54, 0x01, 0x71, 0x88, 0x6a, 0x9d,
+	0x7e, 0x47, 0x53, 0xb5, 0x2e, 0xf7, 0x4c, 0xa7, 0x6a, 0x5d, 0xfe, 0xe1, 0xc5, 0xb5, 0xdb, 0x05,
+	0xf9, 0xa3, 0xf4, 0xf0, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x46, 0x1f, 0xcc, 0xb0, 0x5a, 0x15,
 	0x00, 0x00,
 }

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

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: server.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 ServerInfoRequest struct {
+}
+
+func (m *ServerInfoRequest) Reset()                    { *m = ServerInfoRequest{} }
+func (m *ServerInfoRequest) String() string            { return proto.CompactTextString(m) }
+func (*ServerInfoRequest) ProtoMessage()               {}
+func (*ServerInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
+
+type ServerInfoResponse struct {
+	ServerVersion string `protobuf:"bytes,1,opt,name=server_version,json=serverVersion" json:"server_version,omitempty"`
+	GitVersion    string `protobuf:"bytes,2,opt,name=git_version,json=gitVersion" json:"git_version,omitempty"`
+}
+
+func (m *ServerInfoResponse) Reset()                    { *m = ServerInfoResponse{} }
+func (m *ServerInfoResponse) String() string            { return proto.CompactTextString(m) }
+func (*ServerInfoResponse) ProtoMessage()               {}
+func (*ServerInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
+
+func (m *ServerInfoResponse) GetServerVersion() string {
+	if m != nil {
+		return m.ServerVersion
+	}
+	return ""
+}
+
+func (m *ServerInfoResponse) GetGitVersion() string {
+	if m != nil {
+		return m.GitVersion
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*ServerInfoRequest)(nil), "gitaly.ServerInfoRequest")
+	proto.RegisterType((*ServerInfoResponse)(nil), "gitaly.ServerInfoResponse")
+}
+
+// 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 ServerService service
+
+type ServerServiceClient interface {
+	ServerInfo(ctx context.Context, in *ServerInfoRequest, opts ...grpc.CallOption) (*ServerInfoResponse, error)
+}
+
+type serverServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewServerServiceClient(cc *grpc.ClientConn) ServerServiceClient {
+	return &serverServiceClient{cc}
+}
+
+func (c *serverServiceClient) ServerInfo(ctx context.Context, in *ServerInfoRequest, opts ...grpc.CallOption) (*ServerInfoResponse, error) {
+	out := new(ServerInfoResponse)
+	err := grpc.Invoke(ctx, "/gitaly.ServerService/ServerInfo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for ServerService service
+
+type ServerServiceServer interface {
+	ServerInfo(context.Context, *ServerInfoRequest) (*ServerInfoResponse, error)
+}
+
+func RegisterServerServiceServer(s *grpc.Server, srv ServerServiceServer) {
+	s.RegisterService(&_ServerService_serviceDesc, srv)
+}
+
+func _ServerService_ServerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ServerInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ServerServiceServer).ServerInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.ServerService/ServerInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ServerServiceServer).ServerInfo(ctx, req.(*ServerInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _ServerService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.ServerService",
+	HandlerType: (*ServerServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "ServerInfo",
+			Handler:    _ServerService_ServerInfo_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "server.proto",
+}
+
+func init() { proto.RegisterFile("server.proto", fileDescriptor11) }
+
+var fileDescriptor11 = []byte{
+	// 160 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4e, 0x2d, 0x2a,
+	0x4b, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9,
+	0x54, 0x12, 0xe6, 0x12, 0x0c, 0x06, 0x8b, 0x7b, 0xe6, 0xa5, 0xe5, 0x07, 0xa5, 0x16, 0x96, 0xa6,
+	0x16, 0x97, 0x28, 0xc5, 0x70, 0x09, 0x21, 0x0b, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0xa9,
+	0x72, 0xf1, 0x41, 0x8c, 0x88, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x93, 0x60, 0x54, 0x60,
+	0xd4, 0xe0, 0x0c, 0xe2, 0x85, 0x88, 0x86, 0x41, 0x04, 0x85, 0xe4, 0xb9, 0xb8, 0xd3, 0x33, 0x4b,
+	0xe0, 0x6a, 0x98, 0xc0, 0x6a, 0xb8, 0xd2, 0x33, 0x4b, 0xa0, 0x0a, 0x8c, 0xc2, 0xb8, 0x78, 0x21,
+	0xa6, 0x83, 0xc8, 0xcc, 0xe4, 0x54, 0x21, 0x57, 0x2e, 0x2e, 0x84, 0x75, 0x42, 0x92, 0x7a, 0x10,
+	0xa7, 0xe9, 0x61, 0xb8, 0x4b, 0x4a, 0x0a, 0x9b, 0x14, 0xc4, 0x75, 0x4a, 0x0c, 0x49, 0x6c, 0x60,
+	0x9f, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xa0, 0x30, 0xe2, 0x5e, 0xe9, 0x00, 0x00, 0x00,
+}

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

@@ -30,7 +30,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 fileDescriptor11, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{0} }
 
 func (m *Repository) GetStorageName() string {
 	if m != nil {
@@ -80,7 +80,7 @@ type GitCommit struct {
 func (m *GitCommit) Reset()                    { *m = GitCommit{} }
 func (m *GitCommit) String() string            { return proto.CompactTextString(m) }
 func (*GitCommit) ProtoMessage()               {}
-func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
+func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{1} }
 
 func (m *GitCommit) GetId() string {
 	if m != nil {
@@ -133,7 +133,7 @@ type CommitAuthor struct {
 func (m *CommitAuthor) Reset()                    { *m = CommitAuthor{} }
 func (m *CommitAuthor) String() string            { return proto.CompactTextString(m) }
 func (*CommitAuthor) ProtoMessage()               {}
-func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{2} }
+func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{2} }
 
 func (m *CommitAuthor) GetName() []byte {
 	if m != nil {
@@ -163,7 +163,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 fileDescriptor11, []int{3} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{3} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -181,7 +181,7 @@ type Branch struct {
 func (m *Branch) Reset()                    { *m = Branch{} }
 func (m *Branch) String() string            { return proto.CompactTextString(m) }
 func (*Branch) ProtoMessage()               {}
-func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{4} }
+func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{4} }
 
 func (m *Branch) GetName() []byte {
 	if m != nil {
@@ -207,7 +207,7 @@ type Tag struct {
 func (m *Tag) Reset()                    { *m = Tag{} }
 func (m *Tag) String() string            { return proto.CompactTextString(m) }
 func (*Tag) ProtoMessage()               {}
-func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{5} }
+func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{5} }
 
 func (m *Tag) GetName() []byte {
 	if m != nil {
@@ -247,7 +247,7 @@ type User struct {
 func (m *User) Reset()                    { *m = User{} }
 func (m *User) String() string            { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()               {}
-func (*User) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{6} }
+func (*User) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{6} }
 
 func (m *User) GetGlId() string {
 	if m != nil {
@@ -287,9 +287,9 @@ func init() {
 	proto.RegisterType((*User)(nil), "gitaly.User")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor11) }
+func init() { proto.RegisterFile("shared.proto", fileDescriptor12) }
 
-var fileDescriptor11 = []byte{
+var fileDescriptor12 = []byte{
 	// 518 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6f, 0xd3, 0x40,
 	0x10, 0x55, 0x1c, 0xc7, 0x90, 0x89, 0x8b, 0x60, 0xc9, 0xc1, 0xaa, 0x54, 0x35, 0x98, 0x4b, 0x0f,

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

@@ -26,7 +26,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 fileDescriptor12, []int{0} }
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
 
 func (m *InfoRefsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -49,7 +49,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 fileDescriptor12, []int{1} }
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{1} }
 
 func (m *InfoRefsResponse) GetData() []byte {
 	if m != nil {
@@ -70,7 +70,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 fileDescriptor12, []int{2} }
+func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{2} }
 
 func (m *PostUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -101,7 +101,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 fileDescriptor12, []int{3} }
+func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{3} }
 
 func (m *PostUploadPackResponse) GetData() []byte {
 	if m != nil {
@@ -125,7 +125,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 fileDescriptor12, []int{4} }
+func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{4} }
 
 func (m *PostReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -170,7 +170,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 fileDescriptor12, []int{5} }
+func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{5} }
 
 func (m *PostReceivePackResponse) GetData() []byte {
 	if m != nil {
@@ -485,9 +485,9 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "smarthttp.proto",
 }
 
-func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor12) }
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor13) }
 
-var fileDescriptor12 = []byte{
+var fileDescriptor13 = []byte{
 	// 386 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x93, 0xdd, 0xee, 0xd2, 0x40,
 	0x10, 0xc5, 0x5d, 0xbe, 0x12, 0x06, 0x14, 0x32, 0x44, 0x69, 0x9a, 0x28, 0xa4, 0x26, 0xa6, 0x17,

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

@@ -29,7 +29,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 fileDescriptor13, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -65,7 +65,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 fileDescriptor13, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -103,7 +103,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 fileDescriptor13, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -153,7 +153,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 fileDescriptor13, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -176,11 +176,74 @@ func (m *SSHReceivePackResponse) GetExitStatus() *ExitStatus {
 	return nil
 }
 
+type SSHUploadArchiveRequest struct {
+	// 'repository' must be present in the first message.
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// A chunk of raw data to be copied to 'git upload-archive' standard input
+	Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3" json:"stdin,omitempty"`
+}
+
+func (m *SSHUploadArchiveRequest) Reset()                    { *m = SSHUploadArchiveRequest{} }
+func (m *SSHUploadArchiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*SSHUploadArchiveRequest) ProtoMessage()               {}
+func (*SSHUploadArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
+
+func (m *SSHUploadArchiveRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *SSHUploadArchiveRequest) GetStdin() []byte {
+	if m != nil {
+		return m.Stdin
+	}
+	return nil
+}
+
+type SSHUploadArchiveResponse struct {
+	// A chunk of raw data from 'git upload-archive' standard output
+	Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3" json:"stdout,omitempty"`
+	// A chunk of raw data from 'git upload-archive' standard error
+	Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3" json:"stderr,omitempty"`
+	// This value will only be set on the last message
+	ExitStatus *ExitStatus `protobuf:"bytes,3,opt,name=exit_status,json=exitStatus" json:"exit_status,omitempty"`
+}
+
+func (m *SSHUploadArchiveResponse) Reset()                    { *m = SSHUploadArchiveResponse{} }
+func (m *SSHUploadArchiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*SSHUploadArchiveResponse) ProtoMessage()               {}
+func (*SSHUploadArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{5} }
+
+func (m *SSHUploadArchiveResponse) GetStdout() []byte {
+	if m != nil {
+		return m.Stdout
+	}
+	return nil
+}
+
+func (m *SSHUploadArchiveResponse) GetStderr() []byte {
+	if m != nil {
+		return m.Stderr
+	}
+	return nil
+}
+
+func (m *SSHUploadArchiveResponse) GetExitStatus() *ExitStatus {
+	if m != nil {
+		return m.ExitStatus
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*SSHUploadPackRequest)(nil), "gitaly.SSHUploadPackRequest")
 	proto.RegisterType((*SSHUploadPackResponse)(nil), "gitaly.SSHUploadPackResponse")
 	proto.RegisterType((*SSHReceivePackRequest)(nil), "gitaly.SSHReceivePackRequest")
 	proto.RegisterType((*SSHReceivePackResponse)(nil), "gitaly.SSHReceivePackResponse")
+	proto.RegisterType((*SSHUploadArchiveRequest)(nil), "gitaly.SSHUploadArchiveRequest")
+	proto.RegisterType((*SSHUploadArchiveResponse)(nil), "gitaly.SSHUploadArchiveResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -198,6 +261,8 @@ type SSHServiceClient interface {
 	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) (SSHService_SSHReceivePackClient, error)
+	// To forward 'git upload-archive' to Gitaly for SSH sessions
+	SSHUploadArchive(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadArchiveClient, error)
 }
 
 type sSHServiceClient struct {
@@ -270,6 +335,37 @@ func (x *sSHServiceSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error)
 	return m, nil
 }
 
+func (c *sSHServiceClient) SSHUploadArchive(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadArchiveClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[2], c.cc, "/gitaly.SSHService/SSHUploadArchive", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &sSHServiceSSHUploadArchiveClient{stream}
+	return x, nil
+}
+
+type SSHService_SSHUploadArchiveClient interface {
+	Send(*SSHUploadArchiveRequest) error
+	Recv() (*SSHUploadArchiveResponse, error)
+	grpc.ClientStream
+}
+
+type sSHServiceSSHUploadArchiveClient struct {
+	grpc.ClientStream
+}
+
+func (x *sSHServiceSSHUploadArchiveClient) Send(m *SSHUploadArchiveRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *sSHServiceSSHUploadArchiveClient) Recv() (*SSHUploadArchiveResponse, error) {
+	m := new(SSHUploadArchiveResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for SSHService service
 
 type SSHServiceServer interface {
@@ -277,6 +373,8 @@ type SSHServiceServer interface {
 	SSHUploadPack(SSHService_SSHUploadPackServer) error
 	// To forward 'git receive-pack' to Gitaly for SSH sessions
 	SSHReceivePack(SSHService_SSHReceivePackServer) error
+	// To forward 'git upload-archive' to Gitaly for SSH sessions
+	SSHUploadArchive(SSHService_SSHUploadArchiveServer) error
 }
 
 func RegisterSSHServiceServer(s *grpc.Server, srv SSHServiceServer) {
@@ -335,6 +433,32 @@ func (x *sSHServiceSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error)
 	return m, nil
 }
 
+func _SSHService_SSHUploadArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SSHServiceServer).SSHUploadArchive(&sSHServiceSSHUploadArchiveServer{stream})
+}
+
+type SSHService_SSHUploadArchiveServer interface {
+	Send(*SSHUploadArchiveResponse) error
+	Recv() (*SSHUploadArchiveRequest, error)
+	grpc.ServerStream
+}
+
+type sSHServiceSSHUploadArchiveServer struct {
+	grpc.ServerStream
+}
+
+func (x *sSHServiceSSHUploadArchiveServer) Send(m *SSHUploadArchiveResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *sSHServiceSSHUploadArchiveServer) Recv() (*SSHUploadArchiveRequest, error) {
+	m := new(SSHUploadArchiveRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 var _SSHService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.SSHService",
 	HandlerType: (*SSHServiceServer)(nil),
@@ -352,36 +476,45 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 			ClientStreams: true,
 		},
+		{
+			StreamName:    "SSHUploadArchive",
+			Handler:       _SSHService_SSHUploadArchive_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
 	},
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor13) }
-
-var fileDescriptor13 = []byte{
-	// 377 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xcd, 0xce, 0xd2, 0x40,
-	0x14, 0x75, 0xa4, 0x10, 0xb9, 0xf4, 0x33, 0x64, 0x04, 0xd2, 0x10, 0x7f, 0x48, 0xdd, 0x74, 0x61,
-	0x88, 0x81, 0x47, 0x30, 0x26, 0xe8, 0x46, 0x33, 0x0d, 0xeb, 0x66, 0x6c, 0xaf, 0xc3, 0xc4, 0xa1,
-	0x53, 0x67, 0xa6, 0x04, 0x12, 0x7d, 0x22, 0x1f, 0xc0, 0x8d, 0x0f, 0x67, 0x32, 0xad, 0x58, 0x50,
-	0x96, 0xba, 0xeb, 0x3d, 0xe7, 0xfe, 0x9c, 0x73, 0x6f, 0x07, 0x86, 0xd6, 0xee, 0x96, 0x95, 0xd1,
-	0x4e, 0xd3, 0x81, 0x90, 0x8e, 0xab, 0xd3, 0x3c, 0xb4, 0x3b, 0x6e, 0xb0, 0x68, 0xd0, 0xf8, 0x1b,
-	0x81, 0x49, 0x9a, 0x6e, 0xb6, 0x95, 0xd2, 0xbc, 0x78, 0xcf, 0xf3, 0x4f, 0x0c, 0x3f, 0xd7, 0x68,
-	0x1d, 0x5d, 0x01, 0x18, 0xac, 0xb4, 0x95, 0x4e, 0x9b, 0x53, 0x44, 0x16, 0x24, 0x19, 0xad, 0xe8,
-	0xb2, 0xe9, 0xb1, 0x64, 0x67, 0x86, 0x75, 0xb2, 0xe8, 0x04, 0xfa, 0xd6, 0x15, 0xb2, 0x8c, 0xee,
-	0x2f, 0x48, 0x12, 0xb2, 0x26, 0xa0, 0x2f, 0x80, 0x0a, 0xe9, 0xb2, 0x5c, 0x97, 0x1f, 0xa5, 0xc8,
-	0x74, 0xe5, 0xa4, 0x2e, 0x6d, 0x14, 0x2c, 0x7a, 0xc9, 0x90, 0x8d, 0x85, 0x74, 0xaf, 0x3c, 0xf1,
-	0xae, 0xc1, 0xdf, 0x06, 0x0f, 0x7a, 0xe3, 0x80, 0x4d, 0x3b, 0x15, 0x15, 0x37, 0x7c, 0x8f, 0x0e,
-	0x8d, 0x8d, 0xbf, 0xc0, 0xf4, 0x4a, 0xac, 0xad, 0x74, 0x69, 0x91, 0xce, 0x60, 0x60, 0x5d, 0xa1,
-	0x6b, 0xe7, 0x95, 0x86, 0xac, 0x8d, 0x5a, 0x1c, 0x8d, 0x69, 0x25, 0xb5, 0x11, 0x5d, 0xc3, 0x08,
-	0x8f, 0xd2, 0x65, 0xd6, 0x71, 0x57, 0xdb, 0xa8, 0x77, 0x69, 0xef, 0xf5, 0x51, 0xba, 0xd4, 0x33,
-	0x0c, 0xf0, 0xfc, 0x1d, 0xff, 0x20, 0x7e, 0x3c, 0xc3, 0x1c, 0xe5, 0x01, 0xff, 0xcd, 0xb2, 0x1e,
-	0x41, 0x5f, 0xa8, 0x4c, 0x16, 0x5e, 0xd2, 0x90, 0x05, 0x42, 0xbd, 0x29, 0xe8, 0x73, 0xb8, 0x13,
-	0x2a, 0xeb, 0x4c, 0x08, 0x3c, 0x19, 0x0a, 0xf5, 0xbb, 0x37, 0x7d, 0x06, 0x23, 0xa1, 0xb2, 0xda,
-	0xa2, 0x29, 0xf9, 0x1e, 0xa3, 0xbe, 0x4f, 0x01, 0xa1, 0xb6, 0x2d, 0x12, 0x7f, 0x85, 0xd9, 0xb5,
-	0xfa, 0xff, 0xb8, 0xbd, 0xd5, 0x77, 0x02, 0x90, 0xa6, 0x9b, 0x14, 0xcd, 0x41, 0xe6, 0x48, 0x19,
-	0xdc, 0x5d, 0x9c, 0x92, 0x3e, 0xfe, 0x55, 0xff, 0xb7, 0xdf, 0x71, 0xfe, 0xe4, 0x06, 0xdb, 0x38,
-	0x88, 0xef, 0x25, 0xe4, 0x25, 0xa1, 0x5b, 0x78, 0x78, 0xe9, 0x90, 0x76, 0xcb, 0xfe, 0xbc, 0xdb,
-	0xfc, 0xe9, 0x2d, 0xba, 0xdb, 0xf6, 0xc3, 0xc0, 0x3f, 0x95, 0xf5, 0xcf, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0x1b, 0x65, 0x3d, 0xab, 0x4d, 0x03, 0x00, 0x00,
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor14) }
+
+var fileDescriptor14 = []byte{
+	// 423 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0xc6, 0x8d, 0x13, 0x91, 0x89, 0x8b, 0xa2, 0xa5, 0x2d, 0x96, 0x05, 0xd4, 0x32, 0x17, 0x1f,
+	0x50, 0x84, 0xd2, 0x27, 0x40, 0x08, 0xa9, 0x70, 0x01, 0xad, 0x95, 0x13, 0x07, 0x6b, 0xb1, 0x87,
+	0xcd, 0x8a, 0xad, 0xd7, 0xec, 0xae, 0xa3, 0x56, 0x02, 0xf1, 0x12, 0xbc, 0x05, 0xaf, 0xc0, 0xc3,
+	0x21, 0xad, 0x4d, 0xb0, 0x13, 0x72, 0xa3, 0xbd, 0x79, 0xe6, 0x9b, 0x9f, 0x6f, 0xbe, 0x19, 0x2f,
+	0x4c, 0x8d, 0x59, 0x2f, 0x6a, 0xad, 0xac, 0x22, 0x13, 0x2e, 0x2c, 0x93, 0x37, 0x51, 0x60, 0xd6,
+	0x4c, 0x63, 0xd9, 0x7a, 0x93, 0x9f, 0x1e, 0x9c, 0x64, 0xd9, 0xe5, 0xaa, 0x96, 0x8a, 0x95, 0xef,
+	0x59, 0xf1, 0x99, 0xe2, 0x97, 0x06, 0x8d, 0x25, 0x4b, 0x00, 0x8d, 0xb5, 0x32, 0xc2, 0x2a, 0x7d,
+	0x13, 0x7a, 0xb1, 0x97, 0xce, 0x96, 0x64, 0xd1, 0xd6, 0x58, 0xd0, 0x2d, 0x42, 0x7b, 0x51, 0xe4,
+	0x04, 0xc6, 0xc6, 0x96, 0xa2, 0x0a, 0x8f, 0x62, 0x2f, 0x0d, 0x68, 0x6b, 0x90, 0xe7, 0x40, 0xb8,
+	0xb0, 0x79, 0xa1, 0xaa, 0x4f, 0x82, 0xe7, 0xaa, 0xb6, 0x42, 0x55, 0x26, 0xf4, 0xe3, 0x51, 0x3a,
+	0xa5, 0x73, 0x2e, 0xec, 0x2b, 0x07, 0xbc, 0x6b, 0xfd, 0x6f, 0xfd, 0xfb, 0xa3, 0xb9, 0x4f, 0x4f,
+	0x7b, 0x19, 0x35, 0xd3, 0xec, 0x0a, 0x2d, 0x6a, 0x93, 0x7c, 0x85, 0xd3, 0x1d, 0xb2, 0xa6, 0x56,
+	0x95, 0x41, 0x72, 0x06, 0x13, 0x63, 0x4b, 0xd5, 0x58, 0xc7, 0x34, 0xa0, 0x9d, 0xd5, 0xf9, 0x51,
+	0xeb, 0x8e, 0x52, 0x67, 0x91, 0x0b, 0x98, 0xe1, 0xb5, 0xb0, 0xb9, 0xb1, 0xcc, 0x36, 0x26, 0x1c,
+	0x0d, 0xc7, 0x7b, 0x7d, 0x2d, 0x6c, 0xe6, 0x10, 0x0a, 0xb8, 0xfd, 0x4e, 0x7e, 0x79, 0xae, 0x3d,
+	0xc5, 0x02, 0xc5, 0x06, 0x6f, 0x47, 0xac, 0x87, 0x30, 0xe6, 0x32, 0x17, 0xa5, 0xa3, 0x34, 0xa5,
+	0x3e, 0x97, 0x6f, 0x4a, 0xf2, 0x0c, 0x8e, 0xb9, 0xcc, 0x7b, 0x1d, 0x7c, 0x07, 0x06, 0x5c, 0xfe,
+	0xad, 0x4d, 0xce, 0x61, 0xc6, 0x65, 0xde, 0x18, 0xd4, 0x15, 0xbb, 0xc2, 0x70, 0xec, 0x42, 0x80,
+	0xcb, 0x55, 0xe7, 0x49, 0xbe, 0xc1, 0xd9, 0x2e, 0xfb, 0xbb, 0x54, 0xaf, 0x80, 0x47, 0xdb, 0xdd,
+	0xbd, 0xd4, 0xc5, 0x5a, 0x6c, 0xf0, 0xbf, 0xcb, 0x97, 0x7c, 0x87, 0x70, 0xbf, 0xc9, 0x1d, 0x4e,
+	0xb9, 0xfc, 0x71, 0x04, 0x90, 0x65, 0x97, 0x19, 0xea, 0x8d, 0x28, 0x90, 0x50, 0x38, 0x1e, 0x1c,
+	0x2c, 0x79, 0xfc, 0x27, 0xff, 0x5f, 0x3f, 0x5d, 0xf4, 0xe4, 0x00, 0xda, 0x4e, 0x90, 0xdc, 0x4b,
+	0xbd, 0x17, 0x1e, 0x59, 0xc1, 0x83, 0xe1, 0x1e, 0x49, 0x3f, 0x6d, 0xff, 0x3a, 0xa3, 0xa7, 0x87,
+	0xe0, 0x41, 0xd9, 0x0f, 0x30, 0xdf, 0x95, 0x8e, 0x9c, 0xef, 0xf1, 0x19, 0x6e, 0x2e, 0x8a, 0x0f,
+	0x07, 0xf4, 0x8b, 0x7f, 0x9c, 0xb8, 0xd7, 0xe6, 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6,
+	0xa6, 0x53, 0xee, 0x90, 0x04, 0x00, 0x00,
 }

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

@@ -26,7 +26,7 @@ type WikiCommitDetails struct {
 func (m *WikiCommitDetails) Reset()                    { *m = WikiCommitDetails{} }
 func (m *WikiCommitDetails) String() string            { return proto.CompactTextString(m) }
 func (*WikiCommitDetails) ProtoMessage()               {}
-func (*WikiCommitDetails) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
+func (*WikiCommitDetails) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} }
 
 func (m *WikiCommitDetails) GetName() []byte {
 	if m != nil {
@@ -57,7 +57,7 @@ type WikiPageVersion struct {
 func (m *WikiPageVersion) Reset()                    { *m = WikiPageVersion{} }
 func (m *WikiPageVersion) String() string            { return proto.CompactTextString(m) }
 func (*WikiPageVersion) ProtoMessage()               {}
-func (*WikiPageVersion) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
+func (*WikiPageVersion) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{1} }
 
 func (m *WikiPageVersion) GetCommit() *GitCommit {
 	if m != nil {
@@ -89,7 +89,7 @@ type WikiPage struct {
 func (m *WikiPage) Reset()                    { *m = WikiPage{} }
 func (m *WikiPage) String() string            { return proto.CompactTextString(m) }
 func (*WikiPage) ProtoMessage()               {}
-func (*WikiPage) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
+func (*WikiPage) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{2} }
 
 func (m *WikiPage) GetVersion() *WikiPageVersion {
 	if m != nil {
@@ -157,7 +157,7 @@ type WikiGetPageVersionsRequest struct {
 func (m *WikiGetPageVersionsRequest) Reset()                    { *m = WikiGetPageVersionsRequest{} }
 func (m *WikiGetPageVersionsRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetPageVersionsRequest) ProtoMessage()               {}
-func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{3} }
+func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{3} }
 
 func (m *WikiGetPageVersionsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -194,7 +194,7 @@ type WikiGetPageVersionsResponse struct {
 func (m *WikiGetPageVersionsResponse) Reset()                    { *m = WikiGetPageVersionsResponse{} }
 func (m *WikiGetPageVersionsResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetPageVersionsResponse) ProtoMessage()               {}
-func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
+func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{4} }
 
 func (m *WikiGetPageVersionsResponse) GetVersions() []*WikiPageVersion {
 	if m != nil {
@@ -217,7 +217,7 @@ type WikiWritePageRequest struct {
 func (m *WikiWritePageRequest) Reset()                    { *m = WikiWritePageRequest{} }
 func (m *WikiWritePageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiWritePageRequest) ProtoMessage()               {}
-func (*WikiWritePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{5} }
+func (*WikiWritePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{5} }
 
 func (m *WikiWritePageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -261,7 +261,7 @@ type WikiWritePageResponse struct {
 func (m *WikiWritePageResponse) Reset()                    { *m = WikiWritePageResponse{} }
 func (m *WikiWritePageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiWritePageResponse) ProtoMessage()               {}
-func (*WikiWritePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{6} }
+func (*WikiWritePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{6} }
 
 func (m *WikiWritePageResponse) GetDuplicateError() []byte {
 	if m != nil {
@@ -284,7 +284,7 @@ type WikiUpdatePageRequest struct {
 func (m *WikiUpdatePageRequest) Reset()                    { *m = WikiUpdatePageRequest{} }
 func (m *WikiUpdatePageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiUpdatePageRequest) ProtoMessage()               {}
-func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{7} }
+func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{7} }
 
 func (m *WikiUpdatePageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -335,7 +335,7 @@ type WikiUpdatePageResponse struct {
 func (m *WikiUpdatePageResponse) Reset()                    { *m = WikiUpdatePageResponse{} }
 func (m *WikiUpdatePageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiUpdatePageResponse) ProtoMessage()               {}
-func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{8} }
+func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{8} }
 
 func (m *WikiUpdatePageResponse) GetError() []byte {
 	if m != nil {
@@ -353,7 +353,7 @@ type WikiDeletePageRequest struct {
 func (m *WikiDeletePageRequest) Reset()                    { *m = WikiDeletePageRequest{} }
 func (m *WikiDeletePageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiDeletePageRequest) ProtoMessage()               {}
-func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{9} }
+func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{9} }
 
 func (m *WikiDeletePageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -382,7 +382,7 @@ type WikiDeletePageResponse struct {
 func (m *WikiDeletePageResponse) Reset()                    { *m = WikiDeletePageResponse{} }
 func (m *WikiDeletePageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiDeletePageResponse) ProtoMessage()               {}
-func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{10} }
+func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{10} }
 
 type WikiFindPageRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -394,7 +394,7 @@ type WikiFindPageRequest struct {
 func (m *WikiFindPageRequest) Reset()                    { *m = WikiFindPageRequest{} }
 func (m *WikiFindPageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindPageRequest) ProtoMessage()               {}
-func (*WikiFindPageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{11} }
+func (*WikiFindPageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{11} }
 
 func (m *WikiFindPageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -433,7 +433,7 @@ type WikiFindPageResponse struct {
 func (m *WikiFindPageResponse) Reset()                    { *m = WikiFindPageResponse{} }
 func (m *WikiFindPageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindPageResponse) ProtoMessage()               {}
-func (*WikiFindPageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{12} }
+func (*WikiFindPageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{12} }
 
 func (m *WikiFindPageResponse) GetPage() *WikiPage {
 	if m != nil {
@@ -452,7 +452,7 @@ type WikiFindFileRequest struct {
 func (m *WikiFindFileRequest) Reset()                    { *m = WikiFindFileRequest{} }
 func (m *WikiFindFileRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindFileRequest) ProtoMessage()               {}
-func (*WikiFindFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{13} }
+func (*WikiFindFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{13} }
 
 func (m *WikiFindFileRequest) GetRepository() *Repository {
 	if m != nil {
@@ -486,7 +486,7 @@ type WikiFindFileResponse struct {
 func (m *WikiFindFileResponse) Reset()                    { *m = WikiFindFileResponse{} }
 func (m *WikiFindFileResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindFileResponse) ProtoMessage()               {}
-func (*WikiFindFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{14} }
+func (*WikiFindFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{14} }
 
 func (m *WikiFindFileResponse) GetName() []byte {
 	if m != nil {
@@ -523,7 +523,7 @@ type WikiGetAllPagesRequest struct {
 func (m *WikiGetAllPagesRequest) Reset()                    { *m = WikiGetAllPagesRequest{} }
 func (m *WikiGetAllPagesRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetAllPagesRequest) ProtoMessage()               {}
-func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{15} }
+func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{15} }
 
 func (m *WikiGetAllPagesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -542,7 +542,7 @@ type WikiGetAllPagesResponse struct {
 func (m *WikiGetAllPagesResponse) Reset()                    { *m = WikiGetAllPagesResponse{} }
 func (m *WikiGetAllPagesResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetAllPagesResponse) ProtoMessage()               {}
-func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{16} }
+func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{16} }
 
 func (m *WikiGetAllPagesResponse) GetPage() *WikiPage {
 	if m != nil {
@@ -558,6 +558,62 @@ func (m *WikiGetAllPagesResponse) GetEndOfPage() bool {
 	return false
 }
 
+type WikiGetFormattedDataRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Title      []byte      `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
+	Revision   []byte      `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	Directory  []byte      `protobuf:"bytes,4,opt,name=directory,proto3" json:"directory,omitempty"`
+}
+
+func (m *WikiGetFormattedDataRequest) Reset()                    { *m = WikiGetFormattedDataRequest{} }
+func (m *WikiGetFormattedDataRequest) String() string            { return proto.CompactTextString(m) }
+func (*WikiGetFormattedDataRequest) ProtoMessage()               {}
+func (*WikiGetFormattedDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{17} }
+
+func (m *WikiGetFormattedDataRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *WikiGetFormattedDataRequest) GetTitle() []byte {
+	if m != nil {
+		return m.Title
+	}
+	return nil
+}
+
+func (m *WikiGetFormattedDataRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+func (m *WikiGetFormattedDataRequest) GetDirectory() []byte {
+	if m != nil {
+		return m.Directory
+	}
+	return nil
+}
+
+type WikiGetFormattedDataResponse struct {
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *WikiGetFormattedDataResponse) Reset()                    { *m = WikiGetFormattedDataResponse{} }
+func (m *WikiGetFormattedDataResponse) String() string            { return proto.CompactTextString(m) }
+func (*WikiGetFormattedDataResponse) ProtoMessage()               {}
+func (*WikiGetFormattedDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{18} }
+
+func (m *WikiGetFormattedDataResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*WikiCommitDetails)(nil), "gitaly.WikiCommitDetails")
 	proto.RegisterType((*WikiPageVersion)(nil), "gitaly.WikiPageVersion")
@@ -576,6 +632,8 @@ func init() {
 	proto.RegisterType((*WikiFindFileResponse)(nil), "gitaly.WikiFindFileResponse")
 	proto.RegisterType((*WikiGetAllPagesRequest)(nil), "gitaly.WikiGetAllPagesRequest")
 	proto.RegisterType((*WikiGetAllPagesResponse)(nil), "gitaly.WikiGetAllPagesResponse")
+	proto.RegisterType((*WikiGetFormattedDataRequest)(nil), "gitaly.WikiGetFormattedDataRequest")
+	proto.RegisterType((*WikiGetFormattedDataResponse)(nil), "gitaly.WikiGetFormattedDataResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -597,6 +655,7 @@ type WikiServiceClient interface {
 	WikiFindPage(ctx context.Context, in *WikiFindPageRequest, opts ...grpc.CallOption) (WikiService_WikiFindPageClient, error)
 	WikiFindFile(ctx context.Context, in *WikiFindFileRequest, opts ...grpc.CallOption) (WikiService_WikiFindFileClient, error)
 	WikiGetAllPages(ctx context.Context, in *WikiGetAllPagesRequest, opts ...grpc.CallOption) (WikiService_WikiGetAllPagesClient, error)
+	WikiGetFormattedData(ctx context.Context, in *WikiGetFormattedDataRequest, opts ...grpc.CallOption) (WikiService_WikiGetFormattedDataClient, error)
 }
 
 type wikiServiceClient struct {
@@ -812,6 +871,38 @@ func (x *wikiServiceWikiGetAllPagesClient) Recv() (*WikiGetAllPagesResponse, err
 	return m, nil
 }
 
+func (c *wikiServiceClient) WikiGetFormattedData(ctx context.Context, in *WikiGetFormattedDataRequest, opts ...grpc.CallOption) (WikiService_WikiGetFormattedDataClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_WikiService_serviceDesc.Streams[6], c.cc, "/gitaly.WikiService/WikiGetFormattedData", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &wikiServiceWikiGetFormattedDataClient{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 WikiService_WikiGetFormattedDataClient interface {
+	Recv() (*WikiGetFormattedDataResponse, error)
+	grpc.ClientStream
+}
+
+type wikiServiceWikiGetFormattedDataClient struct {
+	grpc.ClientStream
+}
+
+func (x *wikiServiceWikiGetFormattedDataClient) Recv() (*WikiGetFormattedDataResponse, error) {
+	m := new(WikiGetFormattedDataResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for WikiService service
 
 type WikiServiceServer interface {
@@ -823,6 +914,7 @@ type WikiServiceServer interface {
 	WikiFindPage(*WikiFindPageRequest, WikiService_WikiFindPageServer) error
 	WikiFindFile(*WikiFindFileRequest, WikiService_WikiFindFileServer) error
 	WikiGetAllPages(*WikiGetAllPagesRequest, WikiService_WikiGetAllPagesServer) error
+	WikiGetFormattedData(*WikiGetFormattedDataRequest, WikiService_WikiGetFormattedDataServer) error
 }
 
 func RegisterWikiServiceServer(s *grpc.Server, srv WikiServiceServer) {
@@ -983,6 +1075,27 @@ func (x *wikiServiceWikiGetAllPagesServer) Send(m *WikiGetAllPagesResponse) erro
 	return x.ServerStream.SendMsg(m)
 }
 
+func _WikiService_WikiGetFormattedData_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(WikiGetFormattedDataRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(WikiServiceServer).WikiGetFormattedData(m, &wikiServiceWikiGetFormattedDataServer{stream})
+}
+
+type WikiService_WikiGetFormattedDataServer interface {
+	Send(*WikiGetFormattedDataResponse) error
+	grpc.ServerStream
+}
+
+type wikiServiceWikiGetFormattedDataServer struct {
+	grpc.ServerStream
+}
+
+func (x *wikiServiceWikiGetFormattedDataServer) Send(m *WikiGetFormattedDataResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _WikiService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.WikiService",
 	HandlerType: (*WikiServiceServer)(nil),
@@ -1023,65 +1136,73 @@ var _WikiService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _WikiService_WikiGetAllPages_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "WikiGetFormattedData",
+			Handler:       _WikiService_WikiGetFormattedData_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "wiki.proto",
 }
 
-func init() { proto.RegisterFile("wiki.proto", fileDescriptor14) }
-
-var fileDescriptor14 = []byte{
-	// 846 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x72, 0xdc, 0x44,
-	0x10, 0x8e, 0xbc, 0xeb, 0x5d, 0x6d, 0xdb, 0x71, 0xc8, 0x10, 0x12, 0x45, 0x36, 0xc6, 0x35, 0x50,
-	0x85, 0xb9, 0xb8, 0xc0, 0xb9, 0x72, 0x08, 0x85, 0x89, 0x2f, 0x50, 0x18, 0x25, 0xc4, 0x47, 0xd5,
-	0x64, 0xd5, 0xf6, 0x4e, 0x45, 0x7f, 0x8c, 0x66, 0xd7, 0xb5, 0x8f, 0x42, 0x15, 0x4f, 0xc0, 0xe3,
-	0xf0, 0x06, 0x1c, 0xb9, 0xf2, 0x04, 0xd4, 0xfc, 0x68, 0x35, 0xd2, 0xfe, 0x50, 0x61, 0xc9, 0x4d,
-	0xd3, 0xdd, 0xf3, 0x4d, 0x7f, 0x5f, 0x4f, 0xf7, 0x08, 0xe0, 0x8e, 0xbf, 0xe5, 0x67, 0xa5, 0x28,
-	0x64, 0x41, 0x06, 0xb7, 0x5c, 0xb2, 0x74, 0x1e, 0xee, 0x57, 0x13, 0x26, 0x30, 0x31, 0x56, 0x7a,
-	0x0d, 0x0f, 0xaf, 0xf9, 0x5b, 0xfe, 0x6d, 0x91, 0x65, 0x5c, 0x5e, 0xa0, 0x64, 0x3c, 0xad, 0x08,
-	0x81, 0x7e, 0xce, 0x32, 0x0c, 0xbc, 0x13, 0xef, 0x74, 0x3f, 0xd2, 0xdf, 0xe4, 0x11, 0xec, 0x62,
-	0xc6, 0x78, 0x1a, 0xec, 0x68, 0xa3, 0x59, 0x90, 0x00, 0x86, 0x19, 0x56, 0x15, 0xbb, 0xc5, 0xa0,
-	0xa7, 0xed, 0xf5, 0x92, 0xbe, 0x82, 0x07, 0x0a, 0xf8, 0x8a, 0xdd, 0xe2, 0x6b, 0x14, 0x15, 0x2f,
-	0x72, 0xf2, 0x05, 0x0c, 0xc6, 0xfa, 0x1c, 0x0d, 0xbc, 0x77, 0xfe, 0xf0, 0xcc, 0xa4, 0x74, 0x76,
-	0xc9, 0xa5, 0x49, 0x20, 0xb2, 0x01, 0xe4, 0x31, 0x0c, 0x6e, 0x0a, 0x91, 0x31, 0xa9, 0x8f, 0x1b,
-	0x45, 0x76, 0x45, 0xff, 0xf2, 0xc0, 0xaf, 0x61, 0xc9, 0x57, 0x30, 0x9c, 0x19, 0x68, 0x0b, 0xf8,
-	0xa4, 0x06, 0xec, 0x9c, 0x1c, 0xd5, 0x71, 0xeb, 0x70, 0x15, 0x3b, 0xc9, 0x65, 0x5a, 0xb3, 0x30,
-	0x0b, 0xf2, 0x14, 0xfc, 0xa9, 0x48, 0xe3, 0x92, 0xc9, 0x49, 0xd0, 0xd7, 0xf1, 0xc3, 0xa9, 0x48,
-	0xaf, 0x98, 0x9c, 0x28, 0x89, 0xb4, 0x79, 0xd7, 0x48, 0x54, 0x5a, 0x9b, 0x96, 0x6d, 0xe0, 0xc8,
-	0x76, 0x0c, 0x30, 0xe1, 0x95, 0x2c, 0x04, 0x1f, 0xb3, 0x34, 0x18, 0x9e, 0x78, 0xa7, 0x7e, 0xe4,
-	0x58, 0xd4, 0x11, 0x82, 0xdd, 0xc5, 0x09, 0x93, 0x2c, 0xf0, 0x8d, 0x82, 0x82, 0xdd, 0x5d, 0x30,
-	0xc9, 0xe8, 0x6f, 0x1e, 0x84, 0x8a, 0xc8, 0x25, 0x4a, 0x87, 0x4b, 0x15, 0xe1, 0x2f, 0x53, 0xac,
-	0x24, 0x39, 0x07, 0x10, 0x58, 0x16, 0x15, 0x97, 0x85, 0x98, 0x5b, 0x01, 0x48, 0x2d, 0x40, 0xb4,
-	0xf0, 0x44, 0x4e, 0x14, 0x39, 0x84, 0x51, 0xc9, 0x6e, 0xd1, 0x30, 0x32, 0x85, 0xf4, 0x95, 0xa1,
-	0xa1, 0x64, 0x0b, 0xb9, 0x1b, 0xe9, 0x6f, 0x95, 0x5e, 0x89, 0x22, 0xd6, 0xf6, 0xbe, 0xb6, 0x0f,
-	0x4b, 0x14, 0x2a, 0x1d, 0x1a, 0xc1, 0xe1, 0xca, 0xec, 0xaa, 0xb2, 0xc8, 0x2b, 0x24, 0xcf, 0xc0,
-	0xb7, 0xa2, 0x57, 0x81, 0x77, 0xd2, 0xdb, 0x54, 0x9d, 0x45, 0x20, 0xfd, 0xc3, 0x83, 0x47, 0xca,
-	0x7b, 0x2d, 0xb8, 0x44, 0x15, 0xb2, 0x0d, 0xd9, 0xba, 0x1c, 0x3b, 0x4e, 0x39, 0x9a, 0xfa, 0xf7,
-	0x5a, 0xf5, 0x7f, 0x0e, 0x07, 0xe6, 0xe6, 0xc5, 0x89, 0xe9, 0x01, 0xcd, 0x76, 0xef, 0xfc, 0xa9,
-	0x9b, 0x73, 0xab, 0x49, 0xa2, 0xfb, 0xe3, 0x56, 0xcf, 0x04, 0x30, 0x1c, 0x17, 0xb9, 0xc4, 0x5c,
-	0xda, 0x3b, 0x51, 0x2f, 0xe9, 0x73, 0xf8, 0xa8, 0xc3, 0xc9, 0x4a, 0xf4, 0x39, 0x3c, 0x48, 0xa6,
-	0x65, 0xca, 0xc7, 0x4c, 0x62, 0x8c, 0x42, 0x14, 0xc2, 0x76, 0xdc, 0xc1, 0xc2, 0xfc, 0x9d, 0xb2,
-	0xd2, 0xbf, 0x3d, 0x03, 0xf1, 0x73, 0x99, 0xb0, 0xed, 0x75, 0xd9, 0x78, 0x09, 0x56, 0x37, 0x42,
-	0x23, 0x5b, 0xff, 0x5f, 0x64, 0xdb, 0xfd, 0xef, 0xb2, 0x0d, 0xda, 0xb2, 0x9d, 0xc1, 0xe3, 0x2e,
-	0x67, 0xab, 0x9b, 0x1a, 0x45, 0x8e, 0x5a, 0x66, 0x41, 0x7f, 0xb7, 0x22, 0x5d, 0x60, 0x8a, 0xef,
-	0x59, 0xa4, 0x65, 0xda, 0xbd, 0x77, 0xa3, 0x4d, 0x03, 0x43, 0xce, 0xcd, 0xd5, 0x90, 0xa3, 0xbf,
-	0x7a, 0xf0, 0xa1, 0x72, 0xbd, 0xe0, 0x79, 0xb2, 0x2d, 0x89, 0x45, 0x31, 0x77, 0xdc, 0x62, 0x86,
-	0xe0, 0x0b, 0x9c, 0x71, 0x3d, 0x37, 0x4d, 0x95, 0x17, 0x6b, 0x72, 0x04, 0xa3, 0x84, 0x0b, 0x1c,
-	0xeb, 0x43, 0xfa, 0xda, 0xd9, 0x18, 0xe8, 0xd7, 0xa6, 0x3b, 0x9b, 0xd4, 0x6c, 0x41, 0x3e, 0xb3,
-	0x93, 0xc3, 0x64, 0xf5, 0x41, 0xb7, 0xcf, 0xcd, 0x2c, 0xa1, 0xf3, 0x86, 0xd8, 0x0b, 0x9e, 0xfe,
-	0xef, 0xad, 0xbd, 0x81, 0x16, 0x9d, 0x35, 0x89, 0x9b, 0xa3, 0x6d, 0xe2, 0xab, 0x1e, 0xba, 0x43,
-	0x18, 0x65, 0x3c, 0xc3, 0x58, 0xce, 0x4b, 0xb4, 0xaf, 0x84, 0xaf, 0x0c, 0xaf, 0xe6, 0x25, 0xb6,
-	0xc6, 0x75, 0xaf, 0x35, 0xae, 0x17, 0x2f, 0x42, 0xbf, 0x79, 0x11, 0xe8, 0xf7, 0xa6, 0xcc, 0x97,
-	0x28, 0xbf, 0x49, 0x53, 0x25, 0xc5, 0x36, 0xd3, 0x9b, 0xc6, 0xf0, 0x64, 0x09, 0xed, 0x5d, 0x2a,
-	0x40, 0x8e, 0x61, 0x0f, 0xf3, 0x24, 0x2e, 0x6e, 0xcc, 0x40, 0xdf, 0xd1, 0xaf, 0xd1, 0x08, 0xf3,
-	0xe4, 0xc7, 0x1b, 0x15, 0x75, 0xfe, 0x67, 0x1f, 0xf6, 0xd4, 0x96, 0x97, 0x28, 0x66, 0x7c, 0x8c,
-	0xe4, 0x8d, 0xa9, 0x58, 0x67, 0xc4, 0x13, 0xea, 0xc2, 0xaf, 0x7e, 0x9d, 0xc2, 0x4f, 0x37, 0xc6,
-	0xd8, 0xbb, 0x7e, 0xef, 0x4b, 0x8f, 0x5c, 0xc1, 0xfd, 0xd6, 0x74, 0x24, 0x47, 0xee, 0xce, 0xee,
-	0x43, 0x10, 0x7e, 0xbc, 0xc6, 0x5b, 0x23, 0x9e, 0x7a, 0xe4, 0x25, 0x1c, 0xb4, 0x07, 0x07, 0x69,
-	0x6d, 0x5a, 0x1a, 0xa2, 0xe1, 0xf1, 0x3a, 0xb7, 0x03, 0xfa, 0x93, 0x01, 0x6d, 0x1a, 0xb6, 0x0d,
-	0xba, 0x34, 0x74, 0xda, 0xa0, 0x2b, 0xfa, 0xfc, 0x1e, 0xf9, 0x01, 0xf6, 0xdd, 0x6e, 0x22, 0x87,
-	0xee, 0x8e, 0x4e, 0xfb, 0x87, 0x47, 0xab, 0x9d, 0x8e, 0x90, 0x0e, 0x9c, 0xba, 0xe3, 0xcb, 0x70,
-	0x4e, 0xd3, 0x2d, 0xc3, 0xb9, 0x6d, 0xa1, 0xe1, 0x5e, 0x9b, 0xff, 0x37, 0xe7, 0xb2, 0x91, 0xe3,
-	0x4e, 0x4d, 0x3b, 0x77, 0x3a, 0xfc, 0x64, 0xad, 0xbf, 0xc1, 0x7d, 0x33, 0xd0, 0xff, 0x9d, 0xcf,
-	0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xbb, 0xf3, 0xde, 0x9b, 0x0a, 0x00, 0x00,
+func init() { proto.RegisterFile("wiki.proto", fileDescriptor15) }
+
+var fileDescriptor15 = []byte{
+	// 893 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x72, 0xdc, 0x44,
+	0x10, 0x8e, 0xbc, 0x7f, 0xda, 0xb6, 0xe3, 0x90, 0x21, 0x24, 0x8a, 0x6c, 0x8c, 0x6b, 0x48, 0x15,
+	0xe6, 0xe2, 0x82, 0xcd, 0x95, 0x43, 0x28, 0x8c, 0x7d, 0x81, 0xc2, 0x28, 0x21, 0x3e, 0xaa, 0x26,
+	0xab, 0xb6, 0x3d, 0x15, 0xfd, 0x31, 0x1a, 0xdb, 0xb5, 0x8f, 0x42, 0x15, 0x17, 0xae, 0x3c, 0x09,
+	0x67, 0xde, 0x82, 0x2b, 0x4f, 0x40, 0xcd, 0x8f, 0x56, 0x23, 0xad, 0xbc, 0x54, 0x30, 0x54, 0x71,
+	0xdb, 0xe9, 0x19, 0x7d, 0xd3, 0xdf, 0xd7, 0xd3, 0x5f, 0x2f, 0xc0, 0x0d, 0x7f, 0xcb, 0x0f, 0x4b,
+	0x51, 0xc8, 0x82, 0x8c, 0x2f, 0xb8, 0x64, 0xe9, 0x22, 0xdc, 0xaa, 0x2e, 0x99, 0xc0, 0xc4, 0x44,
+	0xe9, 0x19, 0x3c, 0x3c, 0xe3, 0x6f, 0xf9, 0x57, 0x45, 0x96, 0x71, 0x79, 0x84, 0x92, 0xf1, 0xb4,
+	0x22, 0x04, 0x86, 0x39, 0xcb, 0x30, 0xf0, 0xf6, 0xbd, 0x83, 0xad, 0x48, 0xff, 0x26, 0x8f, 0x60,
+	0x84, 0x19, 0xe3, 0x69, 0xb0, 0xa1, 0x83, 0x66, 0x41, 0x02, 0x98, 0x64, 0x58, 0x55, 0xec, 0x02,
+	0x83, 0x81, 0x8e, 0xd7, 0x4b, 0xfa, 0x0a, 0x1e, 0x28, 0xe0, 0x53, 0x76, 0x81, 0xaf, 0x51, 0x54,
+	0xbc, 0xc8, 0xc9, 0xa7, 0x30, 0x9e, 0xeb, 0x7b, 0x34, 0xf0, 0xe6, 0xec, 0xe1, 0xa1, 0x49, 0xe9,
+	0xf0, 0x84, 0x4b, 0x93, 0x40, 0x64, 0x0f, 0x90, 0xc7, 0x30, 0x3e, 0x2f, 0x44, 0xc6, 0xa4, 0xbe,
+	0x6e, 0x1a, 0xd9, 0x15, 0xfd, 0xc3, 0x03, 0xbf, 0x86, 0x25, 0x9f, 0xc3, 0xe4, 0xda, 0x40, 0x5b,
+	0xc0, 0x27, 0x35, 0x60, 0xe7, 0xe6, 0xa8, 0x3e, 0x77, 0x1b, 0xae, 0x62, 0x27, 0xb9, 0x4c, 0x6b,
+	0x16, 0x66, 0x41, 0x9e, 0x82, 0x7f, 0x25, 0xd2, 0xb8, 0x64, 0xf2, 0x32, 0x18, 0xea, 0xf3, 0x93,
+	0x2b, 0x91, 0x9e, 0x32, 0x79, 0xa9, 0x24, 0xd2, 0xe1, 0x91, 0x91, 0xa8, 0xb4, 0x31, 0x2d, 0xdb,
+	0xd8, 0x91, 0x6d, 0x0f, 0xe0, 0x92, 0x57, 0xb2, 0x10, 0x7c, 0xce, 0xd2, 0x60, 0xb2, 0xef, 0x1d,
+	0xf8, 0x91, 0x13, 0x51, 0x57, 0x08, 0x76, 0x13, 0x27, 0x4c, 0xb2, 0xc0, 0x37, 0x0a, 0x0a, 0x76,
+	0x73, 0xc4, 0x24, 0xa3, 0x3f, 0x7b, 0x10, 0x2a, 0x22, 0x27, 0x28, 0x1d, 0x2e, 0x55, 0x84, 0x3f,
+	0x5e, 0x61, 0x25, 0xc9, 0x0c, 0x40, 0x60, 0x59, 0x54, 0x5c, 0x16, 0x62, 0x61, 0x05, 0x20, 0xb5,
+	0x00, 0xd1, 0x72, 0x27, 0x72, 0x4e, 0x91, 0x1d, 0x98, 0x96, 0xec, 0x02, 0x0d, 0x23, 0x53, 0x48,
+	0x5f, 0x05, 0x1a, 0x4a, 0xb6, 0x90, 0xa3, 0x48, 0xff, 0x56, 0xe9, 0x95, 0x28, 0x62, 0x1d, 0x1f,
+	0xea, 0xf8, 0xa4, 0x44, 0xa1, 0xd2, 0xa1, 0x11, 0xec, 0xf4, 0x66, 0x57, 0x95, 0x45, 0x5e, 0x21,
+	0x79, 0x0e, 0xbe, 0x15, 0xbd, 0x0a, 0xbc, 0xfd, 0xc1, 0xba, 0xea, 0x2c, 0x0f, 0xd2, 0xdf, 0x3d,
+	0x78, 0xa4, 0x76, 0xcf, 0x04, 0x97, 0xa8, 0x8e, 0xdc, 0x85, 0x6c, 0x5d, 0x8e, 0x0d, 0xa7, 0x1c,
+	0x4d, 0xfd, 0x07, 0xad, 0xfa, 0xbf, 0x80, 0x6d, 0xf3, 0xf2, 0xe2, 0xc4, 0xf4, 0x80, 0x66, 0xbb,
+	0x39, 0x7b, 0xea, 0xe6, 0xdc, 0x6a, 0x92, 0xe8, 0xfe, 0xbc, 0xd5, 0x33, 0x01, 0x4c, 0xe6, 0x45,
+	0x2e, 0x31, 0x97, 0xf6, 0x4d, 0xd4, 0x4b, 0xfa, 0x02, 0x3e, 0xe8, 0x70, 0xb2, 0x12, 0x7d, 0x02,
+	0x0f, 0x92, 0xab, 0x32, 0xe5, 0x73, 0x26, 0x31, 0x46, 0x21, 0x0a, 0x61, 0x3b, 0x6e, 0x7b, 0x19,
+	0xfe, 0x5a, 0x45, 0xe9, 0x9f, 0x9e, 0x81, 0xf8, 0xa1, 0x4c, 0xd8, 0xdd, 0x75, 0x59, 0xfb, 0x08,
+	0xfa, 0x1b, 0xa1, 0x91, 0x6d, 0xf8, 0x37, 0xb2, 0x8d, 0xfe, 0xb9, 0x6c, 0xe3, 0xb6, 0x6c, 0x87,
+	0xf0, 0xb8, 0xcb, 0xd9, 0xea, 0xa6, 0xac, 0xc8, 0x51, 0xcb, 0x2c, 0xe8, 0xaf, 0x56, 0xa4, 0x23,
+	0x4c, 0xf1, 0x3f, 0x16, 0x69, 0x95, 0xf6, 0xe0, 0xdd, 0x68, 0xd3, 0xc0, 0x90, 0x73, 0x73, 0x35,
+	0xe4, 0xe8, 0x4f, 0x1e, 0xbc, 0xaf, 0xb6, 0x8e, 0x79, 0x9e, 0xdc, 0x95, 0xc4, 0xb2, 0x98, 0x1b,
+	0x6e, 0x31, 0x43, 0xf0, 0x05, 0x5e, 0x73, 0xed, 0x9b, 0xa6, 0xca, 0xcb, 0x35, 0xd9, 0x85, 0x69,
+	0xc2, 0x05, 0xce, 0xf5, 0x25, 0x43, 0xbd, 0xd9, 0x04, 0xe8, 0x17, 0xa6, 0x3b, 0x9b, 0xd4, 0x6c,
+	0x41, 0x9e, 0x59, 0xe7, 0x30, 0x59, 0xbd, 0xd7, 0xed, 0x73, 0xe3, 0x25, 0x74, 0xd1, 0x10, 0x3b,
+	0xe6, 0xe9, 0xbf, 0xde, 0xda, 0x6b, 0x68, 0xd1, 0xeb, 0x26, 0x71, 0x73, 0xb5, 0x4d, 0xbc, 0x6f,
+	0xd0, 0xed, 0xc0, 0x34, 0xe3, 0x19, 0xc6, 0x72, 0x51, 0xa2, 0x9d, 0x12, 0xbe, 0x0a, 0xbc, 0x5a,
+	0x94, 0xd8, 0xb2, 0xeb, 0x41, 0xcb, 0xae, 0x97, 0x13, 0x61, 0xd8, 0x4c, 0x04, 0xfa, 0x8d, 0x29,
+	0xf3, 0x09, 0xca, 0x2f, 0xd3, 0x54, 0x49, 0x71, 0x17, 0xf7, 0xa6, 0x31, 0x3c, 0x59, 0x41, 0x7b,
+	0x97, 0x0a, 0x90, 0x3d, 0xd8, 0xc4, 0x3c, 0x89, 0x8b, 0x73, 0x63, 0xe8, 0x1b, 0x7a, 0x1a, 0x4d,
+	0x31, 0x4f, 0xbe, 0x3b, 0xd7, 0x96, 0xfe, 0x8b, 0xb7, 0xf4, 0xf4, 0x63, 0xdd, 0xe0, 0x12, 0x13,
+	0xc5, 0xed, 0xff, 0xf4, 0x06, 0x67, 0xb0, 0xdb, 0x9f, 0x62, 0x53, 0x52, 0x5d, 0x1d, 0x5b, 0x52,
+	0xf5, 0x7b, 0xf6, 0xdb, 0x08, 0x36, 0xd5, 0x47, 0x2f, 0x51, 0x5c, 0xf3, 0x39, 0x92, 0x37, 0xe6,
+	0x25, 0x76, 0x46, 0x17, 0xa1, 0xae, 0x6c, 0xfd, 0x53, 0x37, 0xfc, 0x78, 0xed, 0x19, 0xdb, 0xc3,
+	0xf7, 0x3e, 0xf3, 0xc8, 0x29, 0xdc, 0x6f, 0xb9, 0x3e, 0xd9, 0x75, 0xbf, 0xec, 0x0e, 0xb8, 0xf0,
+	0xc3, 0x5b, 0x76, 0x6b, 0xc4, 0x03, 0x8f, 0xbc, 0x84, 0xed, 0xb6, 0x21, 0x92, 0xd6, 0x47, 0x2b,
+	0xc3, 0x21, 0xdc, 0xbb, 0x6d, 0xdb, 0x01, 0xfd, 0xde, 0x80, 0x36, 0x46, 0xd4, 0x06, 0x5d, 0x31,
+	0xd3, 0x36, 0x68, 0x8f, 0x7f, 0xdd, 0x23, 0xdf, 0xc2, 0x96, 0xeb, 0x12, 0x64, 0xc7, 0xfd, 0xa2,
+	0x63, 0x6b, 0xe1, 0x6e, 0xff, 0xa6, 0x23, 0xa4, 0x03, 0xa7, 0x7a, 0x77, 0x15, 0xce, 0x31, 0x93,
+	0x55, 0x38, 0xb7, 0xdd, 0x35, 0xdc, 0x6b, 0xf3, 0xbf, 0xd4, 0x69, 0x22, 0xb2, 0xd7, 0xa9, 0x69,
+	0xa7, 0x57, 0xc3, 0x8f, 0x6e, 0xdd, 0x77, 0x70, 0xd1, 0x58, 0x4c, 0xf7, 0x5d, 0x92, 0xee, 0x83,
+	0xe9, 0x6b, 0xac, 0xf0, 0xd9, 0xfa, 0x43, 0xcd, 0x35, 0x6f, 0xc6, 0xfa, 0x6f, 0xfb, 0xf3, 0xbf,
+	0x02, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x50, 0x3d, 0x3a, 0xda, 0x0b, 0x00, 0x00,
 }

go/vendor/gitlab.com/gitlab-org/gitaly/client/upload_archive.go

+package client
+
+import (
+	"io"
+
+	"gitlab.com/gitlab-org/gitaly/streamio"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+)
+
+// UploadArchive proxies an SSH git-upload-archive (git archive --remote) session to Gitaly
+func UploadArchive(ctx context.Context, conn *grpc.ClientConn, stdin io.Reader, stdout, stderr io.Writer, req *pb.SSHUploadArchiveRequest) (int32, error) {
+	ctx2, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	ssh := pb.NewSSHServiceClient(conn)
+	stream, err := ssh.SSHUploadArchive(ctx2)
+	if err != nil {
+		return 0, err
+	}
+
+	if err = stream.Send(req); err != nil {
+		return 0, err
+	}
+
+	inWriter := streamio.NewWriter(func(p []byte) error {
+		return stream.Send(&pb.SSHUploadArchiveRequest{Stdin: p})
+	})
+
+	return streamHandler(func() (stdoutStderrResponse, error) {
+		return stream.Recv()
+	}, func(errC chan error) {
+		_, errRecv := io.Copy(inWriter, stdin)
+		stream.CloseSend()
+		errC <- errRecv
+	}, stdout, stderr)
+}

go/vendor/vendor.json

@@ -41,13 +41,13 @@
 			"versionExact": "v1.0.5"
 		},
 		{
-			"checksumSHA1": "8Gc1ZcO7WxXstNzyePjwG90SBSU=",
+			"checksumSHA1": "EuiW0GPDEqCG0UhnE7zYCrc6/G0=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "f62abc80cb25363bf51a4f89f02654ca2f722dc8",
-			"revisionTime": "2018-01-17T16:23:27Z",
+			"revision": "4d256c2c6403d420c598c1649b1d26fa4384bb1d",
+			"revisionTime": "2018-03-08T23:20:01Z",
 			"tree": true,
-			"version": "v0.75.0",
-			"versionExact": "v0.75.0"
+			"version": "v0.89.0",
+			"versionExact": "v0.89.0"
 		},
 		{
 			"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",
@@ -58,12 +58,12 @@
 			"versionExact": "v0.71.0"
 		},
 		{
-			"checksumSHA1": "s53Qjro9ZHX0DV2tCYQXLO2FHqI=",
+			"checksumSHA1": "CsPKG7r/N8ARlHtnHKimJiOnYiY=",
 			"path": "gitlab.com/gitlab-org/gitaly/client",
-			"revision": "95a198aef54c42fd8e84c62acc63f0cd620864b3",
-			"revisionTime": "2018-01-18T11:33:00Z",
-			"version": "v0.71.0",
-			"versionExact": "v0.71.0"
+			"revision": "5e2c70a9a670f5d675cf45f880bbbb08a5169ab8",
+			"revisionTime": "2018-03-13T20:33:04Z",
+			"version": "v0.90.0",
+			"versionExact": "v0.90.0"
 		},
 		{
 			"checksumSHA1": "mifcYH0qXpoPkX5KzXoM3mterWQ=",

lib/gitlab_shell.rb

@@ -12,6 +12,7 @@ class GitlabShell # rubocop:disable Metrics/ClassLength
   GIT_COMMANDS = %w(git-upload-pack git-receive-pack git-upload-archive git-lfs-authenticate).freeze
   GITALY_MIGRATED_COMMANDS = {
     'git-upload-pack' => File.join(ROOT_PATH, 'bin', 'gitaly-upload-pack'),
+    'git-upload-archive' => File.join(ROOT_PATH, 'bin', 'gitaly-upload-archive'),
     'git-receive-pack' => File.join(ROOT_PATH, 'bin', 'gitaly-receive-pack')
   }.freeze
   API_COMMANDS = %w(2fa_recovery_codes).freeze

spec/gitlab_shell_spec.rb

@@ -252,6 +252,61 @@ describe GitlabShell do
       end
     end
 
+    shared_examples_for 'upload-archive' do |command|
+      let(:ssh_cmd) { "#{command} gitlab-ci.git" }
+      let(:exec_cmd_params) { ['git-upload-archive', repo_path] }
+      let(:exec_cmd_log_params) { exec_cmd_params }
+
+      after { subject.exec(ssh_cmd) }
+
+      it "should process the command" do
+        subject.should_receive(:process_cmd).with(%W(git-upload-archive gitlab-ci.git))
+      end
+
+      it "should execute the command" do
+        subject.should_receive(:exec_cmd).with(*exec_cmd_params)
+      end
+
+      it "should log the command execution" do
+        message = "executing git command"
+        user_string = "user with key #{key_id}"
+        $logger.should_receive(:info).with(message, command: exec_cmd_log_params.join(' '), user: user_string)
+      end
+
+      it "should use usernames if configured to do so" do
+        GitlabConfig.any_instance.stub(audit_usernames: true)
+        $logger.should_receive(:info).with("executing git command", hash_including(user: 'John Doe'))
+      end
+    end
+
+    context 'git-upload-archive' do
+      it_behaves_like 'upload-archive', 'git-upload-archive'
+    end
+
+    context 'git upload-archive' do
+      it_behaves_like 'upload-archive', 'git upload-archive'
+    end
+
+    context 'gitaly-upload-archive' do
+      before do
+        api.stub(check_access: gitaly_check_access)
+      end
+
+      it_behaves_like 'upload-archive', 'git-upload-archive' do
+        let(:gitaly_executable) { "gitaly-upload-archive" }
+        let(:exec_cmd_params) do
+          [
+            File.join(ROOT_PATH, "bin", gitaly_executable),
+            'unix:gitaly.socket',
+            gitaly_message
+          ]
+        end
+        let(:exec_cmd_log_params) do
+          [gitaly_executable, 'unix:gitaly.socket', gitaly_message]
+        end
+      end
+    end
+
     context 'arbitrary command' do
       let(:ssh_cmd) { 'arbitrary command' }
       after { subject.exec(ssh_cmd) }