update gitaly-proto

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

-0.9.0
+0.14.0

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

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

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

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

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

@@ -24,7 +24,7 @@ type PostReceiveRequest struct {
 func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
 func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostReceiveRequest) ProtoMessage()               {}
-func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
 
 func (m *PostReceiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -39,7 +39,7 @@ type PostReceiveResponse struct {
 func (m *PostReceiveResponse) Reset()                    { *m = PostReceiveResponse{} }
 func (m *PostReceiveResponse) String() string            { return proto.CompactTextString(m) }
 func (*PostReceiveResponse) ProtoMessage()               {}
-func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
 
 func init() {
 	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
@@ -54,74 +54,74 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Notifications service
+// Client API for NotificationService service
 
-type NotificationsClient interface {
+type NotificationServiceClient interface {
 	PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error)
 }
 
-type notificationsClient struct {
+type notificationServiceClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient {
-	return &notificationsClient{cc}
+func NewNotificationServiceClient(cc *grpc.ClientConn) NotificationServiceClient {
+	return &notificationServiceClient{cc}
 }
 
-func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
+func (c *notificationServiceClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
 	out := new(PostReceiveResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...)
+	err := grpc.Invoke(ctx, "/gitaly.NotificationService/PostReceive", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-// Server API for Notifications service
+// Server API for NotificationService service
 
-type NotificationsServer interface {
+type NotificationServiceServer interface {
 	PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error)
 }
 
-func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) {
-	s.RegisterService(&_Notifications_serviceDesc, srv)
+func RegisterNotificationServiceServer(s *grpc.Server, srv NotificationServiceServer) {
+	s.RegisterService(&_NotificationService_serviceDesc, srv)
 }
 
-func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _NotificationService_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(PostReceiveRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(NotificationsServer).PostReceive(ctx, in)
+		return srv.(NotificationServiceServer).PostReceive(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/gitaly.Notifications/PostReceive",
+		FullMethod: "/gitaly.NotificationService/PostReceive",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest))
+		return srv.(NotificationServiceServer).PostReceive(ctx, req.(*PostReceiveRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-var _Notifications_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Notifications",
-	HandlerType: (*NotificationsServer)(nil),
+var _NotificationService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.NotificationService",
+	HandlerType: (*NotificationServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "PostReceive",
-			Handler:    _Notifications_PostReceive_Handler,
+			Handler:    _NotificationService_PostReceive_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "notifications.proto",
 }
 
-func init() { proto.RegisterFile("notifications.proto", fileDescriptor2) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor4) }
 
-var fileDescriptor2 = []byte{
-	// 163 bytes of a gzipped FileDescriptorProto
+var fileDescriptor4 = []byte{
+	// 170 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9,
 	0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
 	0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81,
@@ -129,8 +129,8 @@ var fileDescriptor2 = []byte{
 	0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
 	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x0c,
 	0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x52, 0x12, 0xe5, 0x12, 0x46, 0x31, 0xa9, 0xb8, 0x20,
-	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x92, 0x8b, 0xd7, 0x0f, 0xd9, 0x35, 0x42, 0x1e, 0x5c, 0xdc, 0x48,
-	0xea, 0x84, 0xa4, 0x60, 0xc6, 0x62, 0x3a, 0x43, 0x4a, 0x1a, 0xab, 0x1c, 0xc4, 0x60, 0x25, 0x86,
-	0x24, 0x36, 0xb0, 0x17, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x5e, 0x1f, 0x64, 0xef,
-	0x00, 0x00, 0x00,
+	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x9e, 0x4b, 0xd8, 0x0f, 0xc9, 0x35, 0xc1, 0xa9, 0x45, 0x65, 0x99,
+	0xc9, 0xa9, 0x42, 0x1e, 0x5c, 0xdc, 0x48, 0xaa, 0x85, 0xa4, 0x60, 0x86, 0x63, 0x3a, 0x46, 0x4a,
+	0x1a, 0xab, 0x1c, 0xc4, 0x78, 0x25, 0x86, 0x24, 0x36, 0xb0, 0x47, 0x8c, 0x01, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x98, 0xea, 0xcc, 0xff, 0xf5, 0x00, 0x00, 0x00,
 }

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

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

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

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

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

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

go/vendor/vendor.json

@@ -21,13 +21,13 @@
 			"revisionTime": "2017-03-31T03:19:02Z"
 		},
 		{
-			"checksumSHA1": "guPHQjm2kqtHM03hF2rss9K6YR8=",
+			"checksumSHA1": "FPNHA80Wu9QTcNcjbuw0kdLOg5Q=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "e302a46f7ccd889bfaa683d2ba06ffe06ca5875b",
-			"revisionTime": "2017-06-12T18:49:50Z",
+			"revision": "e73c809c669748d0f49e257a249c4c12b59f7968",
+			"revisionTime": "2017-07-07T12:10:40Z",
 			"tree": true,
-			"version": "v0.9.0",
-			"versionExact": "v0.9.0"
+			"version": "v0.14.0",
+			"versionExact": "v0.14.0"
 		},
 		{
 			"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",