Skip to content

G
gitlab-workhorse
Commit 3aef5f9a authored by Nick Thomas's avatar Nick Thomas
Browse files
Options

Merge branch 'gitaly-0.35.0' into 'master' 

Update gitaly-proto to 0.35.0

See merge request gitlab-org/gitlab-workhorse!193
parents 1f05c34c 516fdf8e
Hide whitespace changes
Inline Side-by-side
Showing with 1561 additions and 366 deletions
vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go
View file @ 3aef5f9a
......@@ -9,7 +9,9 @@ It is generated from these files:
commit.proto
deprecated-services.proto
diff.proto
namespace.proto
notifications.proto
operations.proto
ref.proto
repository-service.proto
shared.proto
......@@ -53,8 +55,22 @@ It has these top-level messages:
CommitDeltaRequest
CommitDelta
CommitDeltaResponse
CommitPatchRequest
CommitPatchResponse
AddNamespaceRequest
RemoveNamespaceRequest
RenameNamespaceRequest
NamespaceExistsRequest
NamespaceExistsResponse
AddNamespaceResponse
RemoveNamespaceResponse
RenameNamespaceResponse
PostReceiveRequest
PostReceiveResponse
UserCreateBranchRequest
UserCreateBranchResponse
UserDeleteTagRequest
UserDeleteTagResponse
FindDefaultBranchNameRequest
FindDefaultBranchNameResponse
FindAllBranchNamesRequest
......@@ -73,6 +89,12 @@ It has these top-level messages:
FindAllTagsResponse
RefExistsRequest
RefExistsResponse
CreateBranchRequest
CreateBranchResponse
DeleteBranchRequest
DeleteBranchResponse
FindBranchRequest
FindBranchResponse
RepositoryExistsRequest
RepositoryExistsResponse
RepackIncrementalRequest
......@@ -87,10 +109,14 @@ It has these top-level messages:
ApplyGitattributesResponse
FetchRemoteRequest
FetchRemoteResponse
CreateRepositoryRequest
CreateRepositoryResponse
Repository
GitCommit
CommitAuthor
ExitStatus
Branch
User
InfoRefsRequest
InfoRefsResponse
PostUploadPackRequest
......
vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go
View file @ 3aef5f9a
......@@ -419,6 +419,8 @@ type TreeEntry struct {
Mode int32 `protobuf:"varint,5,opt,name=mode" json:"mode,omitempty"`
// The commit object via which this entry was retrieved
CommitOid string `protobuf:"bytes,6,opt,name=commit_oid,json=commitOid" json:"commit_oid,omitempty"`
// Relative path of the first subdir that doesn't have only one directory descendant
FlatPath []byte `protobuf:"bytes,7,opt,name=flat_path,json=flatPath,proto3" json:"flat_path,omitempty"`
}
func (m *TreeEntry) Reset() { *m = TreeEntry{} }
......@@ -468,6 +470,13 @@ func (m *TreeEntry) GetCommitOid() string {
return ""
}
func (m *TreeEntry) GetFlatPath() []byte {
if m != nil {
return m.FlatPath
}
return nil
}
type GetTreeEntriesRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
......@@ -1773,90 +1782,91 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("commit.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 1353 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0xdb, 0x46,
0x10, 0x36, 0xf5, 0x67, 0x69, 0xa4, 0x3a, 0xf2, 0xe6, 0x4f, 0xa6, 0x93, 0xd8, 0xd9, 0xfe, 0xc0,
0x41, 0x0a, 0x25, 0x50, 0x51, 0xa0, 0x3d, 0x15, 0x56, 0x22, 0xbb, 0x4e, 0xed, 0x28, 0x60, 0x04,
0x04, 0xed, 0xc5, 0xa0, 0xc4, 0x95, 0xcc, 0x86, 0xd4, 0x2a, 0xe4, 0x2a, 0x8e, 0x5a, 0xa0, 0xf7,
0x02, 0x7d, 0x95, 0x3e, 0x44, 0x5f, 0xa1, 0xf7, 0xa2, 0xf7, 0x02, 0x7d, 0x81, 0x9e, 0x8a, 0xfd,
0x21, 0x97, 0x12, 0xa9, 0xb4, 0x71, 0x20, 0x5f, 0x84, 0x9d, 0xd9, 0xe1, 0xce, 0xb7, 0xb3, 0x33,
0xdf, 0xce, 0x0a, 0x6a, 0x03, 0xea, 0xfb, 0x2e, 0x6b, 0x4e, 0x02, 0xca, 0x28, 0x2a, 0x8d, 0x5c,
0x66, 0x7b, 0x33, 0xb3, 0x16, 0x9e, 0xd9, 0x01, 0x71, 0xa4, 0xd6, 0xdc, 0x19, 0x51, 0x3a, 0xf2,
0xc8, 0x03, 0x21, 0xf5, 0xa7, 0xc3, 0x07, 0xcc, 0xf5, 0x49, 0xc8, 0x6c, 0x7f, 0x22, 0x0d, 0xb0,
0x03, 0xe8, 0x91, 0x58, 0xe6, 0x39, 0xb3, 0x59, 0x68, 0x91, 0x57, 0x53, 0x12, 0x32, 0xd4, 0x02,
0x08, 0xc8, 0x84, 0x86, 0x2e, 0xa3, 0xc1, 0xac, 0x61, 0xec, 0x1a, 0x7b, 0xd5, 0x16, 0x6a, 0x4a,
0x0f, 0x4d, 0x2b, 0x9e, 0xb1, 0x12, 0x56, 0xc8, 0x84, 0x72, 0x40, 0x5e, 0xbb, 0xa1, 0x4b, 0xc7,
0x8d, 0xdc, 0xae, 0xb1, 0x57, 0xb3, 0x62, 0x19, 0x0f, 0xe0, 0xea, 0x9c, 0x97, 0x70, 0x42, 0xc7,
0x21, 0x41, 0x75, 0xc8, 0x53, 0xd7, 0x11, 0xeb, 0x57, 0x2c, 0x3e, 0x44, 0xb7, 0xa0, 0x62, 0x3b,
0x8e, 0xcb, 0x5c, 0x3a, 0x0e, 0xc5, 0x2a, 0x45, 0x4b, 0x2b, 0xf8, 0xac, 0x43, 0x3c, 0x22, 0x67,
0xf3, 0x72, 0x36, 0x56, 0xe0, 0x9f, 0x0d, 0xb8, 0x29, 0xbd, 0x1c, 0x85, 0xfb, 0xe3, 0x01, 0x09,
0x19, 0x0d, 0xde, 0x67, 0x43, 0x3b, 0x50, 0xb5, 0xd5, 0x32, 0xa7, 0xae, 0x23, 0xd0, 0x54, 0x2c,
0x88, 0x54, 0x47, 0x0e, 0xda, 0x82, 0xf2, 0xe0, 0xcc, 0xf5, 0x1c, 0x3e, 0x9b, 0x17, 0xb3, 0xeb,
0x42, 0x3e, 0x72, 0xf0, 0x43, 0x68, 0xa4, 0xa1, 0xa8, 0x5d, 0x5f, 0x83, 0xe2, 0x6b, 0xdb, 0x9b,
0x12, 0x01, 0xa3, 0x6c, 0x49, 0x01, 0xff, 0x62, 0x40, 0xbd, 0x17, 0x10, 0xd2, 0x19, 0xb3, 0x60,
0xb6, 0xa2, 0x73, 0x40, 0x08, 0x0a, 0x13, 0x9b, 0x9d, 0x09, 0xb4, 0x35, 0x4b, 0x8c, 0x39, 0x1c,
0xcf, 0xf5, 0x5d, 0xd6, 0x28, 0xec, 0x1a, 0x7b, 0x79, 0x4b, 0x0a, 0xf8, 0x77, 0x03, 0x36, 0x13,
0x70, 0x14, 0xf4, 0x2f, 0xa0, 0xc0, 0x66, 0x13, 0x89, 0x7c, 0xa3, 0xf5, 0x51, 0x84, 0x24, 0x65,
0xd8, 0xec, 0xf6, 0xbf, 0x27, 0x03, 0xd6, 0x9b, 0x4d, 0x88, 0x25, 0xbe, 0x88, 0x8e, 0x3a, 0xa7,
0x8f, 0x1a, 0x41, 0x21, 0x74, 0x7f, 0x20, 0x02, 0x4b, 0xde, 0x12, 0x63, 0xae, 0xf3, 0xa9, 0x43,
0x04, 0x94, 0xa2, 0x25, 0xc6, 0x5c, 0xe7, 0xd8, 0xcc, 0x6e, 0x14, 0x25, 0x66, 0x3e, 0xc6, 0x9f,
0x03, 0x68, 0x0f, 0x08, 0xa0, 0xf4, 0xa8, 0x7b, 0x72, 0x72, 0xd4, 0xab, 0xaf, 0xa1, 0x32, 0x14,
0xda, 0xc7, 0xdd, 0x76, 0xdd, 0xe0, 0xa3, 0x9e, 0xd5, 0xe9, 0xd4, 0x73, 0x68, 0x1d, 0xf2, 0xbd,
0xfd, 0xc3, 0x7a, 0x1e, 0x53, 0xb8, 0x2e, 0x4f, 0x25, 0x6c, 0x13, 0x76, 0x4e, 0xc8, 0xf8, 0x7d,
0xe2, 0x8c, 0xa0, 0x30, 0x0c, 0xa8, 0xaf, 0x62, 0x2c, 0xc6, 0x68, 0x03, 0x72, 0x8c, 0xaa, 0xe8,
0xe6, 0x18, 0xc5, 0x1d, 0xb8, 0xb1, 0xe8, 0x50, 0x45, 0xf2, 0x3e, 0xac, 0xcb, 0xf2, 0x0d, 0x1b,
0xc6, 0x6e, 0x7e, 0xaf, 0xda, 0xda, 0x8c, 0xdc, 0x1d, 0xba, 0x4c, 0x7e, 0x63, 0x45, 0x16, 0xf8,
0x4f, 0x83, 0xd7, 0xcf, 0x74, 0xac, 0x26, 0x56, 0x55, 0xa6, 0xe8, 0x21, 0x14, 0xed, 0x21, 0x23,
0x81, 0xd8, 0x41, 0xb5, 0x65, 0x36, 0x25, 0x7b, 0x34, 0x23, 0xf6, 0x68, 0xf6, 0x22, 0xf6, 0xb0,
0xa4, 0x21, 0x6a, 0x41, 0xa9, 0x4f, 0x86, 0x34, 0x90, 0x47, 0xf6, 0xf6, 0x4f, 0x94, 0x65, 0x9c,
0x84, 0x45, 0x9d, 0x84, 0xf8, 0x53, 0xb8, 0x36, 0xbf, 0x41, 0x5d, 0x2b, 0x03, 0xae, 0x17, 0x9b,
0x2b, 0x5a, 0x52, 0xc0, 0x7f, 0x18, 0x50, 0x89, 0x73, 0x2e, 0x83, 0x45, 0xb6, 0xa0, 0x1c, 0x50,
0xca, 0x4e, 0x75, 0xc6, 0xad, 0x73, 0xb9, 0x2b, 0xb3, 0x2e, 0x55, 0x01, 0x0f, 0x54, 0x56, 0x17,
0x44, 0x56, 0x6f, 0xa7, 0xb2, 0xba, 0x29, 0x7e, 0x13, 0xc9, 0x1c, 0xa5, 0x69, 0x31, 0x91, 0xa6,
0xb7, 0x01, 0xe4, 0x71, 0x09, 0xaf, 0x25, 0xe1, 0xb5, 0x22, 0x35, 0x5d, 0xd7, 0xc1, 0xf7, 0xa1,
0x12, 0xaf, 0x12, 0x27, 0xe9, 0x5a, 0x9c, 0xa4, 0x46, 0x22, 0x89, 0xf3, 0xf8, 0x47, 0xb8, 0x7e,
0x48, 0x58, 0xe4, 0xdf, 0x25, 0xe1, 0x25, 0xf2, 0x01, 0xcf, 0xd9, 0x45, 0xe7, 0x3a, 0x67, 0x89,
0x54, 0x2d, 0xe6, 0xac, 0x26, 0x80, 0xc8, 0x02, 0xf7, 0xa1, 0x7e, 0xec, 0x86, 0xec, 0xc0, 0xf5,
0x56, 0x06, 0x1f, 0xdf, 0x83, 0xcd, 0x84, 0x0f, 0x9d, 0x32, 0x7c, 0x1f, 0x12, 0x63, 0xcd, 0x92,
0x02, 0x1e, 0xc0, 0xe6, 0x81, 0x3b, 0x76, 0x54, 0x65, 0xad, 0x08, 0xcf, 0x57, 0x80, 0x92, 0x4e,
0x14, 0xa0, 0x7b, 0x50, 0x92, 0x79, 0xa0, 0x3c, 0x64, 0x54, 0xba, 0x32, 0xc0, 0xff, 0x18, 0x70,
0x9d, 0xaf, 0xb0, 0xef, 0x79, 0x2b, 0x2e, 0xf5, 0x6d, 0xa8, 0xf8, 0xf6, 0x9b, 0x53, 0x59, 0x5c,
0xf2, 0x2a, 0x2d, 0xfb, 0xf6, 0x1b, 0x51, 0x84, 0x82, 0x9a, 0x5f, 0xba, 0x93, 0x88, 0x86, 0xf9,
0x18, 0x7d, 0x09, 0x45, 0x1a, 0x38, 0x24, 0x10, 0x49, 0xbf, 0xd1, 0xfa, 0x30, 0xf2, 0x9d, 0x09,
0xb7, 0xd9, 0xe5, 0xa6, 0x96, 0xfc, 0x02, 0x7f, 0x0c, 0x45, 0x21, 0xf3, 0x6c, 0x7f, 0xda, 0x7d,
0xda, 0x51, 0x79, 0xdf, 0x7d, 0xd6, 0x95, 0x34, 0xfd, 0x78, 0xbf, 0xd7, 0xa9, 0xe7, 0x78, 0xe2,
0x2d, 0x2e, 0x76, 0x11, 0xb2, 0xfc, 0x2b, 0x97, 0x3c, 0x85, 0x95, 0x05, 0x30, 0xbe, 0x36, 0x65,
0xf0, 0xa4, 0x80, 0x6e, 0x40, 0x89, 0x0e, 0x87, 0x21, 0x61, 0x2a, 0x76, 0x4a, 0xd2, 0x49, 0x59,
0x4c, 0x24, 0x25, 0xb7, 0x1e, 0x52, 0xcf, 0xa3, 0xe7, 0x82, 0x2f, 0xca, 0x96, 0x92, 0x78, 0xe7,
0xc1, 0x63, 0x7e, 0xea, 0x93, 0x60, 0x44, 0xc2, 0xc6, 0xba, 0x98, 0x04, 0xae, 0x3a, 0x11, 0x1a,
0x74, 0x17, 0x6a, 0x8e, 0x1b, 0xda, 0x7d, 0x8f, 0x9c, 0x9e, 0xdb, 0xde, 0xcb, 0x46, 0x59, 0x58,
0x54, 0x95, 0xee, 0x85, 0xed, 0xbd, 0xd4, 0x5c, 0x5e, 0x79, 0x77, 0x2e, 0x87, 0xff, 0xcb, 0xe5,
0xb8, 0x0d, 0x57, 0xe7, 0x62, 0x7d, 0x91, 0x03, 0x3b, 0x8b, 0x2e, 0xc9, 0x63, 0x7b, 0x3c, 0x9a,
0xda, 0xa3, 0xd5, 0xf1, 0xc5, 0xaf, 0x71, 0x87, 0x98, 0x70, 0xa5, 0x20, 0x1f, 0x40, 0xc5, 0x8b,
0x94, 0x0a, 0xf4, 0x5e, 0xe4, 0x6a, 0xc9, 0x37, 0xcd, 0x48, 0x63, 0xe9, 0x4f, 0xcd, 0x27, 0x50,
0x8e, 0xd4, 0xbc, 0x8e, 0xc6, 0xb6, 0x4f, 0xd4, 0xd5, 0x24, 0xc6, 0x3c, 0x13, 0x44, 0x87, 0x2e,
0xc0, 0xe5, 0x2c, 0x29, 0xc8, 0x7b, 0xce, 0xa3, 0x81, 0xea, 0x23, 0xa5, 0x80, 0xa7, 0x70, 0xc5,
0xb2, 0xcf, 0xdb, 0x9e, 0xed, 0x93, 0xcb, 0xbc, 0x01, 0x3e, 0x81, 0xba, 0x76, 0xab, 0xc2, 0x13,
0x75, 0x61, 0x46, 0xa2, 0x0b, 0xfb, 0x09, 0x1a, 0xc7, 0x76, 0xa8, 0xce, 0xf3, 0x80, 0x06, 0xcf,
0x6c, 0x76, 0x76, 0x99, 0x38, 0x0f, 0x60, 0x2b, 0xc3, 0xff, 0xbb, 0xb3, 0xee, 0x6f, 0x71, 0x5a,
0x84, 0xed, 0xd9, 0x09, 0x09, 0x43, 0x7e, 0xa4, 0x2b, 0xda, 0x87, 0x26, 0x88, 0xfc, 0x22, 0x41,
0xe8, 0x2e, 0x3c, 0xa6, 0x93, 0x8c, 0x56, 0x89, 0x5b, 0xbe, 0x9a, 0x92, 0x60, 0xa6, 0x7a, 0x0c,
0x29, 0xe0, 0xc3, 0xe8, 0xc1, 0x91, 0xdc, 0xc2, 0x05, 0xaa, 0xb1, 0xf5, 0x77, 0x19, 0x3e, 0x50,
0x6f, 0x35, 0x12, 0xbc, 0x76, 0x07, 0x04, 0xbd, 0x80, 0xfa, 0xe2, 0x5b, 0x06, 0xed, 0xcc, 0x97,
0x46, 0xea, 0xc1, 0x65, 0xee, 0x2e, 0x37, 0x90, 0xa8, 0xf0, 0x1a, 0x7a, 0x9c, 0xec, 0xe2, 0x1a,
0x19, 0x8f, 0x09, 0xb9, 0xd4, 0xd6, 0xd2, 0x67, 0x06, 0x5e, 0x7b, 0x68, 0xa0, 0xe7, 0xb0, 0x31,
0xdf, 0x63, 0xa3, 0xdb, 0xf3, 0xbe, 0x17, 0x9a, 0x7d, 0xf3, 0xce, 0xb2, 0xe9, 0xc4, 0xa2, 0xdf,
0x40, 0x2d, 0xd9, 0x8f, 0xa2, 0x6d, 0xfd, 0x4d, 0xaa, 0x0d, 0x37, 0x6f, 0x65, 0x4f, 0xc6, 0xfb,
0x7c, 0x0e, 0x1b, 0xf3, 0x1d, 0x95, 0x46, 0x98, 0xd9, 0xe6, 0x69, 0x84, 0xd9, 0x8d, 0x98, 0x40,
0xf8, 0x18, 0x2a, 0x71, 0xef, 0xa3, 0x83, 0xb7, 0xd8, 0x72, 0xe9, 0xe0, 0xa5, 0x1a, 0x25, 0xb1,
0x4a, 0x07, 0x40, 0xf3, 0x37, 0xda, 0x4a, 0x5e, 0xea, 0x73, 0xad, 0x92, 0x69, 0x66, 0x4d, 0xc5,
0x3b, 0xfc, 0x1a, 0xaa, 0x89, 0xf7, 0x3d, 0x32, 0xe7, 0x23, 0x9c, 0xfc, 0x6b, 0xc1, 0xdc, 0xce,
0x9c, 0x4b, 0xc6, 0x6a, 0xbe, 0x09, 0xd0, 0xb1, 0xca, 0xec, 0x34, 0x74, 0xac, 0xb2, 0x7b, 0x07,
0xb1, 0xcb, 0x27, 0x50, 0x4d, 0xdc, 0x52, 0x28, 0x63, 0x2f, 0x69, 0x78, 0x19, 0xd7, 0x9a, 0x58,
0xab, 0x07, 0x57, 0x16, 0xae, 0x03, 0x74, 0x67, 0xe9, 0x3d, 0x21, 0xd7, 0xdc, 0xf9, 0x8f, 0x7b,
0x04, 0xaf, 0xa1, 0x7d, 0x28, 0x47, 0x94, 0x8b, 0x6e, 0xc6, 0xf4, 0x32, 0xcf, 0xfd, 0x66, 0x23,
0x3d, 0x91, 0x00, 0xf6, 0x1d, 0x6c, 0xa6, 0xd8, 0x10, 0xc5, 0x65, 0xb8, 0x8c, 0xa8, 0xcd, 0xbb,
0x6f, 0xb1, 0x88, 0xe1, 0x7d, 0x1b, 0x51, 0x80, 0x66, 0x97, 0x45, 0x0a, 0x48, 0x51, 0xe7, 0x22,
0x05, 0xa4, 0x89, 0x89, 0xc3, 0xee, 0x97, 0x44, 0x77, 0xf1, 0xd9, 0xbf, 0x01, 0x00, 0x00, 0xff,
0xff, 0x72, 0x55, 0x08, 0x55, 0xce, 0x12, 0x00, 0x00,
// 1366 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0xdb, 0xb6,
0x17, 0x8f, 0xfc, 0x15, 0xf9, 0xd8, 0xff, 0xd4, 0x61, 0xbf, 0x1c, 0xa5, 0x6d, 0x52, 0xfd, 0xb7,
0x21, 0x45, 0x07, 0xb7, 0xf0, 0x30, 0x60, 0xbb, 0x1a, 0x92, 0xd6, 0xc9, 0xd2, 0x25, 0x75, 0xc1,
0x1a, 0x28, 0xb6, 0x9b, 0x40, 0xb6, 0x68, 0x47, 0xab, 0x64, 0xba, 0x12, 0xdd, 0xd4, 0x1b, 0xb0,
0xfb, 0x01, 0x7b, 0x95, 0x3d, 0xc4, 0x5e, 0x61, 0x2f, 0xb0, 0xfb, 0x01, 0x7b, 0x81, 0x5d, 0x0d,
0xfc, 0x90, 0x28, 0x5b, 0x72, 0xb7, 0xb6, 0x70, 0x6e, 0x0c, 0x9e, 0x43, 0x8a, 0xe7, 0xc7, 0xc3,
0x1f, 0x7f, 0x3c, 0x34, 0xd4, 0x07, 0x34, 0x08, 0x3c, 0xd6, 0x9a, 0x84, 0x94, 0x51, 0x54, 0x19,
0x79, 0xcc, 0xf1, 0x67, 0x56, 0x3d, 0x3a, 0x77, 0x42, 0xe2, 0x4a, 0xaf, 0xb5, 0x33, 0xa2, 0x74,
0xe4, 0x93, 0x07, 0xc2, 0xea, 0x4f, 0x87, 0x0f, 0x98, 0x17, 0x90, 0x88, 0x39, 0xc1, 0x44, 0x0e,
0xb0, 0x5d, 0x40, 0x8f, 0xc4, 0x34, 0xcf, 0x99, 0xc3, 0x22, 0x4c, 0x5e, 0x4d, 0x49, 0xc4, 0x50,
0x1b, 0x20, 0x24, 0x13, 0x1a, 0x79, 0x8c, 0x86, 0xb3, 0xa6, 0xb1, 0x6b, 0xec, 0xd5, 0xda, 0xa8,
0x25, 0x23, 0xb4, 0x70, 0xd2, 0x83, 0x53, 0xa3, 0x90, 0x05, 0x66, 0x48, 0x5e, 0x7b, 0x91, 0x47,
0xc7, 0xcd, 0xc2, 0xae, 0xb1, 0x57, 0xc7, 0x89, 0x6d, 0x0f, 0xe0, 0xea, 0x5c, 0x94, 0x68, 0x42,
0xc7, 0x11, 0x41, 0x0d, 0x28, 0x52, 0xcf, 0x15, 0xf3, 0x57, 0x31, 0x6f, 0xa2, 0x5b, 0x50, 0x75,
0x5c, 0xd7, 0x63, 0x1e, 0x1d, 0x47, 0x62, 0x96, 0x32, 0xd6, 0x0e, 0xde, 0xeb, 0x12, 0x9f, 0xc8,
0xde, 0xa2, 0xec, 0x4d, 0x1c, 0xf6, 0xcf, 0x06, 0xdc, 0x94, 0x51, 0x8e, 0xa3, 0xfd, 0xf1, 0x80,
0x44, 0x8c, 0x86, 0x1f, 0xb2, 0xa0, 0x1d, 0xa8, 0x39, 0x6a, 0x9a, 0x33, 0xcf, 0x15, 0x68, 0xaa,
0x18, 0x62, 0xd7, 0xb1, 0x8b, 0xb6, 0xc0, 0x1c, 0x9c, 0x7b, 0xbe, 0xcb, 0x7b, 0x8b, 0xa2, 0x77,
0x5d, 0xd8, 0xc7, 0xae, 0xfd, 0x10, 0x9a, 0x59, 0x28, 0x6a, 0xd5, 0xd7, 0xa0, 0xfc, 0xda, 0xf1,
0xa7, 0x44, 0xc0, 0x30, 0xb1, 0x34, 0xec, 0x5f, 0x0c, 0x68, 0xf4, 0x42, 0x42, 0x3a, 0x63, 0x16,
0xce, 0x56, 0xb4, 0x0f, 0x08, 0x41, 0x69, 0xe2, 0xb0, 0x73, 0x81, 0xb6, 0x8e, 0x45, 0x9b, 0xc3,
0xf1, 0xbd, 0xc0, 0x63, 0xcd, 0xd2, 0xae, 0xb1, 0x57, 0xc4, 0xd2, 0xb0, 0x7f, 0x37, 0x60, 0x33,
0x05, 0x47, 0x41, 0xff, 0x02, 0x4a, 0x6c, 0x36, 0x91, 0xc8, 0x37, 0xda, 0x1f, 0xc5, 0x48, 0x32,
0x03, 0x5b, 0xdd, 0xfe, 0xf7, 0x64, 0xc0, 0x7a, 0xb3, 0x09, 0xc1, 0xe2, 0x8b, 0x78, 0xab, 0x0b,
0x7a, 0xab, 0x11, 0x94, 0x22, 0xef, 0x07, 0x22, 0xb0, 0x14, 0xb1, 0x68, 0x73, 0x5f, 0x40, 0x5d,
0x22, 0xa0, 0x94, 0xb1, 0x68, 0x73, 0x9f, 0xeb, 0x30, 0xa7, 0x59, 0x96, 0x98, 0x79, 0xdb, 0xfe,
0x1c, 0x40, 0x47, 0x40, 0x00, 0x95, 0x47, 0xdd, 0xd3, 0xd3, 0xe3, 0x5e, 0x63, 0x0d, 0x99, 0x50,
0x3a, 0x38, 0xe9, 0x1e, 0x34, 0x0c, 0xde, 0xea, 0xe1, 0x4e, 0xa7, 0x51, 0x40, 0xeb, 0x50, 0xec,
0xed, 0x1f, 0x35, 0x8a, 0x36, 0x85, 0xeb, 0x72, 0x57, 0xa2, 0x03, 0xc2, 0x2e, 0x08, 0x19, 0x7f,
0x48, 0x9e, 0x11, 0x94, 0x86, 0x21, 0x0d, 0x54, 0x8e, 0x45, 0x1b, 0x6d, 0x40, 0x81, 0x51, 0x95,
0xdd, 0x02, 0xa3, 0x76, 0x07, 0x6e, 0x2c, 0x06, 0x54, 0x99, 0xbc, 0x0f, 0xeb, 0xf2, 0xf8, 0x46,
0x4d, 0x63, 0xb7, 0xb8, 0x57, 0x6b, 0x6f, 0xc6, 0xe1, 0x8e, 0x3c, 0x26, 0xbf, 0xc1, 0xf1, 0x08,
0xfb, 0x0f, 0x83, 0x9f, 0x9f, 0xe9, 0x58, 0x75, 0xac, 0xea, 0x98, 0xa2, 0x87, 0x50, 0x76, 0x86,
0x8c, 0x84, 0x62, 0x05, 0xb5, 0xb6, 0xd5, 0x92, 0xea, 0xd1, 0x8a, 0xd5, 0xa3, 0xd5, 0x8b, 0xd5,
0x03, 0xcb, 0x81, 0xa8, 0x0d, 0x95, 0x3e, 0x19, 0xd2, 0x50, 0x6e, 0xd9, 0xdb, 0x3f, 0x51, 0x23,
0x13, 0x12, 0x96, 0x35, 0x09, 0xed, 0x4f, 0xe1, 0xda, 0xfc, 0x02, 0xf5, 0x59, 0x19, 0x70, 0xbf,
0x58, 0x5c, 0x19, 0x4b, 0xc3, 0xfe, 0xdb, 0x80, 0x6a, 0xc2, 0xb9, 0x1c, 0x15, 0xd9, 0x02, 0x33,
0xa4, 0x94, 0x9d, 0x69, 0xc6, 0xad, 0x73, 0xbb, 0x2b, 0x59, 0x97, 0x39, 0x01, 0x0f, 0x14, 0xab,
0x4b, 0x82, 0xd5, 0xdb, 0x19, 0x56, 0xb7, 0xc4, 0x6f, 0x8a, 0xcc, 0x31, 0x4d, 0xcb, 0x29, 0x9a,
0xde, 0x06, 0x90, 0xdb, 0x25, 0xa2, 0x56, 0x44, 0xd4, 0xaa, 0xf4, 0xf0, 0xb8, 0xdb, 0x50, 0x1d,
0xfa, 0x0e, 0x3b, 0x13, 0xc1, 0xd7, 0x65, 0xde, 0xb9, 0xe3, 0x19, 0x5f, 0xfd, 0x7d, 0xa8, 0x26,
0x21, 0x12, 0x06, 0xaf, 0x25, 0x0c, 0x36, 0x52, 0x0c, 0x2f, 0xda, 0x3f, 0xc2, 0xf5, 0x23, 0xc2,
0x62, 0x70, 0x1e, 0x89, 0x2e, 0x51, 0x2c, 0x38, 0xa1, 0x17, 0x83, 0x6b, 0x42, 0x13, 0xe9, 0x5a,
0x24, 0xb4, 0x56, 0x87, 0x78, 0x84, 0xdd, 0x87, 0xc6, 0x89, 0x17, 0xb1, 0x43, 0xcf, 0x5f, 0x19,
0x7c, 0xfb, 0x1e, 0x6c, 0xa6, 0x62, 0x68, 0x3e, 0xf1, 0x75, 0x48, 0x8c, 0x75, 0x2c, 0x0d, 0x7b,
0x00, 0x9b, 0x87, 0xde, 0xd8, 0x55, 0xc7, 0x6e, 0x45, 0x78, 0xbe, 0x02, 0x94, 0x0e, 0xa2, 0x00,
0xdd, 0x83, 0x8a, 0x24, 0x89, 0x8a, 0x90, 0x23, 0x03, 0x6a, 0x00, 0x67, 0xfd, 0x75, 0x3e, 0xc3,
0xbe, 0xef, 0xaf, 0x58, 0x07, 0xb6, 0xa1, 0x1a, 0x38, 0x6f, 0xce, 0xe4, 0xc9, 0x93, 0xf7, 0xac,
0x19, 0x38, 0x6f, 0xc4, 0x09, 0x15, 0xba, 0xfd, 0xd2, 0x9b, 0xc4, 0x1a, 0xcd, 0xdb, 0xe8, 0x4b,
0x28, 0xd3, 0xd0, 0x25, 0xa1, 0x38, 0x11, 0x1b, 0xed, 0xff, 0xc7, 0xb1, 0x73, 0xe1, 0xb6, 0xba,
0x7c, 0x28, 0x96, 0x5f, 0xd8, 0x1f, 0x43, 0x59, 0xd8, 0x9c, 0xed, 0x4f, 0xbb, 0x4f, 0x3b, 0x8a,
0xf7, 0xdd, 0x67, 0x5d, 0xa9, 0xe1, 0x8f, 0xf7, 0x7b, 0x9d, 0x46, 0x81, 0x13, 0x6f, 0x71, 0xb2,
0xf7, 0x51, 0xd2, 0x3f, 0x0b, 0xe9, 0x5d, 0x58, 0x59, 0x02, 0x93, 0x3b, 0x55, 0x26, 0x4f, 0x1a,
0xe8, 0x06, 0x54, 0xe8, 0x70, 0x18, 0x11, 0xa6, 0x72, 0xa7, 0x2c, 0x4d, 0xca, 0x72, 0x8a, 0x94,
0x7c, 0xf4, 0x90, 0xfa, 0x3e, 0xbd, 0x10, 0x62, 0x62, 0x62, 0x65, 0xf1, 0xb2, 0x84, 0xe7, 0xfc,
0x2c, 0x20, 0xe1, 0x88, 0x44, 0x42, 0x4b, 0x4c, 0x0c, 0xdc, 0x75, 0x2a, 0x3c, 0xe8, 0x2e, 0xd4,
0x5d, 0x2f, 0x72, 0xfa, 0x3e, 0x39, 0xbb, 0x70, 0xfc, 0x97, 0x4d, 0x53, 0x8c, 0xa8, 0x29, 0xdf,
0x0b, 0xc7, 0x7f, 0xa9, 0x85, 0xbe, 0xfa, 0xee, 0x42, 0x0f, 0xff, 0x55, 0xe8, 0xed, 0x03, 0xb8,
0x3a, 0x97, 0xeb, 0xf7, 0xd9, 0xb0, 0xf3, 0xf8, 0x06, 0x3d, 0x71, 0xc6, 0xa3, 0xa9, 0x33, 0x5a,
0x9d, 0x5e, 0xfc, 0x9a, 0x94, 0x8f, 0xa9, 0x50, 0x0a, 0xf2, 0x21, 0x54, 0xfd, 0xd8, 0xa9, 0x40,
0xef, 0xc5, 0xa1, 0x96, 0x7c, 0xd3, 0x8a, 0x3d, 0x58, 0x7f, 0x6a, 0x3d, 0x01, 0x33, 0x76, 0xf3,
0x73, 0x34, 0x76, 0x02, 0xa2, 0xee, 0x2d, 0xd1, 0xe6, 0x4c, 0x10, 0xe5, 0xbb, 0x00, 0x57, 0xc0,
0xd2, 0x90, 0x97, 0xa0, 0x4f, 0x43, 0x55, 0x64, 0x4a, 0xc3, 0x9e, 0xc2, 0x15, 0xec, 0x5c, 0x1c,
0xf8, 0x4e, 0x40, 0x2e, 0xf3, 0x06, 0xf8, 0x04, 0x1a, 0x3a, 0xac, 0x4a, 0x4f, 0x5c, 0xa2, 0x19,
0xa9, 0x12, 0xed, 0x27, 0x68, 0x9e, 0x38, 0x91, 0xda, 0xcf, 0x43, 0x1a, 0xf2, 0x8b, 0xee, 0x32,
0x71, 0x1e, 0xc2, 0x56, 0x4e, 0xfc, 0x77, 0x57, 0xdd, 0xdf, 0x12, 0x5a, 0x44, 0x07, 0xb3, 0x53,
0x12, 0x45, 0x7c, 0x4b, 0x57, 0xb4, 0x0e, 0x2d, 0x10, 0xc5, 0x45, 0x81, 0xd0, 0x25, 0x7a, 0x22,
0x27, 0x39, 0x75, 0x14, 0x1f, 0xf9, 0x6a, 0x4a, 0xc2, 0x99, 0x2a, 0x40, 0xa4, 0x61, 0x1f, 0xc5,
0xaf, 0x91, 0xf4, 0x12, 0xde, 0xe3, 0x34, 0xb6, 0xff, 0x32, 0xe1, 0x7f, 0xea, 0x21, 0x47, 0xc2,
0xd7, 0xde, 0x80, 0xa0, 0x17, 0xd0, 0x58, 0x7c, 0xe8, 0xa0, 0x9d, 0xf9, 0xa3, 0x91, 0x79, 0x8d,
0x59, 0xbb, 0xcb, 0x07, 0x48, 0x54, 0xf6, 0x1a, 0x7a, 0x9c, 0x2e, 0xf1, 0x9a, 0x39, 0x2f, 0x0d,
0x39, 0xd5, 0xd6, 0xd2, 0x37, 0x88, 0xbd, 0xf6, 0xd0, 0x40, 0xcf, 0x61, 0x63, 0xbe, 0x00, 0x47,
0xb7, 0xe7, 0x63, 0x2f, 0xbc, 0x04, 0xac, 0x3b, 0xcb, 0xba, 0x53, 0x93, 0x7e, 0x03, 0xf5, 0x74,
0xb1, 0x8a, 0xb6, 0xf5, 0x37, 0x99, 0x1a, 0xdd, 0xba, 0x95, 0xdf, 0x99, 0xac, 0xf3, 0x39, 0x6c,
0xcc, 0x57, 0x54, 0x1a, 0x61, 0x6e, 0x99, 0xa7, 0x11, 0xe6, 0x17, 0x62, 0x02, 0xe1, 0x63, 0xa8,
0x26, 0xb5, 0x8f, 0x4e, 0xde, 0x62, 0xc9, 0xa5, 0x93, 0x97, 0x29, 0x94, 0xc4, 0x2c, 0x1d, 0x00,
0xad, 0xdf, 0x68, 0x2b, 0x7d, 0xa9, 0xcf, 0x95, 0x4a, 0x96, 0x95, 0xd7, 0x95, 0xac, 0xf0, 0x6b,
0xa8, 0xa5, 0x1e, 0xff, 0xc8, 0x9a, 0xcf, 0x70, 0xfa, 0x7f, 0x07, 0x6b, 0x3b, 0xb7, 0x2f, 0x9d,
0xab, 0xf9, 0x22, 0x40, 0xe7, 0x2a, 0xb7, 0xd2, 0xd0, 0xb9, 0xca, 0xaf, 0x1d, 0xc4, 0x2a, 0x9f,
0x40, 0x2d, 0x75, 0x4b, 0xa1, 0x9c, 0xb5, 0x64, 0xe1, 0xe5, 0x5c, 0x6b, 0x62, 0xae, 0x1e, 0x5c,
0x59, 0xb8, 0x0e, 0xd0, 0x9d, 0xa5, 0xf7, 0x84, 0x9c, 0x73, 0xe7, 0x5f, 0xee, 0x11, 0x7b, 0x0d,
0xed, 0x83, 0x19, 0x4b, 0x2e, 0xba, 0x99, 0xc8, 0xcb, 0xbc, 0xf6, 0x5b, 0xcd, 0x6c, 0x47, 0x0a,
0xd8, 0x77, 0xb0, 0x99, 0x51, 0x43, 0x94, 0x1c, 0xc3, 0x65, 0x42, 0x6d, 0xdd, 0x7d, 0xcb, 0x88,
0x04, 0xde, 0xb7, 0xb1, 0x04, 0x68, 0x75, 0x59, 0x94, 0x80, 0x8c, 0x74, 0x2e, 0x4a, 0x40, 0x56,
0x98, 0x38, 0xec, 0x7e, 0x45, 0x54, 0x17, 0x9f, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xed, 0xf2,
0x95, 0x19, 0xeb, 0x12, 0x00, 0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go
View file @ 3aef5f9a
......@@ -342,12 +342,54 @@ func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta {
return nil
}
type CommitPatchRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
}
func (m *CommitPatchRequest) Reset() { *m = CommitPatchRequest{} }
func (m *CommitPatchRequest) String() string { return proto.CompactTextString(m) }
func (*CommitPatchRequest) ProtoMessage() {}
func (*CommitPatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{5} }
func (m *CommitPatchRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *CommitPatchRequest) GetRevision() []byte {
if m != nil {
return m.Revision
}
return nil
}
type CommitPatchResponse struct {
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *CommitPatchResponse) Reset() { *m = CommitPatchResponse{} }
func (m *CommitPatchResponse) String() string { return proto.CompactTextString(m) }
func (*CommitPatchResponse) ProtoMessage() {}
func (*CommitPatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{6} }
func (m *CommitPatchResponse) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func init() {
proto.RegisterType((*CommitDiffRequest)(nil), "gitaly.CommitDiffRequest")
proto.RegisterType((*CommitDiffResponse)(nil), "gitaly.CommitDiffResponse")
proto.RegisterType((*CommitDeltaRequest)(nil), "gitaly.CommitDeltaRequest")
proto.RegisterType((*CommitDelta)(nil), "gitaly.CommitDelta")
proto.RegisterType((*CommitDeltaResponse)(nil), "gitaly.CommitDeltaResponse")
proto.RegisterType((*CommitPatchRequest)(nil), "gitaly.CommitPatchRequest")
proto.RegisterType((*CommitPatchResponse)(nil), "gitaly.CommitPatchResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
......@@ -365,6 +407,7 @@ type DiffServiceClient interface {
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) (DiffService_CommitDeltaClient, error)
CommitPatch(ctx context.Context, in *CommitPatchRequest, opts ...grpc.CallOption) (DiffService_CommitPatchClient, error)
}
type diffServiceClient struct {
......@@ -439,6 +482,38 @@ func (x *diffServiceCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
return m, nil
}
func (c *diffServiceClient) CommitPatch(ctx context.Context, in *CommitPatchRequest, opts ...grpc.CallOption) (DiffService_CommitPatchClient, error) {
stream, err := grpc.NewClientStream(ctx, &_DiffService_serviceDesc.Streams[2], c.cc, "/gitaly.DiffService/CommitPatch", opts...)
if err != nil {
return nil, err
}
x := &diffServiceCommitPatchClient{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 DiffService_CommitPatchClient interface {
Recv() (*CommitPatchResponse, error)
grpc.ClientStream
}
type diffServiceCommitPatchClient struct {
grpc.ClientStream
}
func (x *diffServiceCommitPatchClient) Recv() (*CommitPatchResponse, error) {
m := new(CommitPatchResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for DiffService service
type DiffServiceServer interface {
......@@ -446,6 +521,7 @@ type DiffServiceServer interface {
CommitDiff(*CommitDiffRequest, DiffService_CommitDiffServer) error
// Return a stream so we can divide the response in chunks of deltas
CommitDelta(*CommitDeltaRequest, DiffService_CommitDeltaServer) error
CommitPatch(*CommitPatchRequest, DiffService_CommitPatchServer) error
}
func RegisterDiffServiceServer(s *grpc.Server, srv DiffServiceServer) {
......@@ -494,6 +570,27 @@ func (x *diffServiceCommitDeltaServer) Send(m *CommitDeltaResponse) error {
return x.ServerStream.SendMsg(m)
}
func _DiffService_CommitPatch_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(CommitPatchRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(DiffServiceServer).CommitPatch(m, &diffServiceCommitPatchServer{stream})
}
type DiffService_CommitPatchServer interface {
Send(*CommitPatchResponse) error
grpc.ServerStream
}
type diffServiceCommitPatchServer struct {
grpc.ServerStream
}
func (x *diffServiceCommitPatchServer) Send(m *CommitPatchResponse) error {
return x.ServerStream.SendMsg(m)
}
var _DiffService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.DiffService",
HandlerType: (*DiffServiceServer)(nil),
......@@ -509,6 +606,11 @@ var _DiffService_serviceDesc = grpc.ServiceDesc{
Handler: _DiffService_CommitDelta_Handler,
ServerStreams: true,
},
{
StreamName: "CommitPatch",
Handler: _DiffService_CommitPatch_Handler,
ServerStreams: true,
},
},
Metadata: "diff.proto",
}
......@@ -516,45 +618,48 @@ var _DiffService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("diff.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 629 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0xcf, 0x6e, 0xdb, 0x38,
0x10, 0xc6, 0x57, 0xb1, 0xad, 0xc8, 0x63, 0x25, 0xd9, 0x65, 0x16, 0x59, 0xc5, 0xd9, 0x83, 0x60,
0xf4, 0x8f, 0x81, 0x02, 0x41, 0xe1, 0x5e, 0x7a, 0x4e, 0x82, 0x16, 0x09, 0x12, 0x34, 0x50, 0x0f,
0x3d, 0x0a, 0x8c, 0x38, 0xb2, 0x88, 0x4a, 0xa2, 0x4b, 0xb2, 0x71, 0xfc, 0x3a, 0xbd, 0xf4, 0xd2,
0x37, 0xea, 0xab, 0xf4, 0x50, 0x90, 0xb4, 0x64, 0xb9, 0xc8, 0x03, 0xe4, 0x38, 0xdf, 0xef, 0xd3,
0xcc, 0x68, 0x86, 0x24, 0x00, 0xe3, 0x79, 0x7e, 0xba, 0x90, 0x42, 0x0b, 0xe2, 0xcf, 0xb9, 0xa6,
0xe5, 0x6a, 0x1c, 0xaa, 0x82, 0x4a, 0x64, 0x4e, 0x9d, 0xfc, 0xea, 0xc1, 0x3f, 0xe7, 0xa2, 0xaa,
0xb8, 0xbe, 0xe0, 0x79, 0x9e, 0xe0, 0x97, 0xaf, 0xa8, 0x34, 0x99, 0x01, 0x48, 0x5c, 0x08, 0xc5,
0xb5, 0x90, 0xab, 0xc8, 0x8b, 0xbd, 0xe9, 0x68, 0x46, 0x4e, 0x5d, 0x82, 0xd3, 0xa4, 0x25, 0x49,
0xc7, 0x45, 0x9e, 0xc1, 0x7e, 0x89, 0xb9, 0x4e, 0x33, 0x9b, 0x2d, 0xe5, 0x2c, 0xda, 0x89, 0xbd,
0xe9, 0x30, 0x09, 0x8d, 0xea, 0x4a, 0x5c, 0x32, 0xf2, 0x02, 0x0e, 0x24, 0x9f, 0x17, 0x5d, 0x5b,
0xcf, 0xda, 0xf6, 0xac, 0xdc, 0xfa, 0xde, 0x42, 0xc4, 0xe7, 0xb5, 0x90, 0x98, 0x2e, 0x0b, 0xae,
0x51, 0x2d, 0x68, 0x86, 0x69, 0x56, 0xd0, 0x7a, 0x8e, 0x51, 0x3f, 0xf6, 0xa6, 0x41, 0x72, 0xe4,
0xf8, 0xa7, 0x16, 0x9f, 0x5b, 0x4a, 0xfe, 0x85, 0xc1, 0x82, 0xea, 0x42, 0x45, 0x83, 0xb8, 0x37,
0x0d, 0x13, 0x17, 0x90, 0xe7, 0xb0, 0x9f, 0x89, 0xb2, 0xa4, 0x0b, 0x85, 0xa9, 0x19, 0x8a, 0x8a,
0x7c, 0x9b, 0x65, 0xaf, 0x51, 0xcd, 0xef, 0x5b, 0x1b, 0xd6, 0xb9, 0x90, 0x19, 0xa6, 0x25, 0xaf,
0xb8, 0x56, 0xd1, 0xae, 0xb3, 0xad, 0xd5, 0x6b, 0x2b, 0x92, 0x13, 0x18, 0x56, 0xf4, 0x21, 0xcd,
0x79, 0x89, 0x2a, 0x0a, 0x62, 0x6f, 0x3a, 0x48, 0x82, 0x8a, 0x3e, 0xbc, 0x33, 0x71, 0x03, 0x4b,
0x5e, 0xa3, 0x8a, 0x86, 0x2d, 0xbc, 0x36, 0x71, 0x03, 0xef, 0x56, 0x1a, 0x55, 0x04, 0x2d, 0x3c,
0x33, 0xb1, 0x19, 0xa1, 0xa2, 0x39, 0xa6, 0x9b, 0xdc, 0x23, 0xeb, 0x08, 0x8d, 0x7a, 0xd3, 0xe4,
0xef, 0xba, 0x5c, 0x91, 0x70, 0xcb, 0xe5, 0x0a, 0x75, 0x5d, 0xae, 0xda, 0xde, 0x96, 0xcb, 0x56,
0x9c, 0xfc, 0xdc, 0x01, 0xd2, 0x5d, 0xbf, 0x5a, 0x88, 0x5a, 0xa1, 0xe9, 0x32, 0x97, 0xa2, 0x4a,
0xcd, 0xec, 0xec, 0xfa, 0xc3, 0x24, 0x30, 0xc2, 0x2d, 0xd5, 0x05, 0xf9, 0x0f, 0x76, 0xb5, 0x70,
0x68, 0xc7, 0x22, 0x5f, 0x8b, 0x06, 0xd8, 0xaf, 0xda, 0x9d, 0xfa, 0x26, 0xbc, 0x64, 0xe4, 0x10,
0x06, 0x5a, 0x18, 0xb9, 0x6f, 0xe5, 0xbe, 0x16, 0x97, 0x8c, 0x1c, 0x43, 0x20, 0x4a, 0x96, 0x56,
0x82, 0x61, 0x34, 0xb0, 0xad, 0xed, 0x8a, 0x92, 0xdd, 0x08, 0x86, 0x06, 0xd5, 0xb8, 0x74, 0xc8,
0x77, 0xa8, 0xc6, 0xa5, 0x45, 0x47, 0xe0, 0xdf, 0xf1, 0x9a, 0xca, 0xd5, 0x7a, 0x31, 0xeb, 0xc8,
0xfc, 0xae, 0xa4, 0x4b, 0xd3, 0x55, 0x56, 0xa4, 0x8c, 0x6a, 0x6a, 0x27, 0x1f, 0x26, 0xa1, 0xa4,
0xcb, 0x5b, 0x23, 0x5e, 0x50, 0x4d, 0x49, 0x0c, 0x21, 0xd6, 0x2c, 0x15, 0xb9, 0x33, 0xda, 0x05,
0x04, 0x09, 0x60, 0xcd, 0x3e, 0xe4, 0xd6, 0x45, 0x5e, 0xc2, 0x81, 0xb8, 0x47, 0x99, 0x97, 0x62,
0x99, 0x56, 0x54, 0x7e, 0x46, 0x69, 0x77, 0x10, 0x24, 0xfb, 0x8d, 0x7c, 0x63, 0x55, 0xf2, 0x3f,
0x0c, 0x9b, 0xa3, 0xc3, 0xec, 0x02, 0x82, 0x64, 0x23, 0x5c, 0xf5, 0x83, 0xe0, 0xef, 0xe1, 0xe4,
0x87, 0xd7, 0x4e, 0x17, 0x4b, 0x4d, 0x9f, 0xce, 0xed, 0x6a, 0xef, 0x48, 0xbf, 0x73, 0x47, 0x26,
0xdf, 0x3d, 0x18, 0x75, 0xda, 0x7d, 0xba, 0xa7, 0x60, 0x72, 0x06, 0x87, 0x5b, 0x73, 0x5d, 0x1f,
0xdb, 0x57, 0xe0, 0x33, 0x23, 0xa8, 0xc8, 0x8b, 0x7b, 0xd3, 0xd1, 0xec, 0xb0, 0x19, 0x6a, 0xd7,
0xbc, 0xb6, 0xcc, 0xbe, 0x79, 0x30, 0x32, 0x87, 0xfe, 0x23, 0xca, 0x7b, 0x9e, 0x21, 0x79, 0x0f,
0xb0, 0xb9, 0x09, 0xe4, 0xf8, 0x8f, 0x4f, 0x37, 0x8f, 0xe3, 0x78, 0xfc, 0x18, 0x72, 0x1d, 0x4c,
0xfe, 0x7a, 0xed, 0x91, 0xab, 0xed, 0x29, 0x8e, 0x1f, 0x6b, 0x62, 0x9d, 0xea, 0xe4, 0x51, 0xb6,
0xc9, 0x75, 0xe7, 0xdb, 0x57, 0xfa, 0xcd, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2a, 0x75, 0x5b,
0xf9, 0xc9, 0x05, 0x00, 0x00,
// 679 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0xc1, 0x6e, 0xdb, 0x38,
0x10, 0x5d, 0xc5, 0xb6, 0x22, 0x8f, 0x95, 0x64, 0x97, 0x59, 0x64, 0x15, 0x67, 0x0f, 0x86, 0xb0,
0xdb, 0xba, 0x28, 0x10, 0x14, 0xee, 0xa5, 0xe7, 0x24, 0x68, 0x91, 0x20, 0x41, 0x03, 0xf5, 0xd0,
0xa3, 0xc0, 0x98, 0x23, 0x9b, 0xa8, 0x24, 0xba, 0x24, 0x1b, 0xc7, 0x5f, 0xd4, 0x4b, 0xff, 0xa8,
0xff, 0xd0, 0x2f, 0xe8, 0xa1, 0x20, 0x29, 0xc9, 0x72, 0xe0, 0x5b, 0x2f, 0xb9, 0x79, 0xde, 0x7b,
0x9e, 0x21, 0xdf, 0xe3, 0xd8, 0x00, 0x8c, 0x67, 0xd9, 0xe9, 0x42, 0x0a, 0x2d, 0x88, 0x3f, 0xe3,
0x9a, 0xe6, 0xab, 0x61, 0xa8, 0xe6, 0x54, 0x22, 0x73, 0x68, 0xfc, 0xb3, 0x03, 0x7f, 0x9d, 0x8b,
0xa2, 0xe0, 0xfa, 0x82, 0x67, 0x59, 0x82, 0x9f, 0xbf, 0xa0, 0xd2, 0x64, 0x02, 0x20, 0x71, 0x21,
0x14, 0xd7, 0x42, 0xae, 0x22, 0x6f, 0xe4, 0x8d, 0x07, 0x13, 0x72, 0xea, 0x1a, 0x9c, 0x26, 0x0d,
0x93, 0xb4, 0x54, 0xe4, 0x3f, 0xd8, 0xcf, 0x31, 0xd3, 0xe9, 0xd4, 0x76, 0x4b, 0x39, 0x8b, 0x76,
0x46, 0xde, 0xb8, 0x9f, 0x84, 0x06, 0x75, 0x23, 0x2e, 0x19, 0x79, 0x06, 0x07, 0x92, 0xcf, 0xe6,
0x6d, 0x59, 0xc7, 0xca, 0xf6, 0x2c, 0xdc, 0xe8, 0xde, 0x40, 0xc4, 0x67, 0xa5, 0x90, 0x98, 0x2e,
0xe7, 0x5c, 0xa3, 0x5a, 0xd0, 0x29, 0xa6, 0xd3, 0x39, 0x2d, 0x67, 0x18, 0x75, 0x47, 0xde, 0x38,
0x48, 0x8e, 0x1c, 0xff, 0xb1, 0xa1, 0xcf, 0x2d, 0x4b, 0xfe, 0x86, 0xde, 0x82, 0xea, 0xb9, 0x8a,
0x7a, 0xa3, 0xce, 0x38, 0x4c, 0x5c, 0x41, 0xfe, 0x87, 0xfd, 0xa9, 0xc8, 0x73, 0xba, 0x50, 0x98,
0x1a, 0x53, 0x54, 0xe4, 0xdb, 0x2e, 0x7b, 0x35, 0x6a, 0xae, 0x6f, 0x65, 0x58, 0x66, 0x42, 0x4e,
0x31, 0xcd, 0x79, 0xc1, 0xb5, 0x8a, 0x76, 0x9d, 0xac, 0x42, 0xaf, 0x2d, 0x48, 0x4e, 0xa0, 0x5f,
0xd0, 0x87, 0x34, 0xe3, 0x39, 0xaa, 0x28, 0x18, 0x79, 0xe3, 0x5e, 0x12, 0x14, 0xf4, 0xe1, 0xad,
0xa9, 0x6b, 0x32, 0xe7, 0x25, 0xaa, 0xa8, 0xdf, 0x90, 0xd7, 0xa6, 0xae, 0xc9, 0xbb, 0x95, 0x46,
0x15, 0x41, 0x43, 0x9e, 0x99, 0xda, 0x58, 0xa8, 0x68, 0x86, 0xe9, 0xba, 0xf7, 0xc0, 0x2a, 0x42,
0x83, 0xde, 0xd4, 0xfd, 0xdb, 0x2a, 0x37, 0x24, 0xdc, 0x50, 0xb9, 0x41, 0x6d, 0x95, 0x9b, 0xb6,
0xb7, 0xa1, 0xb2, 0x13, 0xe3, 0xef, 0x3b, 0x40, 0xda, 0xf1, 0xab, 0x85, 0x28, 0x15, 0x9a, 0x53,
0x66, 0x52, 0x14, 0xa9, 0xf1, 0xce, 0xc6, 0x1f, 0x26, 0x81, 0x01, 0x6e, 0xa9, 0x9e, 0x93, 0x7f,
0x60, 0x57, 0x0b, 0x47, 0xed, 0x58, 0xca, 0xd7, 0xa2, 0x26, 0xec, 0xb7, 0x9a, 0x4c, 0x7d, 0x53,
0x5e, 0x32, 0x72, 0x08, 0x3d, 0x2d, 0x0c, 0xdc, 0xb5, 0x70, 0x57, 0x8b, 0x4b, 0x46, 0x8e, 0x21,
0x10, 0x39, 0x4b, 0x0b, 0xc1, 0x30, 0xea, 0xd9, 0xa3, 0xed, 0x8a, 0x9c, 0xdd, 0x08, 0x86, 0x86,
0x2a, 0x71, 0xe9, 0x28, 0xdf, 0x51, 0x25, 0x2e, 0x2d, 0x75, 0x04, 0xfe, 0x1d, 0x2f, 0xa9, 0x5c,
0x55, 0xc1, 0x54, 0x95, 0xb9, 0xae, 0xa4, 0x4b, 0x73, 0xaa, 0xe9, 0x3c, 0x65, 0x54, 0x53, 0xeb,
0x7c, 0x98, 0x84, 0x92, 0x2e, 0x6f, 0x0d, 0x78, 0x41, 0x35, 0x25, 0x23, 0x08, 0xb1, 0x64, 0xa9,
0xc8, 0x9c, 0xd0, 0x06, 0x10, 0x24, 0x80, 0x25, 0x7b, 0x9f, 0x59, 0x15, 0x79, 0x0e, 0x07, 0xe2,
0x1e, 0x65, 0x96, 0x8b, 0x65, 0x5a, 0x50, 0xf9, 0x09, 0xa5, 0xcd, 0x20, 0x48, 0xf6, 0x6b, 0xf8,
0xc6, 0xa2, 0xe4, 0x5f, 0xe8, 0xd7, 0x4f, 0x87, 0xd9, 0x00, 0x82, 0x64, 0x0d, 0x5c, 0x75, 0x83,
0xe0, 0xcf, 0x7e, 0xfc, 0xcd, 0x6b, 0xdc, 0xc5, 0x5c, 0xd3, 0xa7, 0xb3, 0x5d, 0xcd, 0x8e, 0x74,
0x5b, 0x3b, 0x12, 0x7f, 0xf5, 0x60, 0xd0, 0x3a, 0xee, 0xd3, 0x7d, 0x05, 0xf1, 0x19, 0x1c, 0x6e,
0xf8, 0x5a, 0x3d, 0xdb, 0x97, 0xe0, 0x33, 0x03, 0xa8, 0xc8, 0x1b, 0x75, 0xc6, 0x83, 0xc9, 0x61,
0x6d, 0x6a, 0x5b, 0x5c, 0x49, 0x62, 0x56, 0x67, 0x63, 0x83, 0xff, 0x9d, 0x6c, 0x86, 0x10, 0x48,
0xbc, 0xe7, 0x8a, 0x8b, 0xb2, 0xf2, 0xa2, 0xa9, 0xe3, 0x17, 0xf5, 0x49, 0xab, 0x29, 0xd5, 0x49,
0x09, 0x74, 0xed, 0x23, 0x75, 0xae, 0xda, 0xcf, 0x93, 0x1f, 0x1e, 0x0c, 0xcc, 0x16, 0x7e, 0x40,
0x79, 0xcf, 0xa7, 0x48, 0xde, 0x01, 0xac, 0x57, 0x93, 0x1c, 0x3f, 0xba, 0xcb, 0xfa, 0xd7, 0x7a,
0x38, 0xdc, 0x46, 0xb9, 0x41, 0xf1, 0x1f, 0xaf, 0x3c, 0x72, 0xb5, 0x19, 0xeb, 0x70, 0x9b, 0x2b,
0x55, 0xab, 0x93, 0xad, 0xdc, 0xb6, 0x5e, 0x6e, 0x5d, 0x1e, 0xf5, 0x6a, 0x5b, 0xf9, 0xb8, 0xd7,
0x86, 0x01, 0xa6, 0xd7, 0x9d, 0x6f, 0xff, 0x82, 0x5e, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x15,
0xae, 0x47, 0xd4, 0xa6, 0x06, 0x00, 0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/namespace.pb.go 0 → 100644
View file @ 3aef5f9a
// 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 fileDescriptor4, []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 fileDescriptor4, []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 fileDescriptor4, []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 fileDescriptor4, []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 fileDescriptor4, []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 fileDescriptor4, []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 fileDescriptor4, []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 fileDescriptor4, []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", fileDescriptor4) }
var fileDescriptor4 = []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,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go
View file @ 3aef5f9a
......@@ -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 fileDescriptor5, []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 fileDescriptor5, []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", fileDescriptor5) }
var fileDescriptor4 = []byte{
var fileDescriptor5 = []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,
......
vendor/gitlab.com/gitlab-org/gitaly-proto/go/operations.pb.go 0 → 100644
View file @ 3aef5f9a
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: operations.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 UserCreateBranchRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
BranchName []byte `protobuf:"bytes,2,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
User *User `protobuf:"bytes,3,opt,name=user" json:"user,omitempty"`
StartPoint []byte `protobuf:"bytes,4,opt,name=start_point,json=startPoint,proto3" json:"start_point,omitempty"`
}
func (m *UserCreateBranchRequest) Reset() { *m = UserCreateBranchRequest{} }
func (m *UserCreateBranchRequest) String() string { return proto.CompactTextString(m) }
func (*UserCreateBranchRequest) ProtoMessage() {}
func (*UserCreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
func (m *UserCreateBranchRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *UserCreateBranchRequest) GetBranchName() []byte {
if m != nil {
return m.BranchName
}
return nil
}
func (m *UserCreateBranchRequest) GetUser() *User {
if m != nil {
return m.User
}
return nil
}
func (m *UserCreateBranchRequest) GetStartPoint() []byte {
if m != nil {
return m.StartPoint
}
return nil
}
type UserCreateBranchResponse struct {
Branch *Branch `protobuf:"bytes,1,opt,name=branch" json:"branch,omitempty"`
}
func (m *UserCreateBranchResponse) Reset() { *m = UserCreateBranchResponse{} }
func (m *UserCreateBranchResponse) String() string { return proto.CompactTextString(m) }
func (*UserCreateBranchResponse) ProtoMessage() {}
func (*UserCreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
func (m *UserCreateBranchResponse) GetBranch() *Branch {
if m != nil {
return m.Branch
}
return nil
}
type UserDeleteTagRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
TagName []byte `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"`
User *User `protobuf:"bytes,3,opt,name=user" json:"user,omitempty"`
}
func (m *UserDeleteTagRequest) Reset() { *m = UserDeleteTagRequest{} }
func (m *UserDeleteTagRequest) String() string { return proto.CompactTextString(m) }
func (*UserDeleteTagRequest) ProtoMessage() {}
func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
func (m *UserDeleteTagRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *UserDeleteTagRequest) GetTagName() []byte {
if m != nil {
return m.TagName
}
return nil
}
func (m *UserDeleteTagRequest) GetUser() *User {
if m != nil {
return m.User
}
return nil
}
type UserDeleteTagResponse struct {
}
func (m *UserDeleteTagResponse) Reset() { *m = UserDeleteTagResponse{} }
func (m *UserDeleteTagResponse) String() string { return proto.CompactTextString(m) }
func (*UserDeleteTagResponse) ProtoMessage() {}
func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
func init() {
proto.RegisterType((*UserCreateBranchRequest)(nil), "gitaly.UserCreateBranchRequest")
proto.RegisterType((*UserCreateBranchResponse)(nil), "gitaly.UserCreateBranchResponse")
proto.RegisterType((*UserDeleteTagRequest)(nil), "gitaly.UserDeleteTagRequest")
proto.RegisterType((*UserDeleteTagResponse)(nil), "gitaly.UserDeleteTagResponse")
}
// 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 OperationService service
type OperationServiceClient interface {
UserCreateBranch(ctx context.Context, in *UserCreateBranchRequest, opts ...grpc.CallOption) (*UserCreateBranchResponse, error)
UserDeleteTag(ctx context.Context, in *UserDeleteTagRequest, opts ...grpc.CallOption) (*UserDeleteTagResponse, error)
}
type operationServiceClient struct {
cc *grpc.ClientConn
}
func NewOperationServiceClient(cc *grpc.ClientConn) OperationServiceClient {
return &operationServiceClient{cc}
}
func (c *operationServiceClient) UserCreateBranch(ctx context.Context, in *UserCreateBranchRequest, opts ...grpc.CallOption) (*UserCreateBranchResponse, error) {
out := new(UserCreateBranchResponse)
err := grpc.Invoke(ctx, "/gitaly.OperationService/UserCreateBranch", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operationServiceClient) UserDeleteTag(ctx context.Context, in *UserDeleteTagRequest, opts ...grpc.CallOption) (*UserDeleteTagResponse, error) {
out := new(UserDeleteTagResponse)
err := grpc.Invoke(ctx, "/gitaly.OperationService/UserDeleteTag", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for OperationService service
type OperationServiceServer interface {
UserCreateBranch(context.Context, *UserCreateBranchRequest) (*UserCreateBranchResponse, error)
UserDeleteTag(context.Context, *UserDeleteTagRequest) (*UserDeleteTagResponse, error)
}
func RegisterOperationServiceServer(s *grpc.Server, srv OperationServiceServer) {
s.RegisterService(&_OperationService_serviceDesc, srv)
}
func _OperationService_UserCreateBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UserCreateBranchRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperationServiceServer).UserCreateBranch(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.OperationService/UserCreateBranch",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperationServiceServer).UserCreateBranch(ctx, req.(*UserCreateBranchRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OperationService_UserDeleteTag_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UserDeleteTagRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperationServiceServer).UserDeleteTag(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.OperationService/UserDeleteTag",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperationServiceServer).UserDeleteTag(ctx, req.(*UserDeleteTagRequest))
}
return interceptor(ctx, in, info, handler)
}
var _OperationService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.OperationService",
HandlerType: (*OperationServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "UserCreateBranch",
Handler: _OperationService_UserCreateBranch_Handler,
},
{
MethodName: "UserDeleteTag",
Handler: _OperationService_UserDeleteTag_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "operations.proto",
}
func init() { proto.RegisterFile("operations.proto", fileDescriptor6) }
var fileDescriptor6 = []byte{
// 308 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xc1, 0x4a, 0xfb, 0x40,
0x10, 0xc6, 0xff, 0xfb, 0xb7, 0x54, 0x99, 0x46, 0x09, 0x8b, 0xd2, 0x18, 0x94, 0x86, 0x1c, 0xa4,
0xa7, 0x1c, 0xe2, 0x1b, 0x54, 0xcf, 0x55, 0xa2, 0xe2, 0xb1, 0x6c, 0xeb, 0x90, 0x06, 0xda, 0x6c,
0x9c, 0x9d, 0x0a, 0x7d, 0x02, 0x9f, 0xc7, 0xb3, 0x2f, 0x27, 0xc9, 0x26, 0x12, 0xa3, 0x05, 0xc1,
0xeb, 0xf7, 0x4d, 0x7e, 0xf3, 0x7d, 0x99, 0x05, 0x57, 0x17, 0x48, 0x8a, 0x33, 0x9d, 0x9b, 0xa8,
0x20, 0xcd, 0x5a, 0xf6, 0xd3, 0x8c, 0xd5, 0x6a, 0xeb, 0x3b, 0x66, 0xa9, 0x08, 0x9f, 0xac, 0x1a,
0xbe, 0x09, 0x18, 0x3e, 0x18, 0xa4, 0x2b, 0x42, 0xc5, 0x38, 0x21, 0x95, 0x2f, 0x96, 0x09, 0x3e,
0x6f, 0xd0, 0xb0, 0x8c, 0x01, 0x08, 0x0b, 0x6d, 0x32, 0xd6, 0xb4, 0xf5, 0x44, 0x20, 0xc6, 0x83,
0x58, 0x46, 0x16, 0x13, 0x25, 0x9f, 0x4e, 0xd2, 0x9a, 0x92, 0x23, 0x18, 0xcc, 0x2b, 0xc8, 0x2c,
0x57, 0x6b, 0xf4, 0xfe, 0x07, 0x62, 0xec, 0x24, 0x60, 0xa5, 0xa9, 0x5a, 0xa3, 0x0c, 0xa0, 0xb7,
0x31, 0x48, 0xde, 0x5e, 0x85, 0x73, 0x1a, 0x5c, 0x99, 0x21, 0xa9, 0x9c, 0x12, 0x61, 0x58, 0x11,
0xcf, 0x0a, 0x9d, 0xe5, 0xec, 0xf5, 0x2c, 0xa2, 0x92, 0x6e, 0x4b, 0x25, 0x9c, 0x80, 0xf7, 0x3d,
0xb2, 0x29, 0x74, 0x6e, 0x50, 0x5e, 0x40, 0xdf, 0x2e, 0xab, 0xf3, 0x1e, 0x35, 0x0b, 0xea, 0xb9,
0xda, 0x0d, 0x5f, 0x05, 0x1c, 0x97, 0x90, 0x6b, 0x5c, 0x21, 0xe3, 0xbd, 0x4a, 0xff, 0x52, 0xfa,
0x14, 0x0e, 0x58, 0xa5, 0xed, 0xc6, 0xfb, 0xac, 0xd2, 0xdf, 0xd5, 0x0d, 0x87, 0x70, 0xd2, 0x09,
0x62, 0xab, 0xc4, 0xef, 0x02, 0xdc, 0x9b, 0xe6, 0x8a, 0x77, 0x48, 0x2f, 0xd9, 0x02, 0xe5, 0x23,
0xb8, 0xdd, 0xee, 0x72, 0xd4, 0xa6, 0xfe, 0x70, 0x48, 0x3f, 0xd8, 0x3d, 0x60, 0x77, 0x85, 0xff,
0xe4, 0x14, 0x0e, 0xbf, 0xc4, 0x90, 0x67, 0xed, 0x8f, 0xba, 0xbf, 0xc9, 0x3f, 0xdf, 0xe1, 0x36,
0xbc, 0x79, 0xbf, 0x7a, 0x5f, 0x97, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x75, 0xe5, 0x7b,
0x89, 0x02, 0x00, 0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go
View file @ 3aef5f9a
......@@ -41,7 +41,36 @@ func (x FindLocalBranchesRequest_SortBy) String() string {
return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
}
func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
return fileDescriptor5, []int{8, 0}
return fileDescriptor7, []int{8, 0}
}
type CreateBranchResponse_Status int32
const (
CreateBranchResponse_OK CreateBranchResponse_Status = 0
CreateBranchResponse_ERR_EXISTS CreateBranchResponse_Status = 1
CreateBranchResponse_ERR_INVALID CreateBranchResponse_Status = 2
CreateBranchResponse_ERR_INVALID_START_POINT CreateBranchResponse_Status = 3
)
var CreateBranchResponse_Status_name = map[int32]string{
0: "OK",
1: "ERR_EXISTS",
2: "ERR_INVALID",
3: "ERR_INVALID_START_POINT",
}
var CreateBranchResponse_Status_value = map[string]int32{
"OK": 0,
"ERR_EXISTS": 1,
"ERR_INVALID": 2,
"ERR_INVALID_START_POINT": 3,
}
func (x CreateBranchResponse_Status) String() string {
return proto.EnumName(CreateBranchResponse_Status_name, int32(x))
}
func (CreateBranchResponse_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor7, []int{19, 0}
}
type FindDefaultBranchNameRequest struct {
......@@ -51,7 +80,7 @@ type FindDefaultBranchNameRequest struct {
func (m *FindDefaultBranchNameRequest) Reset() { *m = FindDefaultBranchNameRequest{} }
func (m *FindDefaultBranchNameRequest) String() string { return proto.CompactTextString(m) }
func (*FindDefaultBranchNameRequest) ProtoMessage() {}
func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
if m != nil {
......@@ -67,7 +96,7 @@ type FindDefaultBranchNameResponse struct {
func (m *FindDefaultBranchNameResponse) Reset() { *m = FindDefaultBranchNameResponse{} }
func (m *FindDefaultBranchNameResponse) String() string { return proto.CompactTextString(m) }
func (*FindDefaultBranchNameResponse) ProtoMessage() {}
func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
func (m *FindDefaultBranchNameResponse) GetName() []byte {
if m != nil {
......@@ -83,7 +112,7 @@ type FindAllBranchNamesRequest struct {
func (m *FindAllBranchNamesRequest) Reset() { *m = FindAllBranchNamesRequest{} }
func (m *FindAllBranchNamesRequest) String() string { return proto.CompactTextString(m) }
func (*FindAllBranchNamesRequest) ProtoMessage() {}
func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
if m != nil {
......@@ -99,7 +128,7 @@ type FindAllBranchNamesResponse struct {
func (m *FindAllBranchNamesResponse) Reset() { *m = FindAllBranchNamesResponse{} }
func (m *FindAllBranchNamesResponse) String() string { return proto.CompactTextString(m) }
func (*FindAllBranchNamesResponse) ProtoMessage() {}
func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
if m != nil {
......@@ -115,7 +144,7 @@ type FindAllTagNamesRequest struct {
func (m *FindAllTagNamesRequest) Reset() { *m = FindAllTagNamesRequest{} }
func (m *FindAllTagNamesRequest) String() string { return proto.CompactTextString(m) }
func (*FindAllTagNamesRequest) ProtoMessage() {}
func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{4} }
func (m *FindAllTagNamesRequest) GetRepository() *Repository {
if m != nil {
......@@ -131,7 +160,7 @@ type FindAllTagNamesResponse struct {
func (m *FindAllTagNamesResponse) Reset() { *m = FindAllTagNamesResponse{} }
func (m *FindAllTagNamesResponse) String() string { return proto.CompactTextString(m) }
func (*FindAllTagNamesResponse) ProtoMessage() {}
func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{5} }
func (m *FindAllTagNamesResponse) GetNames() [][]byte {
if m != nil {
......@@ -151,7 +180,7 @@ type FindRefNameRequest struct {
func (m *FindRefNameRequest) Reset() { *m = FindRefNameRequest{} }
func (m *FindRefNameRequest) String() string { return proto.CompactTextString(m) }
func (*FindRefNameRequest) ProtoMessage() {}
func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{6} }
func (m *FindRefNameRequest) GetRepository() *Repository {
if m != nil {
......@@ -182,7 +211,7 @@ type FindRefNameResponse struct {
func (m *FindRefNameResponse) Reset() { *m = FindRefNameResponse{} }
func (m *FindRefNameResponse) String() string { return proto.CompactTextString(m) }
func (*FindRefNameResponse) ProtoMessage() {}
func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{7} }
func (m *FindRefNameResponse) GetName() []byte {
if m != nil {
......@@ -199,7 +228,7 @@ type FindLocalBranchesRequest struct {
func (m *FindLocalBranchesRequest) Reset() { *m = FindLocalBranchesRequest{} }
func (m *FindLocalBranchesRequest) String() string { return proto.CompactTextString(m) }
func (*FindLocalBranchesRequest) ProtoMessage() {}
func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{8} }
func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{8} }
func (m *FindLocalBranchesRequest) GetRepository() *Repository {
if m != nil {
......@@ -222,7 +251,7 @@ type FindLocalBranchesResponse struct {
func (m *FindLocalBranchesResponse) Reset() { *m = FindLocalBranchesResponse{} }
func (m *FindLocalBranchesResponse) String() string { return proto.CompactTextString(m) }
func (*FindLocalBranchesResponse) ProtoMessage() {}
func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{9} }
func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{9} }
func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse {
if m != nil {
......@@ -242,7 +271,7 @@ type FindLocalBranchResponse struct {
func (m *FindLocalBranchResponse) Reset() { *m = FindLocalBranchResponse{} }
func (m *FindLocalBranchResponse) String() string { return proto.CompactTextString(m) }
func (*FindLocalBranchResponse) ProtoMessage() {}
func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{10} }
func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{10} }
func (m *FindLocalBranchResponse) GetName() []byte {
if m != nil {
......@@ -288,7 +317,7 @@ type FindLocalBranchCommitAuthor struct {
func (m *FindLocalBranchCommitAuthor) Reset() { *m = FindLocalBranchCommitAuthor{} }
func (m *FindLocalBranchCommitAuthor) String() string { return proto.CompactTextString(m) }
func (*FindLocalBranchCommitAuthor) ProtoMessage() {}
func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{11} }
func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{11} }
func (m *FindLocalBranchCommitAuthor) GetName() []byte {
if m != nil {
......@@ -318,7 +347,7 @@ type FindAllBranchesRequest struct {
func (m *FindAllBranchesRequest) Reset() { *m = FindAllBranchesRequest{} }
func (m *FindAllBranchesRequest) String() string { return proto.CompactTextString(m) }
func (*FindAllBranchesRequest) ProtoMessage() {}
func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{12} }
func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{12} }
func (m *FindAllBranchesRequest) GetRepository() *Repository {
if m != nil {
......@@ -334,7 +363,7 @@ type FindAllBranchesResponse struct {
func (m *FindAllBranchesResponse) Reset() { *m = FindAllBranchesResponse{} }
func (m *FindAllBranchesResponse) String() string { return proto.CompactTextString(m) }
func (*FindAllBranchesResponse) ProtoMessage() {}
func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{13} }
func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{13} }
func (m *FindAllBranchesResponse) GetBranches() []*FindAllBranchesResponse_Branch {
if m != nil {
......@@ -352,7 +381,7 @@ func (m *FindAllBranchesResponse_Branch) Reset() { *m = FindAllBranchesR
func (m *FindAllBranchesResponse_Branch) String() string { return proto.CompactTextString(m) }
func (*FindAllBranchesResponse_Branch) ProtoMessage() {}
func (*FindAllBranchesResponse_Branch) Descriptor() ([]byte, []int) {
return fileDescriptor5, []int{13, 0}
return fileDescriptor7, []int{13, 0}
}
func (m *FindAllBranchesResponse_Branch) GetName() []byte {
......@@ -376,7 +405,7 @@ type FindAllTagsRequest struct {
func (m *FindAllTagsRequest) Reset() { *m = FindAllTagsRequest{} }
func (m *FindAllTagsRequest) String() string { return proto.CompactTextString(m) }
func (*FindAllTagsRequest) ProtoMessage() {}
func (*FindAllTagsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{14} }
func (*FindAllTagsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{14} }
func (m *FindAllTagsRequest) GetRepository() *Repository {
if m != nil {
......@@ -392,7 +421,7 @@ type FindAllTagsResponse struct {
func (m *FindAllTagsResponse) Reset() { *m = FindAllTagsResponse{} }
func (m *FindAllTagsResponse) String() string { return proto.CompactTextString(m) }
func (*FindAllTagsResponse) ProtoMessage() {}
func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{15} }
func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{15} }
func (m *FindAllTagsResponse) GetTags() []*FindAllTagsResponse_Tag {
if m != nil {
......@@ -411,7 +440,7 @@ type FindAllTagsResponse_Tag struct {
func (m *FindAllTagsResponse_Tag) Reset() { *m = FindAllTagsResponse_Tag{} }
func (m *FindAllTagsResponse_Tag) String() string { return proto.CompactTextString(m) }
func (*FindAllTagsResponse_Tag) ProtoMessage() {}
func (*FindAllTagsResponse_Tag) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{15, 0} }
func (*FindAllTagsResponse_Tag) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{15, 0} }
func (m *FindAllTagsResponse_Tag) GetName() []byte {
if m != nil {
......@@ -450,7 +479,7 @@ type RefExistsRequest struct {
func (m *RefExistsRequest) Reset() { *m = RefExistsRequest{} }
func (m *RefExistsRequest) String() string { return proto.CompactTextString(m) }
func (*RefExistsRequest) ProtoMessage() {}
func (*RefExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{16} }
func (*RefExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{16} }
func (m *RefExistsRequest) GetRepository() *Repository {
if m != nil {
......@@ -473,7 +502,7 @@ type RefExistsResponse struct {
func (m *RefExistsResponse) Reset() { *m = RefExistsResponse{} }
func (m *RefExistsResponse) String() string { return proto.CompactTextString(m) }
func (*RefExistsResponse) ProtoMessage() {}
func (*RefExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{17} }
func (*RefExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{17} }
func (m *RefExistsResponse) GetValue() bool {
if m != nil {
......@@ -482,6 +511,136 @@ func (m *RefExistsResponse) GetValue() bool {
return false
}
type CreateBranchRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Name []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
StartPoint []byte `protobuf:"bytes,3,opt,name=start_point,json=startPoint,proto3" json:"start_point,omitempty"`
}
func (m *CreateBranchRequest) Reset() { *m = CreateBranchRequest{} }
func (m *CreateBranchRequest) String() string { return proto.CompactTextString(m) }
func (*CreateBranchRequest) ProtoMessage() {}
func (*CreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{18} }
func (m *CreateBranchRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *CreateBranchRequest) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
func (m *CreateBranchRequest) GetStartPoint() []byte {
if m != nil {
return m.StartPoint
}
return nil
}
type CreateBranchResponse struct {
Status CreateBranchResponse_Status `protobuf:"varint,1,opt,name=status,enum=gitaly.CreateBranchResponse_Status" json:"status,omitempty"`
Branch *Branch `protobuf:"bytes,2,opt,name=branch" json:"branch,omitempty"`
}
func (m *CreateBranchResponse) Reset() { *m = CreateBranchResponse{} }
func (m *CreateBranchResponse) String() string { return proto.CompactTextString(m) }
func (*CreateBranchResponse) ProtoMessage() {}
func (*CreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{19} }
func (m *CreateBranchResponse) GetStatus() CreateBranchResponse_Status {
if m != nil {
return m.Status
}
return CreateBranchResponse_OK
}
func (m *CreateBranchResponse) GetBranch() *Branch {
if m != nil {
return m.Branch
}
return nil
}
type DeleteBranchRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Name []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}
func (m *DeleteBranchRequest) Reset() { *m = DeleteBranchRequest{} }
func (m *DeleteBranchRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteBranchRequest) ProtoMessage() {}
func (*DeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{20} }
func (m *DeleteBranchRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *DeleteBranchRequest) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
// Not clear if we need to do status signaling; we can add fields later.
type DeleteBranchResponse struct {
}
func (m *DeleteBranchResponse) Reset() { *m = DeleteBranchResponse{} }
func (m *DeleteBranchResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteBranchResponse) ProtoMessage() {}
func (*DeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{21} }
type FindBranchRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// Name can be 'master' but also 'refs/heads/master'
Name []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}
func (m *FindBranchRequest) Reset() { *m = FindBranchRequest{} }
func (m *FindBranchRequest) String() string { return proto.CompactTextString(m) }
func (*FindBranchRequest) ProtoMessage() {}
func (*FindBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{22} }
func (m *FindBranchRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *FindBranchRequest) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
type FindBranchResponse struct {
Branch *Branch `protobuf:"bytes,1,opt,name=branch" json:"branch,omitempty"`
}
func (m *FindBranchResponse) Reset() { *m = FindBranchResponse{} }
func (m *FindBranchResponse) String() string { return proto.CompactTextString(m) }
func (*FindBranchResponse) ProtoMessage() {}
func (*FindBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{23} }
func (m *FindBranchResponse) GetBranch() *Branch {
if m != nil {
return m.Branch
}
return nil
}
func init() {
proto.RegisterType((*FindDefaultBranchNameRequest)(nil), "gitaly.FindDefaultBranchNameRequest")
proto.RegisterType((*FindDefaultBranchNameResponse)(nil), "gitaly.FindDefaultBranchNameResponse")
......@@ -503,7 +662,14 @@ func init() {
proto.RegisterType((*FindAllTagsResponse_Tag)(nil), "gitaly.FindAllTagsResponse.Tag")
proto.RegisterType((*RefExistsRequest)(nil), "gitaly.RefExistsRequest")
proto.RegisterType((*RefExistsResponse)(nil), "gitaly.RefExistsResponse")
proto.RegisterType((*CreateBranchRequest)(nil), "gitaly.CreateBranchRequest")
proto.RegisterType((*CreateBranchResponse)(nil), "gitaly.CreateBranchResponse")
proto.RegisterType((*DeleteBranchRequest)(nil), "gitaly.DeleteBranchRequest")
proto.RegisterType((*DeleteBranchResponse)(nil), "gitaly.DeleteBranchResponse")
proto.RegisterType((*FindBranchRequest)(nil), "gitaly.FindBranchRequest")
proto.RegisterType((*FindBranchResponse)(nil), "gitaly.FindBranchResponse")
proto.RegisterEnum("gitaly.FindLocalBranchesRequest_SortBy", FindLocalBranchesRequest_SortBy_name, FindLocalBranchesRequest_SortBy_value)
proto.RegisterEnum("gitaly.CreateBranchResponse_Status", CreateBranchResponse_Status_name, CreateBranchResponse_Status_value)
}
// Reference imports to suppress errors if they are not otherwise used.
......@@ -527,6 +693,9 @@ type RefServiceClient interface {
FindAllBranches(ctx context.Context, in *FindAllBranchesRequest, opts ...grpc.CallOption) (RefService_FindAllBranchesClient, error)
FindAllTags(ctx context.Context, in *FindAllTagsRequest, opts ...grpc.CallOption) (RefService_FindAllTagsClient, error)
RefExists(ctx context.Context, in *RefExistsRequest, opts ...grpc.CallOption) (*RefExistsResponse, error)
CreateBranch(ctx context.Context, in *CreateBranchRequest, opts ...grpc.CallOption) (*CreateBranchResponse, error)
DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*DeleteBranchResponse, error)
FindBranch(ctx context.Context, in *FindBranchRequest, opts ...grpc.CallOption) (*FindBranchResponse, error)
}
type refServiceClient struct {
......@@ -724,6 +893,33 @@ func (c *refServiceClient) RefExists(ctx context.Context, in *RefExistsRequest,
return out, nil
}
func (c *refServiceClient) CreateBranch(ctx context.Context, in *CreateBranchRequest, opts ...grpc.CallOption) (*CreateBranchResponse, error) {
out := new(CreateBranchResponse)
err := grpc.Invoke(ctx, "/gitaly.RefService/CreateBranch", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *refServiceClient) DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*DeleteBranchResponse, error) {
out := new(DeleteBranchResponse)
err := grpc.Invoke(ctx, "/gitaly.RefService/DeleteBranch", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *refServiceClient) FindBranch(ctx context.Context, in *FindBranchRequest, opts ...grpc.CallOption) (*FindBranchResponse, error) {
out := new(FindBranchResponse)
err := grpc.Invoke(ctx, "/gitaly.RefService/FindBranch", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for RefService service
type RefServiceServer interface {
......@@ -737,6 +933,9 @@ type RefServiceServer interface {
FindAllBranches(*FindAllBranchesRequest, RefService_FindAllBranchesServer) error
FindAllTags(*FindAllTagsRequest, RefService_FindAllTagsServer) error
RefExists(context.Context, *RefExistsRequest) (*RefExistsResponse, error)
CreateBranch(context.Context, *CreateBranchRequest) (*CreateBranchResponse, error)
DeleteBranch(context.Context, *DeleteBranchRequest) (*DeleteBranchResponse, error)
FindBranch(context.Context, *FindBranchRequest) (*FindBranchResponse, error)
}
func RegisterRefServiceServer(s *grpc.Server, srv RefServiceServer) {
......@@ -902,6 +1101,60 @@ func _RefService_RefExists_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
func _RefService_CreateBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateBranchRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RefServiceServer).CreateBranch(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RefService/CreateBranch",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RefServiceServer).CreateBranch(ctx, req.(*CreateBranchRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RefService_DeleteBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteBranchRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RefServiceServer).DeleteBranch(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RefService/DeleteBranch",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RefServiceServer).DeleteBranch(ctx, req.(*DeleteBranchRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RefService_FindBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FindBranchRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RefServiceServer).FindBranch(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RefService/FindBranch",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RefServiceServer).FindBranch(ctx, req.(*FindBranchRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RefService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.RefService",
HandlerType: (*RefServiceServer)(nil),
......@@ -918,6 +1171,18 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
MethodName: "RefExists",
Handler: _RefService_RefExists_Handler,
},
{
MethodName: "CreateBranch",
Handler: _RefService_CreateBranch_Handler,
},
{
MethodName: "DeleteBranch",
Handler: _RefService_DeleteBranch_Handler,
},
{
MethodName: "FindBranch",
Handler: _RefService_FindBranch_Handler,
},
},
Streams: []grpc.StreamDesc{
{
......@@ -949,61 +1214,74 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
Metadata: "ref.proto",
}
func init() { proto.RegisterFile("ref.proto", fileDescriptor5) }
var fileDescriptor5 = []byte{
// 833 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0x5e, 0xe7, 0x6f, 0x93, 0x13, 0x6f, 0x9b, 0x0e, 0xcb, 0xe2, 0x75, 0x61, 0x9b, 0x1a, 0x0a,
0xed, 0x8d, 0x8b, 0x5c, 0xc1, 0x0d, 0x37, 0xe4, 0x8f, 0x16, 0x54, 0x0a, 0x9a, 0x04, 0xd4, 0x0b,
0xa4, 0x68, 0x92, 0x8c, 0x5d, 0xa3, 0x38, 0x0e, 0xf6, 0xa4, 0x34, 0x42, 0x3c, 0x01, 0xef, 0xc1,
0x5b, 0x70, 0xdd, 0xd7, 0x42, 0x99, 0x19, 0xbb, 0x4e, 0x32, 0x49, 0x91, 0xc2, 0x95, 0x7d, 0xce,
0x7c, 0xe7, 0x9b, 0x39, 0xff, 0x50, 0x89, 0xa8, 0x6b, 0x4f, 0xa3, 0x90, 0x85, 0xa8, 0xe4, 0xf9,
0x8c, 0x8c, 0xe7, 0xa6, 0x1e, 0xdf, 0x91, 0x88, 0x8e, 0x84, 0xd6, 0x3c, 0xf2, 0xc2, 0xd0, 0x1b,
0xd3, 0x73, 0x2e, 0x0d, 0x66, 0xee, 0x39, 0xf3, 0x03, 0x1a, 0x33, 0x12, 0x4c, 0x05, 0xc0, 0xc2,
0xf0, 0xe1, 0x37, 0xfe, 0x64, 0xd4, 0xa6, 0x2e, 0x99, 0x8d, 0x59, 0x33, 0x22, 0x93, 0xe1, 0xdd,
0x0d, 0x09, 0x28, 0xa6, 0xbf, 0xcd, 0x68, 0xcc, 0x90, 0x03, 0x10, 0xd1, 0x69, 0x18, 0xfb, 0x2c,
0x8c, 0xe6, 0x86, 0x56, 0xd7, 0x4e, 0xab, 0x0e, 0xb2, 0xc5, 0x5d, 0x36, 0x4e, 0x4f, 0x70, 0x06,
0x65, 0x5d, 0xc0, 0x47, 0x1b, 0x38, 0xe3, 0x69, 0x38, 0x89, 0x29, 0x42, 0x50, 0x98, 0x90, 0x80,
0x72, 0x3a, 0x1d, 0xf3, 0x7f, 0xeb, 0x07, 0x78, 0xbb, 0x30, 0x6a, 0x8c, 0xc7, 0x4f, 0x06, 0xf1,
0x2e, 0xaf, 0x70, 0xc0, 0x54, 0x11, 0xca, 0x27, 0xbc, 0x86, 0xe2, 0xe2, 0xda, 0xd8, 0xd0, 0xea,
0xf9, 0x53, 0x1d, 0x0b, 0xc1, 0xba, 0x86, 0x37, 0xd2, 0xa6, 0x47, 0xbc, 0x9d, 0x5f, 0x70, 0x0e,
0x1f, 0xac, 0xb1, 0x6d, 0xbd, 0xfe, 0x4f, 0x40, 0x0b, 0x03, 0x4c, 0xdd, 0x1d, 0x53, 0x80, 0x0e,
0xa1, 0x32, 0x0c, 0x83, 0xc0, 0x67, 0x7d, 0x7f, 0x64, 0xe4, 0xea, 0xda, 0x69, 0x05, 0x97, 0x85,
0xe2, 0xdb, 0x11, 0x7a, 0x03, 0xa5, 0x69, 0x44, 0x5d, 0xff, 0xc1, 0xc8, 0xf3, 0x04, 0x48, 0xc9,
0x3a, 0x83, 0xf7, 0x96, 0xae, 0xdf, 0x92, 0xad, 0x47, 0x0d, 0x8c, 0x05, 0xf6, 0x3a, 0x1c, 0x12,
0x19, 0xdf, 0x9d, 0x62, 0x85, 0xbe, 0x86, 0x97, 0x71, 0x18, 0xb1, 0xfe, 0x60, 0xce, 0x9f, 0xbb,
0xe7, 0x7c, 0x96, 0x18, 0x6c, 0xba, 0xc6, 0xee, 0x86, 0x11, 0x6b, 0xce, 0x71, 0x29, 0xe6, 0x5f,
0xeb, 0x0b, 0x28, 0x09, 0x0d, 0x2a, 0x43, 0xe1, 0xa6, 0xf1, 0x7d, 0xa7, 0xf6, 0x02, 0xed, 0x43,
0xf5, 0xa7, 0x1f, 0xdb, 0x8d, 0x5e, 0xa7, 0xdd, 0x6f, 0x74, 0x5b, 0x35, 0x0d, 0xd5, 0x40, 0x4f,
0x14, 0xed, 0x4e, 0xb7, 0x55, 0xcb, 0x59, 0xb7, 0xa2, 0xee, 0x56, 0x6e, 0x90, 0xae, 0x7f, 0x05,
0xe5, 0x81, 0xd4, 0xf1, 0x4c, 0x55, 0x9d, 0xa3, 0x0d, 0xcf, 0x4a, 0x4c, 0x70, 0x6a, 0x60, 0xfd,
0x95, 0x13, 0xf9, 0x57, 0xa0, 0x54, 0x31, 0xdd, 0x9e, 0xb3, 0x13, 0xd8, 0x93, 0x87, 0xf1, 0x6c,
0xf0, 0x2b, 0x1d, 0x32, 0x99, 0xbb, 0x57, 0x42, 0xdb, 0x15, 0x4a, 0x74, 0x05, 0x52, 0xd1, 0x27,
0x33, 0x76, 0x17, 0x46, 0x46, 0x81, 0x47, 0xff, 0xe3, 0x0d, 0xaf, 0x6e, 0x71, 0x6c, 0x83, 0x43,
0xb1, 0x3e, 0xcc, 0x48, 0xe8, 0x06, 0x6a, 0x92, 0x49, 0x7c, 0x18, 0x8d, 0x8c, 0xe2, 0x7f, 0x27,
0xdb, 0x17, 0x56, 0xad, 0xc4, 0xd6, 0xfa, 0x1d, 0x0e, 0xb7, 0xe0, 0x95, 0x01, 0x79, 0x0d, 0x45,
0x1a, 0x10, 0x7f, 0xcc, 0x83, 0xa1, 0x63, 0x21, 0x20, 0x1b, 0x0a, 0x23, 0xc2, 0x28, 0xf7, 0xbf,
0xea, 0x98, 0xb6, 0x98, 0x70, 0x76, 0x32, 0xe1, 0xec, 0x5e, 0x32, 0xe1, 0x30, 0xc7, 0x65, 0x7a,
0xfa, 0x7f, 0xa8, 0x53, 0xeb, 0x6f, 0x2d, 0x6d, 0xea, 0xb5, 0x6a, 0x69, 0xae, 0x55, 0xcb, 0xa7,
0xd9, 0x50, 0x29, 0x4c, 0x6c, 0x59, 0x16, 0xa9, 0x9d, 0x79, 0x09, 0x25, 0xa1, 0x53, 0x46, 0xe4,
0x0c, 0x4a, 0x8c, 0x44, 0x1e, 0x65, 0x3c, 0x24, 0x55, 0xe7, 0x20, 0xe1, 0xbf, 0x4c, 0x42, 0x8d,
0x25, 0xc0, 0xba, 0x12, 0xb3, 0x44, 0x0c, 0x9f, 0x9d, 0x5c, 0x7e, 0xd4, 0xc4, 0x5c, 0x48, 0xa9,
0xa4, 0xbb, 0x17, 0x50, 0x60, 0xc4, 0x53, 0x36, 0xc6, 0x0a, 0xd4, 0xee, 0x11, 0x0f, 0x73, 0xb0,
0xf9, 0x07, 0xe4, 0x7b, 0xc4, 0x53, 0x3a, 0xb7, 0x07, 0xb9, 0xb4, 0xf0, 0x73, 0xfe, 0x08, 0x7d,
0x09, 0xaf, 0x84, 0x2f, 0xb2, 0x02, 0x65, 0xc6, 0x15, 0x3e, 0xeb, 0x02, 0x27, 0x24, 0x64, 0xc0,
0xcb, 0x80, 0xc6, 0x31, 0xf1, 0x28, 0xaf, 0x7e, 0x1d, 0x27, 0xa2, 0x75, 0x0b, 0x35, 0x4c, 0xdd,
0xce, 0x83, 0x1f, 0xb3, 0x9d, 0x86, 0x55, 0x0d, 0xf2, 0x11, 0x75, 0x65, 0x59, 0x2e, 0x7e, 0xad,
0x33, 0x38, 0xc8, 0x30, 0x3f, 0x0d, 0xf9, 0x7b, 0x32, 0x9e, 0x09, 0x2f, 0xcb, 0x58, 0x08, 0xce,
0x3f, 0x45, 0x00, 0x4c, 0xdd, 0x2e, 0x8d, 0xee, 0xfd, 0x21, 0x45, 0x2e, 0xbc, 0xaf, 0x5c, 0x96,
0xe8, 0x93, 0x6c, 0x40, 0x37, 0xed, 0x67, 0xf3, 0xe4, 0x19, 0x94, 0x78, 0x8a, 0xf5, 0x02, 0xf5,
0xd3, 0x7a, 0xc8, 0xac, 0x43, 0x74, 0xac, 0x2c, 0xd0, 0xec, 0xe6, 0x33, 0xad, 0x6d, 0x90, 0x84,
0xfe, 0x73, 0x0d, 0xfd, 0x0c, 0xfb, 0x2b, 0xdb, 0x0e, 0xbd, 0x5b, 0xaf, 0x89, 0x25, 0xea, 0xa3,
0x8d, 0xe7, 0x19, 0xde, 0x2b, 0xa8, 0x66, 0xb6, 0x12, 0x32, 0xb3, 0x36, 0xcb, 0x9b, 0xd2, 0x3c,
0x54, 0x9e, 0xa5, 0x21, 0xf8, 0x05, 0x0e, 0xd6, 0x46, 0x3d, 0xaa, 0x3f, 0xb7, 0x67, 0xcc, 0xe3,
0x2d, 0x08, 0xa5, 0xff, 0x29, 0xf7, 0xbb, 0x8d, 0xed, 0xaf, 0xf6, 0x5f, 0xc9, 0xfb, 0x9d, 0xf0,
0x5f, 0xb6, 0xd4, 0xb2, 0xff, 0xcb, 0xdd, 0xbd, 0xec, 0xff, 0x4a, 0x0f, 0x72, 0xae, 0x26, 0x54,
0xd2, 0x32, 0x45, 0xc6, 0x53, 0x95, 0x2f, 0xf7, 0x84, 0xf9, 0x56, 0x71, 0x92, 0xb0, 0x0c, 0x4a,
0x7c, 0xd2, 0x5e, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x21, 0xf9, 0x20, 0xe0, 0x7c, 0x0a, 0x00,
0x00,
func init() { proto.RegisterFile("ref.proto", fileDescriptor7) }
var fileDescriptor7 = []byte{
// 1053 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x51, 0x73, 0x22, 0x45,
0x10, 0xce, 0x12, 0x6e, 0x93, 0x34, 0x1c, 0xd9, 0x4c, 0x62, 0x8e, 0x2c, 0xe7, 0x25, 0x37, 0x7a,
0x67, 0xf2, 0xb2, 0xb1, 0x48, 0xe9, 0x8b, 0x3e, 0x48, 0x00, 0x2f, 0x78, 0x91, 0xa4, 0x06, 0xbc,
0x4a, 0x95, 0x5a, 0xd4, 0x00, 0x03, 0x59, 0x0b, 0x58, 0xdc, 0x1d, 0xce, 0x4b, 0x59, 0xfa, 0x07,
0xfc, 0x0f, 0x3e, 0xfa, 0x57, 0xee, 0xc1, 0x3f, 0x65, 0x31, 0x33, 0xbb, 0xec, 0x92, 0x81, 0xb3,
0xc4, 0x7b, 0x82, 0xe9, 0xe9, 0xfe, 0x66, 0xfa, 0x9b, 0xee, 0x6f, 0x1b, 0xb6, 0x7c, 0xd6, 0x73,
0xc6, 0xbe, 0xc7, 0x3d, 0x64, 0xf6, 0x5d, 0x4e, 0x07, 0x77, 0x76, 0x36, 0xb8, 0xa5, 0x3e, 0xeb,
0x4a, 0xab, 0x7d, 0xd8, 0xf7, 0xbc, 0xfe, 0x80, 0x9d, 0x8a, 0x55, 0x7b, 0xd2, 0x3b, 0xe5, 0xee,
0x90, 0x05, 0x9c, 0x0e, 0xc7, 0xd2, 0x01, 0x13, 0x78, 0xfc, 0xb5, 0x3b, 0xea, 0x56, 0x58, 0x8f,
0x4e, 0x06, 0xfc, 0xdc, 0xa7, 0xa3, 0xce, 0x6d, 0x9d, 0x0e, 0x19, 0x61, 0x3f, 0x4f, 0x58, 0xc0,
0x51, 0x11, 0xc0, 0x67, 0x63, 0x2f, 0x70, 0xb9, 0xe7, 0xdf, 0xe5, 0x8d, 0x23, 0xe3, 0x38, 0x53,
0x44, 0x8e, 0x3c, 0xcb, 0x21, 0xd1, 0x0e, 0x89, 0x79, 0xe1, 0x33, 0xf8, 0x70, 0x01, 0x66, 0x30,
0xf6, 0x46, 0x01, 0x43, 0x08, 0xd2, 0x23, 0x3a, 0x64, 0x02, 0x2e, 0x4b, 0xc4, 0x7f, 0x7c, 0x05,
0x07, 0xd3, 0xa0, 0xd2, 0x60, 0x30, 0x0b, 0x08, 0x56, 0xb9, 0x45, 0x11, 0x6c, 0x1d, 0xa0, 0xba,
0xc2, 0x1e, 0x3c, 0x98, 0x1e, 0x1b, 0xe4, 0x8d, 0xa3, 0xf5, 0xe3, 0x2c, 0x91, 0x0b, 0x7c, 0x09,
0xfb, 0x2a, 0xa6, 0x49, 0xfb, 0x2b, 0xdf, 0xe0, 0x14, 0x1e, 0xdd, 0x43, 0x5b, 0x7a, 0xfc, 0x6f,
0x80, 0xa6, 0x01, 0x84, 0xf5, 0x56, 0x7c, 0x02, 0x54, 0x80, 0xad, 0x8e, 0x37, 0x1c, 0xba, 0xbc,
0xe5, 0x76, 0xf3, 0xa9, 0x23, 0xe3, 0x78, 0x8b, 0x6c, 0x4a, 0x43, 0xad, 0x8b, 0xf6, 0xc1, 0x1c,
0xfb, 0xac, 0xe7, 0xbe, 0xc9, 0xaf, 0x8b, 0x07, 0x50, 0x2b, 0x7c, 0x02, 0xbb, 0x89, 0xe3, 0x97,
0xbc, 0xd6, 0x5b, 0x03, 0xf2, 0x53, 0xdf, 0x4b, 0xaf, 0x43, 0x15, 0xbf, 0x2b, 0x71, 0x85, 0xbe,
0x82, 0x8d, 0xc0, 0xf3, 0x79, 0xab, 0x7d, 0x27, 0xae, 0x9b, 0x2b, 0x7e, 0x12, 0x06, 0x2c, 0x3a,
0xc6, 0x69, 0x78, 0x3e, 0x3f, 0xbf, 0x23, 0x66, 0x20, 0x7e, 0xf1, 0x67, 0x60, 0x4a, 0x0b, 0xda,
0x84, 0x74, 0xbd, 0xf4, 0x6d, 0xd5, 0x5a, 0x43, 0xdb, 0x90, 0xf9, 0xee, 0xba, 0x52, 0x6a, 0x56,
0x2b, 0xad, 0x52, 0xa3, 0x6c, 0x19, 0xc8, 0x82, 0x6c, 0x68, 0xa8, 0x54, 0x1b, 0x65, 0x2b, 0x85,
0x6f, 0x64, 0xdd, 0xcd, 0x9d, 0xa0, 0x52, 0xff, 0x02, 0x36, 0xdb, 0xca, 0x26, 0x5e, 0x2a, 0x53,
0x3c, 0x5c, 0x70, 0xad, 0x30, 0x84, 0x44, 0x01, 0xf8, 0x8f, 0x94, 0x7c, 0x7f, 0x8d, 0x97, 0x8e,
0xd3, 0xe5, 0x6f, 0xf6, 0x0c, 0x72, 0x6a, 0x33, 0x98, 0xb4, 0x7f, 0x62, 0x1d, 0xae, 0xde, 0xee,
0xa1, 0xb4, 0x36, 0xa4, 0x11, 0x5d, 0x80, 0x32, 0xb4, 0xe8, 0x84, 0xdf, 0x7a, 0x7e, 0x3e, 0x2d,
0xd8, 0xff, 0x68, 0xc1, 0xad, 0xcb, 0xc2, 0xb7, 0x24, 0x5c, 0x49, 0xb6, 0x13, 0x5b, 0xa1, 0x3a,
0x58, 0x0a, 0x49, 0xfe, 0x70, 0xe6, 0xe7, 0x1f, 0xfc, 0x7b, 0xb0, 0x6d, 0x19, 0x55, 0x0e, 0x63,
0xf1, 0x2f, 0x50, 0x58, 0xe2, 0xaf, 0x25, 0x64, 0x0f, 0x1e, 0xb0, 0x21, 0x75, 0x07, 0x82, 0x8c,
0x2c, 0x91, 0x0b, 0xe4, 0x40, 0xba, 0x4b, 0x39, 0x13, 0xf9, 0x67, 0x8a, 0xb6, 0x23, 0x15, 0xce,
0x09, 0x15, 0xce, 0x69, 0x86, 0x0a, 0x47, 0x84, 0x5f, 0xac, 0xa7, 0xff, 0x87, 0x3a, 0xc5, 0x7f,
0x19, 0x51, 0x53, 0xdf, 0xab, 0x96, 0xf3, 0x7b, 0xd5, 0xf2, 0x3c, 0x4e, 0x95, 0x26, 0xc4, 0x51,
0x65, 0x11, 0xc5, 0xd9, 0x2f, 0xc0, 0x94, 0x36, 0x2d, 0x23, 0x27, 0x60, 0x72, 0xea, 0xf7, 0x19,
0x17, 0x94, 0x64, 0x8a, 0x3b, 0x21, 0xfe, 0x8b, 0x90, 0x6a, 0xa2, 0x1c, 0xf0, 0x85, 0xd4, 0x12,
0x29, 0x3e, 0x2b, 0xa5, 0xfc, 0xd6, 0x90, 0xba, 0x10, 0x41, 0xa9, 0x74, 0xcf, 0x20, 0xcd, 0x69,
0x5f, 0xdb, 0x18, 0x73, 0xae, 0x4e, 0x93, 0xf6, 0x89, 0x70, 0xb6, 0x7f, 0x85, 0xf5, 0x26, 0xed,
0x6b, 0x93, 0xcb, 0x41, 0x2a, 0x2a, 0xfc, 0x94, 0xdb, 0x45, 0x9f, 0xc3, 0x43, 0x99, 0x8b, 0xaa,
0x40, 0xf5, 0xe2, 0x9a, 0x9c, 0xb3, 0xd2, 0x4f, 0xae, 0x50, 0x1e, 0x36, 0x86, 0x2c, 0x08, 0x68,
0x9f, 0x89, 0xea, 0xcf, 0x92, 0x70, 0x89, 0x6f, 0xc0, 0x22, 0xac, 0x57, 0x7d, 0xe3, 0x06, 0x7c,
0x25, 0xb1, 0xb2, 0x60, 0xdd, 0x67, 0x3d, 0x55, 0x96, 0xd3, 0xbf, 0xf8, 0x04, 0x76, 0x62, 0xc8,
0x33, 0x91, 0x7f, 0x4d, 0x07, 0x13, 0x99, 0xe5, 0x26, 0x91, 0x0b, 0xfc, 0x3b, 0xec, 0x96, 0x7d,
0x46, 0x39, 0x0b, 0x25, 0xe1, 0xbf, 0xdf, 0x23, 0x64, 0x31, 0x15, 0x63, 0xf1, 0x10, 0x32, 0x01,
0xa7, 0x3e, 0x6f, 0x8d, 0x3d, 0x77, 0x14, 0xaa, 0x04, 0x08, 0xd3, 0xf5, 0xd4, 0x82, 0xff, 0x36,
0x60, 0x2f, 0x79, 0x81, 0x48, 0xec, 0xcc, 0x80, 0x53, 0x3e, 0x09, 0xc4, 0xe9, 0xb9, 0x59, 0x9f,
0xeb, 0xbc, 0x9d, 0x86, 0x70, 0x25, 0x2a, 0x04, 0x3d, 0x07, 0x53, 0xd6, 0xb0, 0xaa, 0xcc, 0x5c,
0x18, 0xac, 0xc2, 0xd4, 0x2e, 0xae, 0x83, 0x29, 0x23, 0x91, 0x09, 0xa9, 0xab, 0x97, 0xd6, 0x1a,
0xca, 0x01, 0x54, 0x09, 0x69, 0x55, 0x6f, 0x6a, 0x8d, 0x66, 0xc3, 0x32, 0xa6, 0x9a, 0x3d, 0x5d,
0xd7, 0xea, 0xaf, 0x4a, 0x97, 0xb5, 0x8a, 0x95, 0x42, 0x05, 0x78, 0x14, 0x33, 0xb4, 0x1a, 0xcd,
0x12, 0x69, 0xb6, 0xae, 0xaf, 0x6a, 0xf5, 0xa6, 0xb5, 0x8e, 0x7f, 0x84, 0xdd, 0x0a, 0x1b, 0xb0,
0xf7, 0xc4, 0x26, 0xde, 0x87, 0xbd, 0x24, 0xbc, 0xcc, 0x1e, 0x7f, 0x0f, 0x3b, 0xd3, 0x3a, 0x7f,
0x3f, 0x87, 0x7e, 0x29, 0x5b, 0x77, 0xee, 0x79, 0x66, 0x0c, 0x1b, 0xcb, 0x18, 0x2e, 0xfe, 0xb9,
0x01, 0x40, 0x58, 0xaf, 0xc1, 0xfc, 0xd7, 0x6e, 0x87, 0xa1, 0x1e, 0x7c, 0xa0, 0x1d, 0xc6, 0xd0,
0xc7, 0xf1, 0x86, 0x5d, 0x34, 0xff, 0xd9, 0xcf, 0xde, 0xe1, 0xa5, 0xf8, 0x58, 0x43, 0xad, 0x48,
0x6f, 0x62, 0xe3, 0x16, 0x7a, 0xaa, 0x15, 0xc0, 0xf8, 0x64, 0x65, 0xe3, 0x65, 0x2e, 0x21, 0xfc,
0xa7, 0x06, 0x7a, 0x05, 0xdb, 0x73, 0xd3, 0x14, 0x7a, 0x72, 0x5f, 0x73, 0x12, 0xd0, 0x87, 0x0b,
0xf7, 0x63, 0xb8, 0x17, 0x90, 0x89, 0x4d, 0x3d, 0xc8, 0x8e, 0xc7, 0x24, 0x27, 0x31, 0xbb, 0xa0,
0xdd, 0x8b, 0x28, 0xf8, 0x41, 0x16, 0x45, 0x62, 0x94, 0x40, 0x47, 0xef, 0x9a, 0x63, 0xec, 0xa7,
0x4b, 0x3c, 0xb4, 0xf9, 0x47, 0xd8, 0x4f, 0x16, 0x7e, 0x5e, 0xf4, 0xf9, 0x6b, 0x71, 0xbf, 0x91,
0xf9, 0x2b, 0xc9, 0x4e, 0xe6, 0x9f, 0xfc, 0x7a, 0x24, 0xf3, 0x9f, 0xd3, 0x78, 0x81, 0x75, 0x0e,
0x5b, 0x91, 0x0c, 0xa2, 0xfc, 0xac, 0xf4, 0x93, 0x9a, 0x6b, 0x1f, 0x68, 0x76, 0x22, 0x16, 0x5f,
0x42, 0x36, 0x2e, 0x38, 0xa8, 0xa0, 0x97, 0x21, 0x89, 0xf4, 0x78, 0x99, 0x46, 0x49, 0xb0, 0x78,
0xff, 0xce, 0xc0, 0x34, 0xa2, 0x31, 0x03, 0xd3, 0xb6, 0xfc, 0x1a, 0xaa, 0x02, 0xcc, 0xfa, 0x12,
0x1d, 0xc4, 0xc9, 0x48, 0x02, 0xd9, 0xba, 0xad, 0x10, 0xa6, 0x6d, 0x8a, 0x51, 0xe5, 0xec, 0x9f,
0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x6c, 0xba, 0xd7, 0xbd, 0x0d, 0x00, 0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go
View file @ 3aef5f9a
......@@ -24,7 +24,7 @@ type RepositoryExistsRequest struct {
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 (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
func (m *RepositoryExistsRequest) GetRepository() *Repository {
if m != nil {
......@@ -40,7 +40,7 @@ type RepositoryExistsResponse struct {
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 (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
func (m *RepositoryExistsResponse) GetExists() bool {
if m != nil {
......@@ -56,7 +56,7 @@ type RepackIncrementalRequest struct {
func (m *RepackIncrementalRequest) Reset() { *m = RepackIncrementalRequest{} }
func (m *RepackIncrementalRequest) String() string { return proto.CompactTextString(m) }
func (*RepackIncrementalRequest) ProtoMessage() {}
func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
func (m *RepackIncrementalRequest) GetRepository() *Repository {
if m != nil {
......@@ -71,7 +71,7 @@ type RepackIncrementalResponse struct {
func (m *RepackIncrementalResponse) Reset() { *m = RepackIncrementalResponse{} }
func (m *RepackIncrementalResponse) String() string { return proto.CompactTextString(m) }
func (*RepackIncrementalResponse) ProtoMessage() {}
func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
type RepackFullRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -81,7 +81,7 @@ type RepackFullRequest struct {
func (m *RepackFullRequest) Reset() { *m = RepackFullRequest{} }
func (m *RepackFullRequest) String() string { return proto.CompactTextString(m) }
func (*RepackFullRequest) ProtoMessage() {}
func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{4} }
func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
func (m *RepackFullRequest) GetRepository() *Repository {
if m != nil {
......@@ -103,7 +103,7 @@ type RepackFullResponse struct {
func (m *RepackFullResponse) Reset() { *m = RepackFullResponse{} }
func (m *RepackFullResponse) String() string { return proto.CompactTextString(m) }
func (*RepackFullResponse) ProtoMessage() {}
func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{5} }
func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
type GarbageCollectRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -113,7 +113,7 @@ type GarbageCollectRequest struct {
func (m *GarbageCollectRequest) Reset() { *m = GarbageCollectRequest{} }
func (m *GarbageCollectRequest) String() string { return proto.CompactTextString(m) }
func (*GarbageCollectRequest) ProtoMessage() {}
func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{6} }
func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{6} }
func (m *GarbageCollectRequest) GetRepository() *Repository {
if m != nil {
......@@ -135,7 +135,7 @@ type GarbageCollectResponse struct {
func (m *GarbageCollectResponse) Reset() { *m = GarbageCollectResponse{} }
func (m *GarbageCollectResponse) String() string { return proto.CompactTextString(m) }
func (*GarbageCollectResponse) ProtoMessage() {}
func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{7} }
func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{7} }
type RepositorySizeRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -144,7 +144,7 @@ type RepositorySizeRequest struct {
func (m *RepositorySizeRequest) Reset() { *m = RepositorySizeRequest{} }
func (m *RepositorySizeRequest) String() string { return proto.CompactTextString(m) }
func (*RepositorySizeRequest) ProtoMessage() {}
func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{8} }
func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{8} }
func (m *RepositorySizeRequest) GetRepository() *Repository {
if m != nil {
......@@ -161,7 +161,7 @@ type RepositorySizeResponse struct {
func (m *RepositorySizeResponse) Reset() { *m = RepositorySizeResponse{} }
func (m *RepositorySizeResponse) String() string { return proto.CompactTextString(m) }
func (*RepositorySizeResponse) ProtoMessage() {}
func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{9} }
func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{9} }
func (m *RepositorySizeResponse) GetSize() int64 {
if m != nil {
......@@ -178,7 +178,7 @@ type ApplyGitattributesRequest struct {
func (m *ApplyGitattributesRequest) Reset() { *m = ApplyGitattributesRequest{} }
func (m *ApplyGitattributesRequest) String() string { return proto.CompactTextString(m) }
func (*ApplyGitattributesRequest) ProtoMessage() {}
func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{10} }
func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{10} }
func (m *ApplyGitattributesRequest) GetRepository() *Repository {
if m != nil {
......@@ -200,7 +200,7 @@ type ApplyGitattributesResponse struct {
func (m *ApplyGitattributesResponse) Reset() { *m = ApplyGitattributesResponse{} }
func (m *ApplyGitattributesResponse) String() string { return proto.CompactTextString(m) }
func (*ApplyGitattributesResponse) ProtoMessage() {}
func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{11} }
func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{11} }
type FetchRemoteRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -215,7 +215,7 @@ type FetchRemoteRequest struct {
func (m *FetchRemoteRequest) Reset() { *m = FetchRemoteRequest{} }
func (m *FetchRemoteRequest) String() string { return proto.CompactTextString(m) }
func (*FetchRemoteRequest) ProtoMessage() {}
func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{12} }
func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{12} }
func (m *FetchRemoteRequest) GetRepository() *Repository {
if m != nil {
......@@ -272,7 +272,31 @@ type FetchRemoteResponse struct {
func (m *FetchRemoteResponse) Reset() { *m = FetchRemoteResponse{} }
func (m *FetchRemoteResponse) String() string { return proto.CompactTextString(m) }
func (*FetchRemoteResponse) ProtoMessage() {}
func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{13} }
func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{13} }
type CreateRepositoryRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
}
func (m *CreateRepositoryRequest) Reset() { *m = CreateRepositoryRequest{} }
func (m *CreateRepositoryRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryRequest) ProtoMessage() {}
func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{14} }
func (m *CreateRepositoryRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
type CreateRepositoryResponse struct {
}
func (m *CreateRepositoryResponse) Reset() { *m = CreateRepositoryResponse{} }
func (m *CreateRepositoryResponse) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryResponse) ProtoMessage() {}
func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{15} }
func init() {
proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
......@@ -289,6 +313,8 @@ func init() {
proto.RegisterType((*ApplyGitattributesResponse)(nil), "gitaly.ApplyGitattributesResponse")
proto.RegisterType((*FetchRemoteRequest)(nil), "gitaly.FetchRemoteRequest")
proto.RegisterType((*FetchRemoteResponse)(nil), "gitaly.FetchRemoteResponse")
proto.RegisterType((*CreateRepositoryRequest)(nil), "gitaly.CreateRepositoryRequest")
proto.RegisterType((*CreateRepositoryResponse)(nil), "gitaly.CreateRepositoryResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
......@@ -309,6 +335,7 @@ type RepositoryServiceClient interface {
RepositorySize(ctx context.Context, in *RepositorySizeRequest, opts ...grpc.CallOption) (*RepositorySizeResponse, error)
ApplyGitattributes(ctx context.Context, in *ApplyGitattributesRequest, opts ...grpc.CallOption) (*ApplyGitattributesResponse, error)
FetchRemote(ctx context.Context, in *FetchRemoteRequest, opts ...grpc.CallOption) (*FetchRemoteResponse, error)
CreateRepository(ctx context.Context, in *CreateRepositoryRequest, opts ...grpc.CallOption) (*CreateRepositoryResponse, error)
// Deprecated, use the RepositoryExists RPC instead.
Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error)
}
......@@ -384,6 +411,15 @@ func (c *repositoryServiceClient) FetchRemote(ctx context.Context, in *FetchRemo
return out, nil
}
func (c *repositoryServiceClient) CreateRepository(ctx context.Context, in *CreateRepositoryRequest, opts ...grpc.CallOption) (*CreateRepositoryResponse, error) {
out := new(CreateRepositoryResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/CreateRepository", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
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...)
......@@ -403,6 +439,7 @@ type RepositoryServiceServer interface {
RepositorySize(context.Context, *RepositorySizeRequest) (*RepositorySizeResponse, error)
ApplyGitattributes(context.Context, *ApplyGitattributesRequest) (*ApplyGitattributesResponse, error)
FetchRemote(context.Context, *FetchRemoteRequest) (*FetchRemoteResponse, error)
CreateRepository(context.Context, *CreateRepositoryRequest) (*CreateRepositoryResponse, error)
// Deprecated, use the RepositoryExists RPC instead.
Exists(context.Context, *RepositoryExistsRequest) (*RepositoryExistsResponse, error)
}
......@@ -537,6 +574,24 @@ func _RepositoryService_FetchRemote_Handler(srv interface{}, ctx context.Context
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_CreateRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRepositoryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).CreateRepository(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RepositoryService/CreateRepository",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).CreateRepository(ctx, req.(*CreateRepositoryRequest))
}
return interceptor(ctx, in, info, handler)
}
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 {
......@@ -587,6 +642,10 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
MethodName: "FetchRemote",
Handler: _RepositoryService_FetchRemote_Handler,
},
{
MethodName: "CreateRepository",
Handler: _RepositoryService_CreateRepository_Handler,
},
{
MethodName: "Exists",
Handler: _RepositoryService_Exists_Handler,
......@@ -596,43 +655,46 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
Metadata: "repository-service.proto",
}
func init() { proto.RegisterFile("repository-service.proto", fileDescriptor6) }
var fileDescriptor6 = []byte{
// 558 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0x6e, 0x68, 0x93, 0x94, 0x49, 0x40, 0x30, 0x34, 0xa9, 0xe3, 0x02, 0x0d, 0xe6, 0xd2, 0x03,
0xe4, 0x10, 0x9e, 0x00, 0x50, 0x7f, 0x50, 0x55, 0x24, 0x0c, 0x12, 0x12, 0x12, 0x8a, 0x36, 0x66,
0x48, 0x56, 0x71, 0xbc, 0x66, 0x77, 0x53, 0x48, 0xdf, 0x89, 0xa7, 0xe2, 0x45, 0x50, 0x76, 0x1d,
0xdb, 0x49, 0x9c, 0x5e, 0x0c, 0x37, 0xcf, 0xdf, 0x37, 0xb3, 0xdf, 0xce, 0xb7, 0x06, 0x47, 0x52,
0x2c, 0x14, 0xd7, 0x42, 0xce, 0x5f, 0x2a, 0x92, 0xd7, 0x3c, 0xa0, 0x5e, 0x2c, 0x85, 0x16, 0x58,
0x1b, 0x71, 0xcd, 0xc2, 0xb9, 0xdb, 0x54, 0x63, 0x26, 0xe9, 0x9b, 0xf5, 0x7a, 0x57, 0x70, 0xe8,
0xa7, 0x15, 0xa7, 0xbf, 0xb8, 0xd2, 0xca, 0xa7, 0x1f, 0x33, 0x52, 0x1a, 0xfb, 0x00, 0x19, 0x98,
0x53, 0xe9, 0x56, 0x4e, 0x1a, 0x7d, 0xec, 0x59, 0x94, 0x5e, 0x56, 0xe4, 0xe7, 0xb2, 0xbc, 0x3e,
0x38, 0x9b, 0x70, 0x2a, 0x16, 0x91, 0x22, 0x6c, 0x43, 0x8d, 0x8c, 0xc7, 0x60, 0xed, 0xfb, 0x89,
0xe5, 0xbd, 0x37, 0x35, 0x2c, 0x98, 0xbc, 0x8b, 0x02, 0x49, 0x53, 0x8a, 0x34, 0x0b, 0xcb, 0xcc,
0x70, 0x04, 0x9d, 0x02, 0x3c, 0x3b, 0x84, 0x17, 0xc2, 0x43, 0x1b, 0x3c, 0x9b, 0x85, 0x65, 0xba,
0xe0, 0x73, 0xb8, 0x17, 0x48, 0x62, 0x9a, 0x06, 0x43, 0xae, 0xa7, 0x2c, 0x76, 0xee, 0x98, 0x43,
0x35, 0xad, 0xf3, 0x8d, 0xf1, 0x79, 0x07, 0x80, 0xf9, 0x6e, 0xc9, 0x0c, 0x31, 0xb4, 0xce, 0x99,
0x1c, 0xb2, 0x11, 0xbd, 0x15, 0x61, 0x48, 0x81, 0xfe, 0xef, 0x73, 0x38, 0xd0, 0x5e, 0xef, 0x98,
0xcc, 0x72, 0x09, 0xad, 0x0c, 0xf8, 0x23, 0xbf, 0xa1, 0x32, 0xcc, 0xbf, 0x80, 0xf6, 0x3a, 0x58,
0x72, 0xf7, 0x08, 0x7b, 0x8a, 0xdf, 0x90, 0xc1, 0xd9, 0xf5, 0xcd, 0xb7, 0x37, 0x81, 0xce, 0xeb,
0x38, 0x0e, 0xe7, 0xe7, 0x5c, 0x33, 0xad, 0x25, 0x1f, 0xce, 0x34, 0x95, 0x59, 0x3e, 0x74, 0x61,
0x5f, 0xd2, 0x35, 0x57, 0x5c, 0x44, 0x86, 0x85, 0xa6, 0x9f, 0xda, 0xde, 0x63, 0x70, 0x8b, 0x9a,
0x25, 0x2c, 0xfc, 0xa9, 0x00, 0x9e, 0x91, 0x0e, 0xc6, 0x3e, 0x4d, 0x85, 0x2e, 0xc3, 0xc1, 0x62,
0xcb, 0xa5, 0x01, 0x31, 0x23, 0xdc, 0xf5, 0x13, 0x0b, 0x0f, 0xa0, 0xfa, 0x5d, 0xc8, 0x80, 0x9c,
0x5d, 0x73, 0x3f, 0xd6, 0xc0, 0x43, 0xa8, 0x47, 0x62, 0xa0, 0xd9, 0x48, 0x39, 0x7b, 0x56, 0x14,
0x91, 0xf8, 0xc4, 0x46, 0x0a, 0x1d, 0xa8, 0x6b, 0x3e, 0x25, 0x31, 0xd3, 0x4e, 0xb5, 0x5b, 0x39,
0xa9, 0xfa, 0x4b, 0x73, 0x51, 0xa2, 0xd4, 0x78, 0x30, 0xa1, 0xb9, 0x53, 0xb3, 0x1d, 0x94, 0x1a,
0x5f, 0xd2, 0x1c, 0x8f, 0xa1, 0x31, 0x89, 0xc4, 0xcf, 0x68, 0x30, 0x16, 0x0b, 0x91, 0xd5, 0x4d,
0x10, 0x8c, 0xeb, 0x62, 0xe1, 0xf1, 0x5a, 0xf0, 0x68, 0xe5, 0x90, 0xf6, 0xf0, 0xfd, 0xdf, 0x55,
0xa3, 0x89, 0xe5, 0xb5, 0xd9, 0x47, 0x03, 0x3f, 0xc3, 0x83, 0x75, 0x25, 0xe3, 0xf1, 0xe6, 0xd9,
0x57, 0x9e, 0x0c, 0xb7, 0xbb, 0x3d, 0x21, 0x61, 0x7a, 0x07, 0xbf, 0x2c, 0x15, 0x98, 0x93, 0x27,
0xe6, 0x0b, 0x0b, 0x5f, 0x02, 0xf7, 0xd9, 0x2d, 0x19, 0x29, 0xf6, 0x29, 0x40, 0xa6, 0x37, 0xec,
0xac, 0x96, 0xe4, 0x14, 0xef, 0xba, 0x45, 0xa1, 0x14, 0xe6, 0x03, 0xdc, 0x5f, 0x95, 0x0b, 0x3e,
0x59, 0xe6, 0x17, 0x0a, 0xd7, 0x7d, 0xba, 0x2d, 0x9c, 0x87, 0x5c, 0x95, 0x46, 0x06, 0x59, 0xa8,
0xbf, 0x0c, 0xb2, 0x58, 0x51, 0xde, 0x0e, 0x7e, 0x05, 0xdc, 0x5c, 0x69, 0x4c, 0x79, 0xda, 0xaa,
0x2d, 0xd7, 0xbb, 0x2d, 0x25, 0x85, 0xbf, 0x80, 0x46, 0x6e, 0x5b, 0x30, 0x65, 0x6c, 0x53, 0x27,
0xee, 0x51, 0x61, 0x2c, 0x45, 0xba, 0x82, 0xda, 0x3f, 0x5c, 0xa0, 0x61, 0xcd, 0xfc, 0xb9, 0x5e,
0xfd, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x33, 0x2f, 0xf5, 0x96, 0xeb, 0x06, 0x00, 0x00,
func init() { proto.RegisterFile("repository-service.proto", fileDescriptor8) }
var fileDescriptor8 = []byte{
// 593 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdb, 0x6e, 0xd3, 0x4c,
0x10, 0x6e, 0xfe, 0xb6, 0x4e, 0xff, 0x49, 0x40, 0x65, 0x68, 0x12, 0xc7, 0x05, 0x1a, 0xcc, 0x4d,
0x2f, 0x20, 0x17, 0xe1, 0x09, 0xa0, 0xea, 0x01, 0x55, 0x41, 0xc2, 0x20, 0x55, 0x42, 0x42, 0xd1,
0xc6, 0x0c, 0xc9, 0x2a, 0x8e, 0xd7, 0xec, 0x6e, 0x0a, 0xe9, 0x03, 0xf0, 0xa2, 0xbc, 0x08, 0xca,
0xda, 0xb1, 0x9d, 0xc4, 0xe9, 0x8d, 0xe1, 0x2e, 0x3b, 0x87, 0x6f, 0x0e, 0xfe, 0xbe, 0x09, 0xd8,
0x92, 0x22, 0xa1, 0xb8, 0x16, 0x72, 0xfe, 0x4a, 0x91, 0xbc, 0xe5, 0x3e, 0x75, 0x23, 0x29, 0xb4,
0x40, 0x6b, 0xc4, 0x35, 0x0b, 0xe6, 0x4e, 0x5d, 0x8d, 0x99, 0xa4, 0xaf, 0xb1, 0xd5, 0xed, 0x43,
0xcb, 0x4b, 0x33, 0xce, 0x7f, 0x72, 0xa5, 0x95, 0x47, 0xdf, 0x67, 0xa4, 0x34, 0xf6, 0x00, 0x32,
0x30, 0xbb, 0xd2, 0xa9, 0x9c, 0xd6, 0x7a, 0xd8, 0x8d, 0x51, 0xba, 0x59, 0x92, 0x97, 0x8b, 0x72,
0x7b, 0x60, 0x6f, 0xc2, 0xa9, 0x48, 0x84, 0x8a, 0xb0, 0x09, 0x16, 0x19, 0x8b, 0xc1, 0x3a, 0xf0,
0x92, 0x97, 0xfb, 0xde, 0xe4, 0x30, 0x7f, 0xf2, 0x2e, 0xf4, 0x25, 0x4d, 0x29, 0xd4, 0x2c, 0x28,
0xd3, 0xc3, 0x31, 0xb4, 0x0b, 0xf0, 0xe2, 0x26, 0xdc, 0x00, 0x1e, 0xc5, 0xce, 0x8b, 0x59, 0x50,
0xa6, 0x0a, 0xbe, 0x80, 0x07, 0xbe, 0x24, 0xa6, 0x69, 0x30, 0xe4, 0x7a, 0xca, 0x22, 0xfb, 0x3f,
0x33, 0x54, 0x3d, 0x36, 0xbe, 0x35, 0x36, 0xf7, 0x08, 0x30, 0x5f, 0x2d, 0xe9, 0x21, 0x82, 0xc6,
0x25, 0x93, 0x43, 0x36, 0xa2, 0x33, 0x11, 0x04, 0xe4, 0xeb, 0x7f, 0xde, 0x87, 0x0d, 0xcd, 0xf5,
0x8a, 0x49, 0x2f, 0xd7, 0xd0, 0xc8, 0x80, 0x3f, 0xf2, 0x3b, 0x2a, 0xb3, 0xf9, 0x97, 0xd0, 0x5c,
0x07, 0x4b, 0xbe, 0x3d, 0xc2, 0x9e, 0xe2, 0x77, 0x64, 0x70, 0x76, 0x3d, 0xf3, 0xdb, 0x9d, 0x40,
0xfb, 0x4d, 0x14, 0x05, 0xf3, 0x4b, 0xae, 0x99, 0xd6, 0x92, 0x0f, 0x67, 0x9a, 0xca, 0x90, 0x0f,
0x1d, 0x38, 0x90, 0x74, 0xcb, 0x15, 0x17, 0xa1, 0xd9, 0x42, 0xdd, 0x4b, 0xdf, 0xee, 0x13, 0x70,
0x8a, 0x8a, 0x25, 0x5b, 0xf8, 0x5d, 0x01, 0xbc, 0x20, 0xed, 0x8f, 0x3d, 0x9a, 0x0a, 0x5d, 0x66,
0x07, 0x0b, 0x96, 0x4b, 0x03, 0x62, 0x5a, 0xf8, 0xdf, 0x4b, 0x5e, 0x78, 0x04, 0xfb, 0xdf, 0x84,
0xf4, 0xc9, 0xde, 0x35, 0xdf, 0x27, 0x7e, 0x60, 0x0b, 0xaa, 0xa1, 0x18, 0x68, 0x36, 0x52, 0xf6,
0x5e, 0x2c, 0x8a, 0x50, 0x7c, 0x62, 0x23, 0x85, 0x36, 0x54, 0x35, 0x9f, 0x92, 0x98, 0x69, 0x7b,
0xbf, 0x53, 0x39, 0xdd, 0xf7, 0x96, 0xcf, 0x45, 0x8a, 0x52, 0xe3, 0xc1, 0x84, 0xe6, 0xb6, 0x15,
0x57, 0x50, 0x6a, 0x7c, 0x4d, 0x73, 0x3c, 0x81, 0xda, 0x24, 0x14, 0x3f, 0xc2, 0xc1, 0x58, 0x2c,
0x44, 0x56, 0x35, 0x4e, 0x30, 0xa6, 0xab, 0x85, 0xc5, 0x6d, 0xc0, 0xe3, 0x95, 0x21, 0x93, 0xe1,
0xfb, 0xd0, 0x3a, 0x33, 0x64, 0xc9, 0x4d, 0x54, 0x82, 0x04, 0x0e, 0xd8, 0x9b, 0x70, 0x71, 0xa9,
0xde, 0x2f, 0xcb, 0xc8, 0x6f, 0xc9, 0x90, 0xf8, 0x3e, 0xe1, 0x0d, 0x1c, 0xae, 0x1f, 0x0d, 0x3c,
0xd9, 0xac, 0xb2, 0x72, 0x9d, 0x9c, 0xce, 0xf6, 0x80, 0x64, 0xae, 0x1d, 0xfc, 0xbc, 0x14, 0x7b,
0xee, 0x12, 0x60, 0x3e, 0xb1, 0xf0, 0xe8, 0x38, 0xcf, 0xef, 0x89, 0x48, 0xb1, 0xcf, 0x01, 0x32,
0x69, 0x63, 0x7b, 0x35, 0x25, 0x77, 0x5c, 0x1c, 0xa7, 0xc8, 0x95, 0xc2, 0x7c, 0x80, 0x87, 0xab,
0xca, 0xc4, 0xa7, 0xcb, 0xf8, 0xc2, 0x1b, 0xe1, 0x3c, 0xdb, 0xe6, 0xce, 0x43, 0xae, 0xaa, 0x30,
0x83, 0x2c, 0x94, 0x7a, 0x06, 0x59, 0x2c, 0x5e, 0x77, 0x07, 0xbf, 0x00, 0x6e, 0xaa, 0x07, 0xd3,
0x3d, 0x6d, 0x95, 0xb1, 0xe3, 0xde, 0x17, 0x92, 0xc2, 0x5f, 0x41, 0x2d, 0x47, 0x4c, 0x4c, 0x37,
0xb6, 0x29, 0x49, 0xe7, 0xb8, 0xd0, 0x97, 0x22, 0xdd, 0xc0, 0xe1, 0x3a, 0xf9, 0x32, 0x2a, 0x6d,
0x61, 0x79, 0x46, 0xa5, 0x6d, 0xbc, 0x75, 0x77, 0xb0, 0x0f, 0xd6, 0x5f, 0x64, 0xe6, 0xd0, 0x32,
0xff, 0xbe, 0xaf, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xd3, 0xae, 0xf2, 0xe4, 0xaf, 0x07, 0x00,
0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go
View file @ 3aef5f9a
......@@ -22,12 +22,15 @@ type Repository struct {
// Sets the GIT_ALTERNATE_OBJECT_DIRECTORIES envvar on git commands to the values of this field.
// It influences the list of Git object directories which can be used to search for Git objects.
GitAlternateObjectDirectories []string `protobuf:"bytes,5,rep,name=git_alternate_object_directories,json=gitAlternateObjectDirectories" json:"git_alternate_object_directories,omitempty"`
// Used in callbacks to GitLab so that it knows what repository the event is
// associated with. May be left empty on RPC's that do not perform callbacks.
GlRepository string `protobuf:"bytes,6,opt,name=gl_repository,json=glRepository" json:"gl_repository,omitempty"`
}
func (m *Repository) Reset() { *m = Repository{} }
func (m *Repository) String() string { return proto.CompactTextString(m) }
func (*Repository) ProtoMessage() {}
func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
func (m *Repository) GetStorageName() string {
if m != nil {
......@@ -57,6 +60,14 @@ func (m *Repository) GetGitAlternateObjectDirectories() []string {
return nil
}
func (m *Repository) GetGlRepository() string {
if m != nil {
return m.GlRepository
}
return ""
}
// Corresponds to Gitlab::Git::Commit
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"`
......@@ -69,7 +80,7 @@ type GitCommit struct {
func (m *GitCommit) Reset() { *m = GitCommit{} }
func (m *GitCommit) String() string { return proto.CompactTextString(m) }
func (*GitCommit) ProtoMessage() {}
func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
func (m *GitCommit) GetId() string {
if m != nil {
......@@ -122,7 +133,7 @@ type CommitAuthor struct {
func (m *CommitAuthor) Reset() { *m = CommitAuthor{} }
func (m *CommitAuthor) String() string { return proto.CompactTextString(m) }
func (*CommitAuthor) ProtoMessage() {}
func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
func (m *CommitAuthor) GetName() []byte {
if m != nil {
......@@ -152,7 +163,7 @@ type ExitStatus struct {
func (m *ExitStatus) Reset() { *m = ExitStatus{} }
func (m *ExitStatus) String() string { return proto.CompactTextString(m) }
func (*ExitStatus) ProtoMessage() {}
func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
func (m *ExitStatus) GetValue() int32 {
if m != nil {
......@@ -161,40 +172,104 @@ func (m *ExitStatus) GetValue() int32 {
return 0
}
// Corresponds to Gitlab::Git::Branch
type Branch struct {
Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
TargetCommit *GitCommit `protobuf:"bytes,2,opt,name=target_commit,json=targetCommit" json:"target_commit,omitempty"`
}
func (m *Branch) Reset() { *m = Branch{} }
func (m *Branch) String() string { return proto.CompactTextString(m) }
func (*Branch) ProtoMessage() {}
func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{4} }
func (m *Branch) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
func (m *Branch) GetTargetCommit() *GitCommit {
if m != nil {
return m.TargetCommit
}
return nil
}
type User struct {
GlId string `protobuf:"bytes,1,opt,name=gl_id,json=glId" json:"gl_id,omitempty"`
Name []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
Email []byte `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"`
}
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (*User) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
func (m *User) GetGlId() string {
if m != nil {
return m.GlId
}
return ""
}
func (m *User) GetName() []byte {
if m != nil {
return m.Name
}
return nil
}
func (m *User) GetEmail() []byte {
if m != nil {
return m.Email
}
return nil
}
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")
proto.RegisterType((*Branch)(nil), "gitaly.Branch")
proto.RegisterType((*User)(nil), "gitaly.User")
}
func init() { proto.RegisterFile("shared.proto", fileDescriptor7) }
var fileDescriptor7 = []byte{
// 393 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x4d, 0x8f, 0xd3, 0x40,
0x0c, 0x55, 0xba, 0x69, 0x21, 0x6e, 0x40, 0x68, 0xd4, 0x43, 0xb4, 0xd2, 0x8a, 0x12, 0x2e, 0x7b,
0x40, 0x59, 0x54, 0x7e, 0xc1, 0x0a, 0xd0, 0x0a, 0x0e, 0x80, 0x02, 0xf7, 0xc8, 0x6d, 0x4c, 0x62,
0x94, 0x74, 0xa2, 0x19, 0x67, 0x45, 0xff, 0x22, 0x7f, 0x81, 0x3f, 0x83, 0xe2, 0x69, 0xc4, 0xc7,
0x81, 0x9b, 0xfd, 0xfc, 0x9e, 0xf3, 0x5e, 0xc6, 0x90, 0xfa, 0x16, 0x1d, 0xd5, 0xc5, 0xe0, 0xac,
0x58, 0xb3, 0x6a, 0x58, 0xb0, 0x3b, 0x5d, 0x3e, 0x6d, 0xac, 0x6d, 0x3a, 0xba, 0x51, 0x74, 0x3f,
0x7e, 0xbd, 0x11, 0xee, 0xc9, 0x0b, 0xf6, 0x43, 0x20, 0xe6, 0x3f, 0x23, 0x80, 0x92, 0x06, 0xeb,
0x59, 0xac, 0x3b, 0x99, 0x67, 0x90, 0x7a, 0xb1, 0x0e, 0x1b, 0xaa, 0x8e, 0xd8, 0x53, 0xb6, 0xd8,
0x46, 0xd7, 0x49, 0xb9, 0x3e, 0x63, 0x1f, 0xb0, 0x27, 0xf3, 0x1c, 0x1e, 0x39, 0xea, 0x50, 0xf8,
0x9e, 0xaa, 0x01, 0xa5, 0xcd, 0x2e, 0x94, 0x93, 0xce, 0xe0, 0x27, 0x94, 0xd6, 0xbc, 0x84, 0x4d,
0xc3, 0x52, 0xd9, 0xfd, 0x37, 0x3a, 0x48, 0x55, 0xb3, 0xa3, 0xc3, 0xb4, 0x3f, 0x8b, 0x95, 0x6b,
0x1a, 0x96, 0x8f, 0x3a, 0x7a, 0x33, 0x4f, 0xcc, 0x1d, 0x6c, 0x27, 0x05, 0x76, 0x42, 0xee, 0x88,
0x42, 0xff, 0x6a, 0x99, 0x7c, 0xb6, 0xdc, 0x5e, 0x5c, 0x27, 0xe5, 0x55, 0xc3, 0x72, 0x3b, 0xd3,
0xfe, 0x5e, 0xc3, 0xe4, 0xdf, 0xc7, 0x0f, 0xa3, 0x27, 0x8b, 0x32, 0x9e, 0xac, 0xe5, 0x3f, 0x22,
0x48, 0xee, 0x58, 0x5e, 0xdb, 0xbe, 0x67, 0x31, 0x8f, 0x61, 0xc1, 0x75, 0x16, 0xa9, 0x85, 0x05,
0xd7, 0x26, 0x83, 0x07, 0x7e, 0x54, 0xbd, 0xe6, 0x4c, 0xcb, 0xb9, 0x35, 0x06, 0xe2, 0xbd, 0xad,
0x4f, 0x1a, 0x2d, 0x2d, 0xb5, 0x36, 0x2f, 0x60, 0x85, 0xa3, 0xb4, 0xd6, 0x69, 0x88, 0xf5, 0x6e,
0x53, 0x84, 0x7f, 0x5c, 0x84, 0xed, 0xb7, 0x3a, 0x2b, 0xcf, 0x1c, 0xb3, 0x83, 0xe4, 0xa0, 0xb8,
0x90, 0xcb, 0x96, 0xff, 0x11, 0xfc, 0xa6, 0x99, 0x2b, 0x80, 0x01, 0x1d, 0x1d, 0xa5, 0xe2, 0xda,
0x67, 0x2b, 0x0d, 0x9b, 0x04, 0xe4, 0x5d, 0xed, 0xf3, 0x16, 0xd2, 0x3f, 0x95, 0x93, 0x49, 0x7d,
0xa3, 0x28, 0x98, 0x9c, 0x6a, 0xb3, 0x81, 0x25, 0xf5, 0xc8, 0xdd, 0x39, 0x50, 0x68, 0x4c, 0x01,
0x71, 0x8d, 0x42, 0x1a, 0x67, 0xbd, 0xbb, 0x2c, 0xc2, 0x51, 0x14, 0xf3, 0x51, 0x14, 0x5f, 0xe6,
0xa3, 0x28, 0x95, 0x97, 0xe7, 0x00, 0x6f, 0xbf, 0xb3, 0x7c, 0x16, 0x94, 0xd1, 0x4f, 0x3b, 0xef,
0xb1, 0x1b, 0xc3, 0x87, 0x96, 0x65, 0x68, 0xf6, 0x2b, 0x55, 0xbf, 0xfa, 0x15, 0x00, 0x00, 0xff,
0xff, 0xe1, 0xc9, 0xfa, 0xcc, 0x78, 0x02, 0x00, 0x00,
func init() { proto.RegisterFile("shared.proto", fileDescriptor9) }
var fileDescriptor9 = []byte{
// 468 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0xc1, 0x6e, 0xd3, 0x40,
0x10, 0x55, 0x1c, 0xc7, 0xe0, 0x89, 0x8b, 0x60, 0xc9, 0xc1, 0xaa, 0x54, 0x11, 0xcc, 0xa5, 0x07,
0xe4, 0xa2, 0x20, 0x71, 0x2f, 0x50, 0x55, 0xe5, 0x00, 0x68, 0x29, 0x67, 0x6b, 0x13, 0x0f, 0xeb,
0x45, 0xeb, 0xac, 0xb5, 0x3b, 0xae, 0xc8, 0x8d, 0xef, 0xe3, 0xab, 0x90, 0x77, 0xe3, 0xb4, 0xa0,
0xaa, 0xb7, 0x9d, 0xd9, 0xf7, 0x66, 0xde, 0x9b, 0x19, 0xc8, 0x5c, 0x23, 0x2c, 0xd6, 0x65, 0x67,
0x0d, 0x19, 0x96, 0x48, 0x45, 0x42, 0xef, 0x8e, 0x5f, 0x48, 0x63, 0xa4, 0xc6, 0x33, 0x9f, 0x5d,
0xf7, 0x3f, 0xce, 0x48, 0xb5, 0xe8, 0x48, 0xb4, 0x5d, 0x00, 0x16, 0xbf, 0x23, 0x00, 0x8e, 0x9d,
0x71, 0x8a, 0x8c, 0xdd, 0xb1, 0x97, 0x90, 0x39, 0x32, 0x56, 0x48, 0xac, 0xb6, 0xa2, 0xc5, 0x3c,
0x5a, 0x4e, 0x4e, 0x53, 0x3e, 0xdf, 0xe7, 0x3e, 0x8b, 0x16, 0xd9, 0x2b, 0x38, 0xb2, 0xa8, 0x05,
0xa9, 0x1b, 0xac, 0x3a, 0x41, 0x4d, 0x3e, 0xf5, 0x98, 0x6c, 0x4c, 0x7e, 0x15, 0xd4, 0xb0, 0x37,
0xb0, 0x90, 0x8a, 0x2a, 0xb3, 0xfe, 0x89, 0x1b, 0xaa, 0x6a, 0x65, 0x71, 0x33, 0xd4, 0xcf, 0x63,
0x8f, 0x65, 0x52, 0xd1, 0x17, 0xff, 0xf5, 0x71, 0xfc, 0x61, 0x97, 0xb0, 0x1c, 0x18, 0x42, 0x13,
0xda, 0xad, 0x20, 0xfc, 0x9f, 0xab, 0xd0, 0xe5, 0xb3, 0xe5, 0xf4, 0x34, 0xe5, 0x27, 0x52, 0xd1,
0xf9, 0x08, 0xfb, 0xb7, 0x8c, 0x42, 0x37, 0xe8, 0x93, 0xba, 0xb2, 0x07, 0x4f, 0x79, 0x12, 0xf4,
0x49, 0x7d, 0xeb, 0xf3, 0x53, 0xfc, 0x78, 0xf2, 0x34, 0xe2, 0xf1, 0xa0, 0xbf, 0xf8, 0x33, 0x81,
0xf4, 0x52, 0xd1, 0x07, 0xd3, 0xb6, 0x8a, 0xd8, 0x13, 0x88, 0x54, 0x9d, 0x4f, 0x3c, 0x27, 0x52,
0x35, 0xcb, 0xe1, 0x91, 0xeb, 0x7d, 0x13, 0x3f, 0x8c, 0x8c, 0x8f, 0x21, 0x63, 0x10, 0xaf, 0x4d,
0xbd, 0xf3, 0xfe, 0x33, 0xee, 0xdf, 0xec, 0x35, 0x24, 0xa2, 0xa7, 0xc6, 0x58, 0xef, 0x74, 0xbe,
0x5a, 0x94, 0x61, 0x11, 0x65, 0xa8, 0x7e, 0xee, 0xff, 0xf8, 0x1e, 0xc3, 0x56, 0x90, 0x6e, 0x7c,
0x9e, 0xd0, 0xe6, 0xb3, 0x07, 0x08, 0xb7, 0x30, 0x76, 0x02, 0xd0, 0x09, 0x8b, 0x5b, 0xaa, 0x54,
0xed, 0xf2, 0xc4, 0x4f, 0x24, 0x0d, 0x99, 0xab, 0xda, 0x15, 0x0d, 0x64, 0x77, 0x99, 0x83, 0x48,
0xbf, 0xc8, 0x49, 0x10, 0x39, 0xbc, 0xd9, 0x02, 0x66, 0xd8, 0x0a, 0xa5, 0xf7, 0x86, 0x42, 0xc0,
0x4a, 0x88, 0x6b, 0x41, 0xe8, 0xed, 0xcc, 0x57, 0xc7, 0x65, 0xb8, 0x9c, 0x72, 0xbc, 0x9c, 0xf2,
0x7a, 0xbc, 0x1c, 0xee, 0x71, 0x45, 0x01, 0x70, 0xf1, 0x4b, 0xd1, 0x37, 0x12, 0xd4, 0xbb, 0xa1,
0xe6, 0x8d, 0xd0, 0x7d, 0x68, 0x34, 0xe3, 0x21, 0x28, 0xae, 0x21, 0x79, 0x6f, 0xc5, 0x76, 0xd3,
0xdc, 0xab, 0xe3, 0x1d, 0x1c, 0x91, 0xb0, 0x12, 0xa9, 0x0a, 0xf6, 0xbc, 0x9e, 0xf9, 0xea, 0xd9,
0x38, 0x82, 0xc3, 0x52, 0x78, 0x16, 0x70, 0x21, 0x2a, 0x2e, 0x20, 0xfe, 0xee, 0xd0, 0xb2, 0xe7,
0x30, 0x93, 0xba, 0x3a, 0x6c, 0x2b, 0x96, 0xfa, 0xaa, 0x3e, 0x34, 0x8a, 0xee, 0x33, 0x3c, 0xbd,
0x63, 0x78, 0x9d, 0x78, 0x6b, 0x6f, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x86, 0x24, 0x75, 0x89,
0x3a, 0x03, 0x00, 0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go
View file @ 3aef5f9a
......@@ -24,7 +24,7 @@ type InfoRefsRequest struct {
func (m *InfoRefsRequest) Reset() { *m = InfoRefsRequest{} }
func (m *InfoRefsRequest) String() string { return proto.CompactTextString(m) }
func (*InfoRefsRequest) ProtoMessage() {}
func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{0} }
func (m *InfoRefsRequest) GetRepository() *Repository {
if m != nil {
......@@ -40,7 +40,7 @@ type InfoRefsResponse struct {
func (m *InfoRefsResponse) Reset() { *m = InfoRefsResponse{} }
func (m *InfoRefsResponse) String() string { return proto.CompactTextString(m) }
func (*InfoRefsResponse) ProtoMessage() {}
func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{1} }
func (m *InfoRefsResponse) GetData() []byte {
if m != nil {
......@@ -59,7 +59,7 @@ type PostUploadPackRequest struct {
func (m *PostUploadPackRequest) Reset() { *m = PostUploadPackRequest{} }
func (m *PostUploadPackRequest) String() string { return proto.CompactTextString(m) }
func (*PostUploadPackRequest) ProtoMessage() {}
func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
func (m *PostUploadPackRequest) GetRepository() *Repository {
if m != nil {
......@@ -83,7 +83,7 @@ type PostUploadPackResponse struct {
func (m *PostUploadPackResponse) Reset() { *m = PostUploadPackResponse{} }
func (m *PostUploadPackResponse) String() string { return proto.CompactTextString(m) }
func (*PostUploadPackResponse) ProtoMessage() {}
func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
func (m *PostUploadPackResponse) GetData() []byte {
if m != nil {
......@@ -97,16 +97,17 @@ type PostReceivePackRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// Raw data to be copied to stdin of 'git receive-pack'
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// gl_id and gl_repository becomes env variables, used by the Git {pre,post}-receive
// gl_id, gl_repository, and gl_username become env variables, used by the Git {pre,post}-receive
// hooks. They should only be present in the first message of the stream.
GlId string `protobuf:"bytes,3,opt,name=gl_id,json=glId" json:"gl_id,omitempty"`
GlRepository string `protobuf:"bytes,4,opt,name=gl_repository,json=glRepository" json:"gl_repository,omitempty"`
GlUsername string `protobuf:"bytes,5,opt,name=gl_username,json=glUsername" json:"gl_username,omitempty"`
}
func (m *PostReceivePackRequest) Reset() { *m = PostReceivePackRequest{} }
func (m *PostReceivePackRequest) String() string { return proto.CompactTextString(m) }
func (*PostReceivePackRequest) ProtoMessage() {}
func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{4} }
func (m *PostReceivePackRequest) GetRepository() *Repository {
if m != nil {
......@@ -136,6 +137,13 @@ func (m *PostReceivePackRequest) GetGlRepository() string {
return ""
}
func (m *PostReceivePackRequest) GetGlUsername() string {
if m != nil {
return m.GlUsername
}
return ""
}
type PostReceivePackResponse struct {
// Raw data from stdout of 'git receive-pack'
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
......@@ -144,7 +152,7 @@ type PostReceivePackResponse struct {
func (m *PostReceivePackResponse) Reset() { *m = PostReceivePackResponse{} }
func (m *PostReceivePackResponse) String() string { return proto.CompactTextString(m) }
func (*PostReceivePackResponse) ProtoMessage() {}
func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{5} }
func (m *PostReceivePackResponse) GetData() []byte {
if m != nil {
......@@ -459,29 +467,30 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
Metadata: "smarthttp.proto",
}
func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor8) }
var fileDescriptor8 = []byte{
// 327 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x4b, 0xc3, 0x40,
0x10, 0x75, 0x6b, 0x2d, 0x38, 0x56, 0x5b, 0xa6, 0x68, 0x4b, 0x40, 0x2d, 0x11, 0xa4, 0x07, 0x2d,
0xa5, 0xfe, 0x06, 0xc1, 0xa2, 0x87, 0xb2, 0x6d, 0xc1, 0x5b, 0x59, 0x93, 0x6d, 0x1a, 0x5c, 0xbb,
0x71, 0x77, 0x2d, 0xf4, 0xaf, 0xf8, 0xe3, 0xfc, 0x2d, 0x62, 0x42, 0x3e, 0x9a, 0x18, 0x0f, 0x8a,
0xb7, 0x30, 0x6f, 0xe6, 0xbd, 0x37, 0xf3, 0xb2, 0xd0, 0xd0, 0x2f, 0x4c, 0x99, 0xa5, 0x31, 0x41,
0x3f, 0x50, 0xd2, 0x48, 0xac, 0x79, 0xbe, 0x61, 0x62, 0x63, 0xd5, 0xf5, 0x92, 0x29, 0xee, 0x46,
0x55, 0xfb, 0x16, 0x1a, 0xa3, 0xd5, 0x42, 0x52, 0xbe, 0xd0, 0x94, 0xbf, 0xbe, 0x71, 0x6d, 0x70,
0x08, 0xa0, 0x78, 0x20, 0xb5, 0x6f, 0xa4, 0xda, 0x74, 0x48, 0x97, 0xf4, 0x0e, 0x86, 0xd8, 0x8f,
0xa6, 0xfb, 0x34, 0x41, 0x68, 0xa6, 0xcb, 0xbe, 0x84, 0x66, 0x4a, 0xa3, 0x03, 0xb9, 0xd2, 0x1c,
0x11, 0xaa, 0x2e, 0x33, 0x2c, 0x64, 0xa8, 0xd3, 0xf0, 0xdb, 0x9e, 0xc3, 0xf1, 0x58, 0x6a, 0x33,
0x0b, 0x84, 0x64, 0xee, 0x98, 0x39, 0xcf, 0x7f, 0x10, 0x4d, 0x04, 0x2a, 0x19, 0x81, 0x2b, 0x38,
0xc9, 0x0b, 0xfc, 0x60, 0xe7, 0x9d, 0x44, 0xed, 0x94, 0x3b, 0xdc, 0x5f, 0xf3, 0x7f, 0x30, 0x84,
0x2d, 0xd8, 0xf3, 0xc4, 0xdc, 0x77, 0x3b, 0xbb, 0x5d, 0xd2, 0xdb, 0xa7, 0x55, 0x4f, 0x8c, 0x5c,
0xbc, 0x80, 0x43, 0x4f, 0xcc, 0x33, 0xfc, 0xd5, 0x10, 0xac, 0x7b, 0x22, 0x65, 0xb6, 0xaf, 0xa1,
0x5d, 0xf0, 0x56, 0xbe, 0xcb, 0xf0, 0xa3, 0x02, 0xcd, 0xc9, 0x57, 0xe6, 0x77, 0xd3, 0xe9, 0x78,
0xc2, 0xd5, 0xda, 0x77, 0x38, 0xde, 0x03, 0xc6, 0xb9, 0xa4, 0x27, 0xc1, 0x76, 0xbc, 0x47, 0x2e,
0x7a, 0xab, 0x53, 0x04, 0x22, 0x45, 0x7b, 0x67, 0x40, 0xf0, 0x01, 0x5a, 0x69, 0x3d, 0x31, 0xf5,
0x5b, 0xb6, 0x19, 0x1c, 0x6d, 0x27, 0x85, 0xa7, 0x71, 0xff, 0xb7, 0xbf, 0x88, 0x75, 0x56, 0x06,
0xc7, 0xa4, 0x3d, 0x32, 0x20, 0xf8, 0x08, 0x8d, 0xdc, 0xd5, 0x70, 0x6b, 0xb0, 0x18, 0xb5, 0x75,
0x5e, 0x8a, 0x67, 0x99, 0x9f, 0x6a, 0xe1, 0x8b, 0xb9, 0xf9, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xbe,
0x10, 0x08, 0x81, 0x5a, 0x03, 0x00, 0x00,
func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor10) }
var fileDescriptor10 = []byte{
// 346 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0xd1, 0x4e, 0xc2, 0x30,
0x14, 0x75, 0x08, 0x24, 0x5e, 0x50, 0xc8, 0x25, 0xca, 0xb2, 0x44, 0x21, 0x33, 0x31, 0x3c, 0x28,
0x21, 0xf8, 0x0d, 0x26, 0x12, 0x7d, 0x20, 0x05, 0x12, 0xdf, 0x96, 0xca, 0x4a, 0x59, 0x2c, 0x74,
0xb6, 0x85, 0x84, 0x6f, 0xf3, 0x5f, 0xfc, 0x16, 0xe3, 0xe6, 0xd8, 0x00, 0xf1, 0x41, 0xe3, 0xdb,
0x72, 0xcf, 0xe9, 0x39, 0xa7, 0xbd, 0x67, 0x50, 0xd1, 0x33, 0xaa, 0xcc, 0xd4, 0x98, 0xb0, 0x1d,
0x2a, 0x69, 0x24, 0x16, 0x79, 0x60, 0xa8, 0x58, 0x39, 0x65, 0x3d, 0xa5, 0x8a, 0xf9, 0xf1, 0xd4,
0xbd, 0x83, 0x4a, 0x6f, 0x3e, 0x91, 0x84, 0x4d, 0x34, 0x61, 0xaf, 0x0b, 0xa6, 0x0d, 0x76, 0x01,
0x14, 0x0b, 0xa5, 0x0e, 0x8c, 0x54, 0x2b, 0xdb, 0x6a, 0x5a, 0xad, 0x52, 0x17, 0xdb, 0xf1, 0xe9,
0x36, 0x59, 0x23, 0x24, 0xc3, 0x72, 0xaf, 0xa0, 0x9a, 0xca, 0xe8, 0x50, 0xce, 0x35, 0x43, 0x84,
0xbc, 0x4f, 0x0d, 0x8d, 0x14, 0xca, 0x24, 0xfa, 0x76, 0x3d, 0x38, 0xed, 0x4b, 0x6d, 0x46, 0xa1,
0x90, 0xd4, 0xef, 0xd3, 0xf1, 0xcb, 0x1f, 0x4c, 0xd7, 0x06, 0xb9, 0x8c, 0xc1, 0x35, 0x9c, 0x6d,
0x1b, 0xfc, 0x10, 0xe7, 0xcd, 0x8a, 0xe9, 0x84, 0x8d, 0x59, 0xb0, 0x64, 0xff, 0x10, 0x08, 0x6b,
0x50, 0xe0, 0xc2, 0x0b, 0x7c, 0xfb, 0xb0, 0x69, 0xb5, 0x8e, 0x48, 0x9e, 0x8b, 0x9e, 0x8f, 0x97,
0x70, 0xcc, 0x85, 0x97, 0xd1, 0xcf, 0x47, 0x60, 0x99, 0x8b, 0x54, 0x19, 0x1b, 0x50, 0xe2, 0xc2,
0x5b, 0x68, 0xa6, 0xe6, 0x74, 0xc6, 0xec, 0x42, 0x44, 0x01, 0x2e, 0x46, 0x5f, 0x13, 0xf7, 0x06,
0xea, 0x3b, 0xe1, 0xf7, 0x5f, 0xb6, 0xfb, 0x9e, 0x83, 0xea, 0xe0, 0xb3, 0x14, 0xf7, 0xc3, 0x61,
0x7f, 0xc0, 0xd4, 0x32, 0x18, 0x33, 0x7c, 0x00, 0x4c, 0x16, 0x97, 0xbe, 0x19, 0xd6, 0x93, 0x8b,
0x6e, 0x75, 0xc3, 0xb1, 0x77, 0x81, 0xd8, 0xd1, 0x3d, 0xe8, 0x58, 0xf8, 0x08, 0xb5, 0x74, 0xbe,
0x0e, 0xf5, 0x5b, 0xb5, 0x11, 0x9c, 0x6c, 0xae, 0x12, 0xcf, 0x13, 0xfe, 0xb7, 0x1d, 0x72, 0x2e,
0xf6, 0xc1, 0x89, 0x68, 0xcb, 0xea, 0x58, 0xf8, 0x04, 0x95, 0xad, 0x57, 0xc3, 0x8d, 0x83, 0xbb,
0x5d, 0x70, 0x1a, 0x7b, 0xf1, 0xac, 0xf2, 0x73, 0x31, 0xfa, 0xa5, 0x6e, 0x3f, 0x02, 0x00, 0x00,
0xff, 0xff, 0x58, 0x82, 0x47, 0x22, 0x7b, 0x03, 0x00, 0x00,
}
vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go
View file @ 3aef5f9a
......@@ -29,7 +29,7 @@ type SSHUploadPackRequest struct {
func (m *SSHUploadPackRequest) Reset() { *m = SSHUploadPackRequest{} }
func (m *SSHUploadPackRequest) String() string { return proto.CompactTextString(m) }
func (*SSHUploadPackRequest) ProtoMessage() {}
func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
func (m *SSHUploadPackRequest) GetRepository() *Repository {
if m != nil {
......@@ -65,7 +65,7 @@ type SSHUploadPackResponse struct {
func (m *SSHUploadPackResponse) Reset() { *m = SSHUploadPackResponse{} }
func (m *SSHUploadPackResponse) String() string { return proto.CompactTextString(m) }
func (*SSHUploadPackResponse) ProtoMessage() {}
func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
func (m *SSHUploadPackResponse) GetStdout() []byte {
if m != nil {
......@@ -93,16 +93,17 @@ type SSHReceivePackRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// A chunk of raw data to be copied to 'git upload-pack' standard input
Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3" json:"stdin,omitempty"`
// Contents of GL_ID and GL_REPOSITORY environment variables for
// 'git receive-pack'
// Contents of GL_ID, GL_REPOSITORY, and GL_USERNAME environment variables
// for 'git receive-pack'
GlId string `protobuf:"bytes,3,opt,name=gl_id,json=glId" json:"gl_id,omitempty"`
GlRepository string `protobuf:"bytes,4,opt,name=gl_repository,json=glRepository" json:"gl_repository,omitempty"`
GlUsername string `protobuf:"bytes,5,opt,name=gl_username,json=glUsername" json:"gl_username,omitempty"`
}
func (m *SSHReceivePackRequest) Reset() { *m = SSHReceivePackRequest{} }
func (m *SSHReceivePackRequest) String() string { return proto.CompactTextString(m) }
func (*SSHReceivePackRequest) ProtoMessage() {}
func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{2} }
func (m *SSHReceivePackRequest) GetRepository() *Repository {
if m != nil {
......@@ -132,6 +133,13 @@ func (m *SSHReceivePackRequest) GetGlRepository() string {
return ""
}
func (m *SSHReceivePackRequest) GetGlUsername() string {
if m != nil {
return m.GlUsername
}
return ""
}
type SSHReceivePackResponse struct {
// A chunk of raw data from 'git receive-pack' standard output
Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3" json:"stdout,omitempty"`
......@@ -145,7 +153,7 @@ type SSHReceivePackResponse struct {
func (m *SSHReceivePackResponse) Reset() { *m = SSHReceivePackResponse{} }
func (m *SSHReceivePackResponse) String() string { return proto.CompactTextString(m) }
func (*SSHReceivePackResponse) ProtoMessage() {}
func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{3} }
func (m *SSHReceivePackResponse) GetStdout() []byte {
if m != nil {
......@@ -348,31 +356,32 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
Metadata: "ssh.proto",
}
func init() { proto.RegisterFile("ssh.proto", fileDescriptor9) }
var fileDescriptor9 = []byte{
// 360 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x93, 0xc1, 0x4e, 0xf2, 0x40,
0x10, 0xc7, 0xbf, 0xfd, 0x28, 0xe4, 0x63, 0x28, 0x5f, 0xc8, 0x0a, 0xa4, 0x21, 0x6a, 0x48, 0xbd,
0xf4, 0x60, 0x88, 0x81, 0x47, 0x30, 0x26, 0xe8, 0x45, 0xb3, 0x0d, 0xe7, 0xa6, 0xb6, 0xeb, 0xb2,
0xb1, 0x76, 0xeb, 0xee, 0x40, 0x20, 0xd1, 0x27, 0xf1, 0x11, 0x7c, 0x00, 0x5f, 0xcf, 0xa4, 0xad,
0x58, 0x50, 0x8e, 0x7a, 0xdb, 0x99, 0xdf, 0xce, 0xcc, 0x7f, 0x66, 0x76, 0xa1, 0x69, 0xcc, 0x7c,
0x94, 0x69, 0x85, 0x8a, 0x36, 0x84, 0xc4, 0x30, 0x59, 0x0f, 0x6c, 0x33, 0x0f, 0x35, 0x8f, 0x0b,
0xaf, 0xfb, 0x4a, 0xa0, 0xeb, 0xfb, 0xd3, 0x59, 0x96, 0xa8, 0x30, 0xbe, 0x09, 0xa3, 0x7b, 0xc6,
0x1f, 0x17, 0xdc, 0x20, 0x1d, 0x03, 0x68, 0x9e, 0x29, 0x23, 0x51, 0xe9, 0xb5, 0x43, 0x86, 0xc4,
0x6b, 0x8d, 0xe9, 0xa8, 0xc8, 0x31, 0x62, 0x1b, 0xc2, 0x2a, 0xb7, 0x68, 0x17, 0xea, 0x06, 0x63,
0x99, 0x3a, 0x7f, 0x87, 0xc4, 0xb3, 0x59, 0x61, 0xd0, 0x53, 0xa0, 0x42, 0x62, 0x10, 0xa9, 0xf4,
0x4e, 0x8a, 0x40, 0x65, 0x28, 0x55, 0x6a, 0x1c, 0x6b, 0x58, 0xf3, 0x9a, 0xac, 0x23, 0x24, 0x9e,
0xe7, 0xe0, 0xba, 0xf0, 0x5f, 0x59, 0xff, 0x6a, 0x1d, 0x8b, 0xf5, 0x2a, 0x11, 0x59, 0xa8, 0xc3,
0x07, 0x8e, 0x5c, 0x1b, 0xf7, 0x09, 0x7a, 0x3b, 0x62, 0x4d, 0xa6, 0x52, 0xc3, 0x69, 0x1f, 0x1a,
0x06, 0x63, 0xb5, 0xc0, 0x5c, 0xa9, 0xcd, 0x4a, 0xab, 0xf4, 0x73, 0xad, 0x4b, 0x49, 0xa5, 0x45,
0x27, 0xd0, 0xe2, 0x2b, 0x89, 0x81, 0xc1, 0x10, 0x17, 0xc6, 0xa9, 0x6d, 0xb7, 0x77, 0xb1, 0x92,
0xe8, 0xe7, 0x84, 0x01, 0xdf, 0x9c, 0xdd, 0x17, 0x92, 0x97, 0x67, 0x3c, 0xe2, 0x72, 0xc9, 0x7f,
0x66, 0x58, 0x07, 0x50, 0x17, 0x49, 0x20, 0xe3, 0x5c, 0x52, 0x93, 0x59, 0x22, 0xb9, 0x8c, 0xe9,
0x09, 0xb4, 0x45, 0x12, 0x54, 0x2a, 0x58, 0x39, 0xb4, 0x45, 0xf2, 0x99, 0xdb, 0x7d, 0x86, 0xfe,
0xae, 0xb8, 0x5f, 0x1c, 0xce, 0xf8, 0x8d, 0x00, 0xf8, 0xfe, 0xd4, 0xe7, 0x7a, 0x29, 0x23, 0x4e,
0x19, 0xb4, 0xb7, 0x36, 0x45, 0x0f, 0x3f, 0xe2, 0xbf, 0x7b, 0x6d, 0x83, 0xa3, 0x3d, 0xb4, 0xe8,
0xc0, 0xfd, 0xe3, 0x91, 0x33, 0x42, 0x67, 0xf0, 0x7f, 0xbb, 0x43, 0x5a, 0x0d, 0xfb, 0xba, 0x96,
0xc1, 0xf1, 0x3e, 0x5c, 0x4d, 0x7b, 0xdb, 0xc8, 0x7f, 0xc2, 0xe4, 0x3d, 0x00, 0x00, 0xff, 0xff,
0x2e, 0x25, 0xf4, 0x8b, 0x2c, 0x03, 0x00, 0x00,
func init() { proto.RegisterFile("ssh.proto", fileDescriptor11) }
var fileDescriptor11 = []byte{
// 377 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xcd, 0xce, 0xd2, 0x40,
0x14, 0x75, 0xa4, 0x10, 0xb9, 0xf4, 0x33, 0x64, 0x04, 0xd2, 0x10, 0x7f, 0x48, 0xdd, 0x74, 0x61,
0x88, 0x81, 0x47, 0x30, 0x26, 0xe8, 0x46, 0x33, 0x0d, 0xeb, 0x66, 0x6c, 0xaf, 0xc3, 0xc4, 0xa1,
0x53, 0x67, 0xa6, 0x04, 0x12, 0x7d, 0x22, 0x1f, 0xc0, 0x8d, 0x0f, 0x67, 0x32, 0xad, 0x58, 0x50,
0x96, 0xba, 0xeb, 0x3d, 0xe7, 0xfe, 0x9c, 0x73, 0x6f, 0x07, 0x86, 0xd6, 0xee, 0x96, 0x95, 0xd1,
0x4e, 0xd3, 0x81, 0x90, 0x8e, 0xab, 0xd3, 0x3c, 0xb4, 0x3b, 0x6e, 0xb0, 0x68, 0xd0, 0xf8, 0x1b,
0x81, 0x49, 0x9a, 0x6e, 0xb6, 0x95, 0xd2, 0xbc, 0x78, 0xcf, 0xf3, 0x4f, 0x0c, 0x3f, 0xd7, 0x68,
0x1d, 0x5d, 0x01, 0x18, 0xac, 0xb4, 0x95, 0x4e, 0x9b, 0x53, 0x44, 0x16, 0x24, 0x19, 0xad, 0xe8,
0xb2, 0xe9, 0xb1, 0x64, 0x67, 0x86, 0x75, 0xb2, 0xe8, 0x04, 0xfa, 0xd6, 0x15, 0xb2, 0x8c, 0xee,
0x2f, 0x48, 0x12, 0xb2, 0x26, 0xa0, 0x2f, 0x80, 0x0a, 0xe9, 0xb2, 0x5c, 0x97, 0x1f, 0xa5, 0xc8,
0x74, 0xe5, 0xa4, 0x2e, 0x6d, 0x14, 0x2c, 0x7a, 0xc9, 0x90, 0x8d, 0x85, 0x74, 0xaf, 0x3c, 0xf1,
0xae, 0xc1, 0xdf, 0x06, 0x0f, 0x7a, 0xe3, 0x80, 0x4d, 0x3b, 0x15, 0x15, 0x37, 0x7c, 0x8f, 0x0e,
0x8d, 0x8d, 0xbf, 0xc0, 0xf4, 0x4a, 0xac, 0xad, 0x74, 0x69, 0x91, 0xce, 0x60, 0x60, 0x5d, 0xa1,
0x6b, 0xe7, 0x95, 0x86, 0xac, 0x8d, 0x5a, 0x1c, 0x8d, 0x69, 0x25, 0xb5, 0x11, 0x5d, 0xc3, 0x08,
0x8f, 0xd2, 0x65, 0xd6, 0x71, 0x57, 0xdb, 0xa8, 0x77, 0x69, 0xef, 0xf5, 0x51, 0xba, 0xd4, 0x33,
0x0c, 0xf0, 0xfc, 0x1d, 0xff, 0x20, 0x7e, 0x3c, 0xc3, 0x1c, 0xe5, 0x01, 0xff, 0xcd, 0xb2, 0x1e,
0x41, 0x5f, 0xa8, 0x4c, 0x16, 0x5e, 0xd2, 0x90, 0x05, 0x42, 0xbd, 0x29, 0xe8, 0x73, 0xb8, 0x13,
0x2a, 0xeb, 0x4c, 0x08, 0x3c, 0x19, 0x0a, 0xf5, 0xbb, 0x37, 0x7d, 0x06, 0x23, 0xa1, 0xb2, 0xda,
0xa2, 0x29, 0xf9, 0x1e, 0xa3, 0xbe, 0x4f, 0x01, 0xa1, 0xb6, 0x2d, 0x12, 0x7f, 0x85, 0xd9, 0xb5,
0xfa, 0xff, 0xb8, 0xbd, 0xd5, 0x77, 0x02, 0x90, 0xa6, 0x9b, 0x14, 0xcd, 0x41, 0xe6, 0x48, 0x19,
0xdc, 0x5d, 0x9c, 0x92, 0x3e, 0xfe, 0x55, 0xff, 0xb7, 0xdf, 0x71, 0xfe, 0xe4, 0x06, 0xdb, 0x38,
0x88, 0xef, 0x25, 0xe4, 0x25, 0xa1, 0x5b, 0x78, 0x78, 0xe9, 0x90, 0x76, 0xcb, 0xfe, 0xbc, 0xdb,
0xfc, 0xe9, 0x2d, 0xba, 0xdb, 0xf6, 0xc3, 0xc0, 0x3f, 0x95, 0xf5, 0xcf, 0x00, 0x00, 0x00, 0xff,
0xff, 0x1b, 0x65, 0x3d, 0xab, 0x4d, 0x03, 0x00, 0x00,
}
vendor/vendor.json
View file @ 3aef5f9a
......@@ -146,12 +146,12 @@
"revisionTime": "2016-11-17T07:43:51Z"
},
{
"checksumSHA1": "TEYQhyNOlpU0WpNjmujBqT6++jU=",
"checksumSHA1": "A2jWY7L3EazZt0xdKFKMDOGXCdk=",
"path": "gitlab.com/gitlab-org/gitaly-proto/go",
"revision": "30b876cba87a2cc52a5fa5eb92e01df85ad48ff1",
"revisionTime": "2017-08-16T10:07:43Z",
"version": "v0.29.0",
"versionExact": "v0.29.0"
"revision": "b61fee8cd76e282d15a3c719f7f71a4f71ef0d6c",
"revisionTime": "2017-09-20T19:16:33Z",
"version": "v0.35.0",
"versionExact": "v0.35.0"
},
{
"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7