Update gitaly-proto and gitaly libs

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

@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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

-0.23.0
+0.75.0

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

@@ -7,18 +7,28 @@ Package gitaly is a generated protocol buffer package.
 It is generated from these files:
 	blob.proto
 	commit.proto
+	conflicts.proto
 	deprecated-services.proto
 	diff.proto
+	namespace.proto
 	notifications.proto
+	operations.proto
 	ref.proto
+	remote.proto
 	repository-service.proto
 	shared.proto
 	smarthttp.proto
 	ssh.proto
+	wiki.proto
 
 It has these top-level messages:
 	GetBlobRequest
 	GetBlobResponse
+	GetBlobsRequest
+	GetBlobsResponse
+	LFSPointer
+	GetLFSPointersRequest
+	GetLFSPointersResponse
 	CommitStatsRequest
 	CommitStatsResponse
 	CommitIsAncestorRequest
@@ -36,19 +46,76 @@ It has these top-level messages:
 	ListFilesResponse
 	FindCommitRequest
 	FindCommitResponse
+	ListCommitsByOidRequest
+	ListCommitsByOidResponse
 	FindAllCommitsRequest
 	FindAllCommitsResponse
+	FindCommitsRequest
+	FindCommitsResponse
 	CommitLanguagesRequest
 	CommitLanguagesResponse
 	RawBlameRequest
 	RawBlameResponse
+	LastCommitForPathRequest
+	LastCommitForPathResponse
+	CommitsByMessageRequest
+	CommitsByMessageResponse
+	FilterShasWithSignaturesRequest
+	FilterShasWithSignaturesResponse
+	ExtractCommitSignatureRequest
+	ExtractCommitSignatureResponse
+	ListConflictFilesRequest
+	ConflictFileHeader
+	ConflictFile
+	ListConflictFilesResponse
+	ResolveConflictsRequestHeader
+	ResolveConflictsRequest
+	ResolveConflictsResponse
 	CommitDiffRequest
 	CommitDiffResponse
 	CommitDeltaRequest
 	CommitDelta
 	CommitDeltaResponse
+	CommitPatchRequest
+	CommitPatchResponse
+	RawDiffRequest
+	RawDiffResponse
+	RawPatchRequest
+	RawPatchResponse
+	AddNamespaceRequest
+	RemoveNamespaceRequest
+	RenameNamespaceRequest
+	NamespaceExistsRequest
+	NamespaceExistsResponse
+	AddNamespaceResponse
+	RemoveNamespaceResponse
+	RenameNamespaceResponse
 	PostReceiveRequest
 	PostReceiveResponse
+	UserCreateBranchRequest
+	UserCreateBranchResponse
+	UserDeleteBranchRequest
+	UserDeleteBranchResponse
+	UserDeleteTagRequest
+	UserDeleteTagResponse
+	UserCreateTagRequest
+	UserCreateTagResponse
+	UserMergeBranchRequest
+	UserMergeBranchResponse
+	OperationBranchUpdate
+	UserFFBranchRequest
+	UserFFBranchResponse
+	UserCherryPickRequest
+	UserCherryPickResponse
+	UserRevertRequest
+	UserRevertResponse
+	UserCommitFilesActionHeader
+	UserCommitFilesAction
+	UserCommitFilesRequestHeader
+	UserCommitFilesRequest
+	UserCommitFilesResponse
+	UserRebaseRequest
+	UserRebaseResponse
 	FindDefaultBranchNameRequest
 	FindDefaultBranchNameResponse
 	FindAllBranchNamesRequest
@@ -65,18 +132,71 @@ It has these top-level messages:
 	FindAllBranchesResponse
 	FindAllTagsRequest
 	FindAllTagsResponse
+	RefExistsRequest
+	RefExistsResponse
+	CreateBranchRequest
+	CreateBranchResponse
+	DeleteBranchRequest
+	DeleteBranchResponse
+	FindBranchRequest
+	FindBranchResponse
+	DeleteRefsRequest
+	DeleteRefsResponse
+	ListBranchNamesContainingCommitRequest
+	ListBranchNamesContainingCommitResponse
+	ListTagNamesContainingCommitRequest
+	ListTagNamesContainingCommitResponse
+	AddRemoteRequest
+	AddRemoteResponse
+	RemoveRemoteRequest
+	RemoveRemoteResponse
+	FetchInternalRemoteRequest
+	FetchInternalRemoteResponse
+	UpdateRemoteMirrorRequest
+	UpdateRemoteMirrorResponse
 	RepositoryExistsRequest
 	RepositoryExistsResponse
+	RepositoryIsEmptyRequest
+	RepositoryIsEmptyResponse
 	RepackIncrementalRequest
 	RepackIncrementalResponse
 	RepackFullRequest
 	RepackFullResponse
 	GarbageCollectRequest
 	GarbageCollectResponse
+	RepositorySizeRequest
+	RepositorySizeResponse
+	ApplyGitattributesRequest
+	ApplyGitattributesResponse
+	FetchRemoteRequest
+	FetchRemoteResponse
+	CreateRepositoryRequest
+	CreateRepositoryResponse
+	GetArchiveRequest
+	GetArchiveResponse
+	HasLocalBranchesRequest
+	HasLocalBranchesResponse
+	FetchSourceBranchRequest
+	FetchSourceBranchResponse
+	FsckRequest
+	FsckResponse
+	WriteRefRequest
+	WriteRefResponse
+	FindMergeBaseRequest
+	FindMergeBaseResponse
+	CreateForkRequest
+	CreateForkResponse
+	IsRebaseInProgressRequest
+	IsRebaseInProgressResponse
+	CreateRepositoryFromURLRequest
+	CreateRepositoryFromURLResponse
 	Repository
 	GitCommit
 	CommitAuthor
 	ExitStatus
+	Branch
+	Tag
+	User
 	InfoRefsRequest
 	InfoRefsResponse
 	PostUploadPackRequest
@@ -87,6 +207,23 @@ It has these top-level messages:
 	SSHUploadPackResponse
 	SSHReceivePackRequest
 	SSHReceivePackResponse
+	WikiCommitDetails
+	WikiPageVersion
+	WikiPage
+	WikiGetPageVersionsRequest
+	WikiGetPageVersionsResponse
+	WikiWritePageRequest
+	WikiWritePageResponse
+	WikiUpdatePageRequest
+	WikiUpdatePageResponse
+	WikiDeletePageRequest
+	WikiDeletePageResponse
+	WikiFindPageRequest
+	WikiFindPageResponse
+	WikiFindFileRequest
+	WikiFindFileResponse
+	WikiGetAllPagesRequest
+	WikiGetAllPagesResponse
 */
 package gitaly
 
@@ -179,9 +316,155 @@ func (m *GetBlobResponse) GetOid() string {
 	return ""
 }
 
+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"`
+	// 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"`
+}
+
+func (m *GetBlobsRequest) Reset()                    { *m = GetBlobsRequest{} }
+func (m *GetBlobsRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobsRequest) ProtoMessage()               {}
+func (*GetBlobsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *GetBlobsRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetBlobsRequest) GetOids() []string {
+	if m != nil {
+		return m.Oids
+	}
+	return nil
+}
+
+func (m *GetBlobsRequest) GetLimit() int64 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
+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
+	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"`
+}
+
+func (m *GetBlobsResponse) Reset()                    { *m = GetBlobsResponse{} }
+func (m *GetBlobsResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobsResponse) ProtoMessage()               {}
+func (*GetBlobsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *GetBlobsResponse) GetSize() int64 {
+	if m != nil {
+		return m.Size
+	}
+	return 0
+}
+
+func (m *GetBlobsResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *GetBlobsResponse) GetOid() string {
+	if m != nil {
+		return m.Oid
+	}
+	return ""
+}
+
+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"`
+	Oid  string `protobuf:"bytes,3,opt,name=oid" json:"oid,omitempty"`
+}
+
+func (m *LFSPointer) Reset()                    { *m = LFSPointer{} }
+func (m *LFSPointer) String() string            { return proto.CompactTextString(m) }
+func (*LFSPointer) ProtoMessage()               {}
+func (*LFSPointer) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *LFSPointer) GetSize() int64 {
+	if m != nil {
+		return m.Size
+	}
+	return 0
+}
+
+func (m *LFSPointer) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *LFSPointer) GetOid() string {
+	if m != nil {
+		return m.Oid
+	}
+	return ""
+}
+
+type GetLFSPointersRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	BlobIds    []string    `protobuf:"bytes,2,rep,name=blob_ids,json=blobIds" json:"blob_ids,omitempty"`
+}
+
+func (m *GetLFSPointersRequest) Reset()                    { *m = GetLFSPointersRequest{} }
+func (m *GetLFSPointersRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetLFSPointersRequest) ProtoMessage()               {}
+func (*GetLFSPointersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *GetLFSPointersRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetLFSPointersRequest) GetBlobIds() []string {
+	if m != nil {
+		return m.BlobIds
+	}
+	return nil
+}
+
+type GetLFSPointersResponse struct {
+	LfsPointers []*LFSPointer `protobuf:"bytes,1,rep,name=lfs_pointers,json=lfsPointers" json:"lfs_pointers,omitempty"`
+}
+
+func (m *GetLFSPointersResponse) Reset()                    { *m = GetLFSPointersResponse{} }
+func (m *GetLFSPointersResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetLFSPointersResponse) ProtoMessage()               {}
+func (*GetLFSPointersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *GetLFSPointersResponse) 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((*GetBlobsResponse)(nil), "gitaly.GetBlobsResponse")
+	proto.RegisterType((*LFSPointer)(nil), "gitaly.LFSPointer")
+	proto.RegisterType((*GetLFSPointersRequest)(nil), "gitaly.GetLFSPointersRequest")
+	proto.RegisterType((*GetLFSPointersResponse)(nil), "gitaly.GetLFSPointersResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -199,6 +482,12 @@ 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)
 }
 
 type blobServiceClient struct {
@@ -241,6 +530,70 @@ func (x *blobServiceGetBlobClient) Recv() (*GetBlobResponse, error) {
 	return m, nil
 }
 
+func (c *blobServiceClient) GetBlobs(ctx context.Context, in *GetBlobsRequest, opts ...grpc.CallOption) (BlobService_GetBlobsClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[1], c.cc, "/gitaly.BlobService/GetBlobs", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &blobServiceGetBlobsClient{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_GetBlobsClient interface {
+	Recv() (*GetBlobsResponse, error)
+	grpc.ClientStream
+}
+
+type blobServiceGetBlobsClient struct {
+	grpc.ClientStream
+}
+
+func (x *blobServiceGetBlobsClient) Recv() (*GetBlobsResponse, error) {
+	m := new(GetBlobsResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *blobServiceClient) GetLFSPointers(ctx context.Context, in *GetLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetLFSPointersClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[2], c.cc, "/gitaly.BlobService/GetLFSPointers", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &blobServiceGetLFSPointersClient{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_GetLFSPointersClient interface {
+	Recv() (*GetLFSPointersResponse, error)
+	grpc.ClientStream
+}
+
+type blobServiceGetLFSPointersClient struct {
+	grpc.ClientStream
+}
+
+func (x *blobServiceGetLFSPointersClient) Recv() (*GetLFSPointersResponse, error) {
+	m := new(GetLFSPointersResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for BlobService service
 
 type BlobServiceServer interface {
@@ -248,6 +601,12 @@ 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
 }
 
 func RegisterBlobServiceServer(s *grpc.Server, srv BlobServiceServer) {
@@ -275,6 +634,48 @@ func (x *blobServiceGetBlobServer) Send(m *GetBlobResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
+func _BlobService_GetBlobs_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetBlobsRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(BlobServiceServer).GetBlobs(m, &blobServiceGetBlobsServer{stream})
+}
+
+type BlobService_GetBlobsServer interface {
+	Send(*GetBlobsResponse) error
+	grpc.ServerStream
+}
+
+type blobServiceGetBlobsServer struct {
+	grpc.ServerStream
+}
+
+func (x *blobServiceGetBlobsServer) Send(m *GetBlobsResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _BlobService_GetLFSPointers_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetLFSPointersRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(BlobServiceServer).GetLFSPointers(m, &blobServiceGetLFSPointersServer{stream})
+}
+
+type BlobService_GetLFSPointersServer interface {
+	Send(*GetLFSPointersResponse) error
+	grpc.ServerStream
+}
+
+type blobServiceGetLFSPointersServer struct {
+	grpc.ServerStream
+}
+
+func (x *blobServiceGetLFSPointersServer) Send(m *GetLFSPointersResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _BlobService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.BlobService",
 	HandlerType: (*BlobServiceServer)(nil),
@@ -285,6 +686,16 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _BlobService_GetBlob_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "GetBlobs",
+			Handler:       _BlobService_GetBlobs_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "GetLFSPointers",
+			Handler:       _BlobService_GetLFSPointers_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "blob.proto",
 }
@@ -292,19 +703,28 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
 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,
+	// 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,
 }

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

@@ -1105,9 +1105,9 @@ var _SSH_serviceDesc = grpc.ServiceDesc{
 	Metadata: "deprecated-services.proto",
 }
 
-func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor2) }
+func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor3) }
 
-var fileDescriptor2 = []byte{
+var fileDescriptor3 = []byte{
 	// 534 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40,
 	0x10, 0x80, 0x31, 0x41, 0x91, 0x32, 0xa1, 0x0d, 0x6c, 0x85, 0x68, 0x0c, 0x4d, 0xda, 0x0a, 0x24,

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

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: namespace.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 AddNamespaceRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	Name        string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *AddNamespaceRequest) Reset()                    { *m = AddNamespaceRequest{} }
+func (m *AddNamespaceRequest) String() string            { return proto.CompactTextString(m) }
+func (*AddNamespaceRequest) ProtoMessage()               {}
+func (*AddNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
+
+func (m *AddNamespaceRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *AddNamespaceRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type RemoveNamespaceRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	Name        string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *RemoveNamespaceRequest) Reset()                    { *m = RemoveNamespaceRequest{} }
+func (m *RemoveNamespaceRequest) String() string            { return proto.CompactTextString(m) }
+func (*RemoveNamespaceRequest) ProtoMessage()               {}
+func (*RemoveNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
+
+func (m *RemoveNamespaceRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *RemoveNamespaceRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type RenameNamespaceRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	From        string `protobuf:"bytes,2,opt,name=from" json:"from,omitempty"`
+	To          string `protobuf:"bytes,3,opt,name=to" json:"to,omitempty"`
+}
+
+func (m *RenameNamespaceRequest) Reset()                    { *m = RenameNamespaceRequest{} }
+func (m *RenameNamespaceRequest) String() string            { return proto.CompactTextString(m) }
+func (*RenameNamespaceRequest) ProtoMessage()               {}
+func (*RenameNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
+
+func (m *RenameNamespaceRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *RenameNamespaceRequest) GetFrom() string {
+	if m != nil {
+		return m.From
+	}
+	return ""
+}
+
+func (m *RenameNamespaceRequest) GetTo() string {
+	if m != nil {
+		return m.To
+	}
+	return ""
+}
+
+type NamespaceExistsRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	Name        string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *NamespaceExistsRequest) Reset()                    { *m = NamespaceExistsRequest{} }
+func (m *NamespaceExistsRequest) String() string            { return proto.CompactTextString(m) }
+func (*NamespaceExistsRequest) ProtoMessage()               {}
+func (*NamespaceExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
+
+func (m *NamespaceExistsRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *NamespaceExistsRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type NamespaceExistsResponse struct {
+	Exists bool `protobuf:"varint,1,opt,name=exists" json:"exists,omitempty"`
+}
+
+func (m *NamespaceExistsResponse) Reset()                    { *m = NamespaceExistsResponse{} }
+func (m *NamespaceExistsResponse) String() string            { return proto.CompactTextString(m) }
+func (*NamespaceExistsResponse) ProtoMessage()               {}
+func (*NamespaceExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
+
+func (m *NamespaceExistsResponse) GetExists() bool {
+	if m != nil {
+		return m.Exists
+	}
+	return false
+}
+
+type AddNamespaceResponse struct {
+}
+
+func (m *AddNamespaceResponse) Reset()                    { *m = AddNamespaceResponse{} }
+func (m *AddNamespaceResponse) String() string            { return proto.CompactTextString(m) }
+func (*AddNamespaceResponse) ProtoMessage()               {}
+func (*AddNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
+
+type RemoveNamespaceResponse struct {
+}
+
+func (m *RemoveNamespaceResponse) Reset()                    { *m = RemoveNamespaceResponse{} }
+func (m *RemoveNamespaceResponse) String() string            { return proto.CompactTextString(m) }
+func (*RemoveNamespaceResponse) ProtoMessage()               {}
+func (*RemoveNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
+
+type RenameNamespaceResponse struct {
+}
+
+func (m *RenameNamespaceResponse) Reset()                    { *m = RenameNamespaceResponse{} }
+func (m *RenameNamespaceResponse) String() string            { return proto.CompactTextString(m) }
+func (*RenameNamespaceResponse) ProtoMessage()               {}
+func (*RenameNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
+
+func init() {
+	proto.RegisterType((*AddNamespaceRequest)(nil), "gitaly.AddNamespaceRequest")
+	proto.RegisterType((*RemoveNamespaceRequest)(nil), "gitaly.RemoveNamespaceRequest")
+	proto.RegisterType((*RenameNamespaceRequest)(nil), "gitaly.RenameNamespaceRequest")
+	proto.RegisterType((*NamespaceExistsRequest)(nil), "gitaly.NamespaceExistsRequest")
+	proto.RegisterType((*NamespaceExistsResponse)(nil), "gitaly.NamespaceExistsResponse")
+	proto.RegisterType((*AddNamespaceResponse)(nil), "gitaly.AddNamespaceResponse")
+	proto.RegisterType((*RemoveNamespaceResponse)(nil), "gitaly.RemoveNamespaceResponse")
+	proto.RegisterType((*RenameNamespaceResponse)(nil), "gitaly.RenameNamespaceResponse")
+}
+
+// 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 NamespaceService service
+
+type NamespaceServiceClient interface {
+	AddNamespace(ctx context.Context, in *AddNamespaceRequest, opts ...grpc.CallOption) (*AddNamespaceResponse, error)
+	RemoveNamespace(ctx context.Context, in *RemoveNamespaceRequest, opts ...grpc.CallOption) (*RemoveNamespaceResponse, error)
+	RenameNamespace(ctx context.Context, in *RenameNamespaceRequest, opts ...grpc.CallOption) (*RenameNamespaceResponse, error)
+	NamespaceExists(ctx context.Context, in *NamespaceExistsRequest, opts ...grpc.CallOption) (*NamespaceExistsResponse, error)
+}
+
+type namespaceServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewNamespaceServiceClient(cc *grpc.ClientConn) NamespaceServiceClient {
+	return &namespaceServiceClient{cc}
+}
+
+func (c *namespaceServiceClient) AddNamespace(ctx context.Context, in *AddNamespaceRequest, opts ...grpc.CallOption) (*AddNamespaceResponse, error) {
+	out := new(AddNamespaceResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/AddNamespace", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *namespaceServiceClient) RemoveNamespace(ctx context.Context, in *RemoveNamespaceRequest, opts ...grpc.CallOption) (*RemoveNamespaceResponse, error) {
+	out := new(RemoveNamespaceResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/RemoveNamespace", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *namespaceServiceClient) RenameNamespace(ctx context.Context, in *RenameNamespaceRequest, opts ...grpc.CallOption) (*RenameNamespaceResponse, error) {
+	out := new(RenameNamespaceResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/RenameNamespace", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *namespaceServiceClient) NamespaceExists(ctx context.Context, in *NamespaceExistsRequest, opts ...grpc.CallOption) (*NamespaceExistsResponse, error) {
+	out := new(NamespaceExistsResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/NamespaceExists", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for NamespaceService service
+
+type NamespaceServiceServer interface {
+	AddNamespace(context.Context, *AddNamespaceRequest) (*AddNamespaceResponse, error)
+	RemoveNamespace(context.Context, *RemoveNamespaceRequest) (*RemoveNamespaceResponse, error)
+	RenameNamespace(context.Context, *RenameNamespaceRequest) (*RenameNamespaceResponse, error)
+	NamespaceExists(context.Context, *NamespaceExistsRequest) (*NamespaceExistsResponse, error)
+}
+
+func RegisterNamespaceServiceServer(s *grpc.Server, srv NamespaceServiceServer) {
+	s.RegisterService(&_NamespaceService_serviceDesc, srv)
+}
+
+func _NamespaceService_AddNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddNamespaceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).AddNamespace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/AddNamespace",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).AddNamespace(ctx, req.(*AddNamespaceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _NamespaceService_RemoveNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RemoveNamespaceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).RemoveNamespace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/RemoveNamespace",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).RemoveNamespace(ctx, req.(*RemoveNamespaceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _NamespaceService_RenameNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RenameNamespaceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).RenameNamespace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/RenameNamespace",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).RenameNamespace(ctx, req.(*RenameNamespaceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _NamespaceService_NamespaceExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NamespaceExistsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).NamespaceExists(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/NamespaceExists",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).NamespaceExists(ctx, req.(*NamespaceExistsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _NamespaceService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.NamespaceService",
+	HandlerType: (*NamespaceServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "AddNamespace",
+			Handler:    _NamespaceService_AddNamespace_Handler,
+		},
+		{
+			MethodName: "RemoveNamespace",
+			Handler:    _NamespaceService_RemoveNamespace_Handler,
+		},
+		{
+			MethodName: "RenameNamespace",
+			Handler:    _NamespaceService_RenameNamespace_Handler,
+		},
+		{
+			MethodName: "NamespaceExists",
+			Handler:    _NamespaceService_NamespaceExists_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "namespace.proto",
+}
+
+func init() { proto.RegisterFile("namespace.proto", fileDescriptor5) }
+
+var fileDescriptor5 = []byte{
+	// 291 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcf, 0x4b, 0xcc, 0x4d,
+	0x2d, 0x2e, 0x48, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c,
+	0x49, 0xcc, 0xa9, 0x54, 0xf2, 0xe1, 0x12, 0x76, 0x4c, 0x49, 0xf1, 0x83, 0xc9, 0x06, 0xa5, 0x16,
+	0x96, 0xa6, 0x16, 0x97, 0x08, 0x29, 0x72, 0xf1, 0x14, 0x97, 0xe4, 0x17, 0x25, 0xa6, 0xa7, 0xc6,
+	0x83, 0x74, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0x71, 0x43, 0xc5, 0x40, 0xca, 0x85, 0x84,
+	0xb8, 0x58, 0xc0, 0x52, 0x4c, 0x60, 0x29, 0x30, 0x5b, 0xc9, 0x9f, 0x4b, 0x2c, 0x28, 0x35, 0x37,
+	0xbf, 0x2c, 0x95, 0x5a, 0x06, 0xc6, 0x83, 0x0c, 0x04, 0xb1, 0xc8, 0x34, 0x30, 0xad, 0x28, 0x3f,
+	0x17, 0x66, 0x20, 0x88, 0x2d, 0xc4, 0xc7, 0xc5, 0x54, 0x92, 0x2f, 0xc1, 0x0c, 0x16, 0x61, 0x2a,
+	0xc9, 0x07, 0xb9, 0x18, 0x6e, 0xb4, 0x6b, 0x45, 0x66, 0x71, 0x49, 0x31, 0x85, 0x2e, 0x36, 0xe4,
+	0x12, 0xc7, 0x30, 0xb0, 0xb8, 0x20, 0x3f, 0xaf, 0x38, 0x55, 0x48, 0x8c, 0x8b, 0x2d, 0x15, 0x2c,
+	0x02, 0x36, 0x8b, 0x23, 0x08, 0xca, 0x53, 0x12, 0xe3, 0x12, 0x41, 0x8d, 0x03, 0x88, 0x7a, 0x25,
+	0x49, 0x2e, 0x71, 0x8c, 0xd0, 0x44, 0x96, 0x42, 0x0b, 0x17, 0x88, 0x94, 0xd1, 0x43, 0x26, 0x2e,
+	0x01, 0xb8, 0x68, 0x70, 0x6a, 0x51, 0x59, 0x66, 0x72, 0xaa, 0x90, 0x37, 0x17, 0x0f, 0xb2, 0x15,
+	0x42, 0xd2, 0x7a, 0x90, 0xf8, 0xd7, 0xc3, 0x12, 0xf9, 0x52, 0x32, 0xd8, 0x25, 0xa1, 0x56, 0x33,
+	0x08, 0x85, 0x70, 0xf1, 0xa3, 0xb9, 0x4b, 0x48, 0x0e, 0xa6, 0x05, 0x7b, 0xf4, 0x4b, 0xc9, 0xe3,
+	0x94, 0x47, 0x35, 0x15, 0xc5, 0x4b, 0xc8, 0xa6, 0x62, 0x4b, 0x03, 0xc8, 0xa6, 0x62, 0x0d, 0x0b,
+	0x88, 0xa9, 0x68, 0xd1, 0x81, 0x30, 0x15, 0x7b, 0xc4, 0x23, 0x4c, 0xc5, 0x11, 0x8f, 0x4a, 0x0c,
+	0x49, 0x6c, 0xe0, 0x4c, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x36, 0x4b, 0x73, 0x57,
+	0x03, 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 fileDescriptor4, []int{0} }
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []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 fileDescriptor4, []int{1} }
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
 
 func init() {
 	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
@@ -118,9 +118,9 @@ var _NotificationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "notifications.proto",
 }
 
-func init() { proto.RegisterFile("notifications.proto", fileDescriptor4) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor6) }
 
-var fileDescriptor4 = []byte{
+var fileDescriptor6 = []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,

go/vendor/gitlab.com/gitlab-org/gitaly/LICENSE

@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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

@@ -23,8 +23,8 @@ func Dial(rawAddress string, connOpts []grpc.DialOption) (*grpc.ClientConn, erro
 	}
 
 	connOpts = append(connOpts,
-		grpc.WithDialer(func(a string, _ time.Duration) (net.Conn, error) {
-			return net.Dial(network, a)
+		grpc.WithDialer(func(a string, timeout time.Duration) (net.Conn, error) {
+			return net.DialTimeout(network, a, timeout)
 		}))
 	conn, err := grpc.Dial(addr, connOpts...)
 	if err != nil {