Skip to content

G
gitlab-shell
Commit 27bdba30 authored by Alejandro Rodríguez's avatar Alejandro Rodríguez
Browse files
Options

Add Gitaly git-upload-archive migrated command

parent 9b9ada10
Hide whitespace changes
Inline Side-by-side
Showing with 2457 additions and 666 deletions
.gitignore
View file @ 27bdba30
......@@ -14,3 +14,4 @@ hooks/*.d
/go_build
/bin/gitaly-upload-pack
/bin/gitaly-receive-pack
/bin/gitaly-upload-archive
CHANGELOG
View file @ 27bdba30
v7.1.0
- Migrate `git-upload-archive` to gitaly
v7.0.0
- Switch to structured logging (!193)
......
go/cmd/gitaly-upload-archive/main.go 0 → 100644
View file @ 27bdba30
package main
import (
"encoding/json"
"fmt"
"os"
"gitlab.com/gitlab-org/gitlab-shell/go/internal/handler"
"gitlab.com/gitlab-org/gitlab-shell/go/internal/logger"
pb "gitlab.com/gitlab-org/gitaly-proto/go"
)
func init() {
logger.ProgName = "gitaly-upload-archive"
}
type uploadArchiveHandler func(gitalyAddress string, request *pb.SSHUploadArchiveRequest) (int32, error)
func main() {
if err := handler.Prepare(); err != nil {
logger.Fatal("preparation failed", err)
}
code, err := uploadArchive(handler.UploadArchive, os.Args)
if err != nil {
logger.Fatal("upload-archive failed", err)
}
os.Exit(int(code))
}
func uploadArchive(handler uploadArchiveHandler, args []string) (int32, error) {
if n := len(args); n != 3 {
return 0, fmt.Errorf("wrong number of arguments: expected 2 arguments, got %v", args)
}
var request pb.SSHUploadArchiveRequest
if err := json.Unmarshal([]byte(args[2]), &request); err != nil {
return 0, fmt.Errorf("unmarshaling request json failed: %v", err)
}
return handler(args[1], &request)
}
go/cmd/gitaly-upload-archive/main_test.go 0 → 100644
View file @ 27bdba30
package main
import (
"fmt"
"strings"
"testing"
pb "gitlab.com/gitlab-org/gitaly-proto/go"
)
var testGitalyAddress = "unix:gitaly.socket"
func TestUploadArchiveSuccess(t *testing.T) {
testRelativePath := "myrepo.git"
requestJSON := fmt.Sprintf(`{"repository":{"relative_path":"%s"}}`, testRelativePath)
mockHandler := func(gitalyAddress string, request *pb.SSHUploadArchiveRequest) (int32, error) {
if gitalyAddress != testGitalyAddress {
t.Fatalf("Expected gitaly address %s got %v", testGitalyAddress, gitalyAddress)
}
if relativePath := request.Repository.RelativePath; relativePath != testRelativePath {
t.Fatalf("Expected repository with relative path %s got %v", testRelativePath, request)
}
return 0, nil
}
code, err := uploadArchive(mockHandler, []string{"git-upload-archive", testGitalyAddress, requestJSON})
if err != nil {
t.Fatal(err)
}
if code != 0 {
t.Fatalf("Expected exit code 0, got %v", code)
}
}
func TestUploadArchiveFailure(t *testing.T) {
mockHandler := func(_ string, _ *pb.SSHUploadArchiveRequest) (int32, error) {
t.Fatal("Expected handler not to be called")
return 0, nil
}
tests := []struct {
desc string
args []string
err string
}{
{
desc: "With an invalid request json",
args: []string{"git-upload-archive", testGitalyAddress, "hello"},
err: "unmarshaling request json failed",
},
{
desc: "With an invalid argument count",
args: []string{"git-upload-archive", testGitalyAddress, "{}", "extra arg"},
err: "wrong number of arguments: expected 2 arguments",
},
}
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
_, err := uploadArchive(mockHandler, test.args)
if !strings.Contains(err.Error(), test.err) {
t.Fatalf("Expected error %v, got %v", test.err, err)
}
})
}
}
go/internal/handler/upload_archive.go 0 → 100644
View file @ 27bdba30
package handler
import (
"context"
"fmt"
"os"
pb "gitlab.com/gitlab-org/gitaly-proto/go"
"gitlab.com/gitlab-org/gitaly/client"
)
func UploadArchive(gitalyAddress string, request *pb.SSHUploadArchiveRequest) (int32, error) {
if gitalyAddress == "" {
return 0, fmt.Errorf("no gitaly_address given")
}
conn, err := client.Dial(gitalyAddress, dialOpts())
if err != nil {
return 0, err
}
defer conn.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
return client.UploadArchive(ctx, conn, os.Stdin, os.Stdout, os.Stderr, request)
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go
View file @ 27bdba30
......@@ -16,6 +16,7 @@ It is generated from these files:
ref.proto
remote.proto
repository-service.proto
server.proto
shared.proto
smarthttp.proto
ssh.proto
......@@ -29,6 +30,10 @@ It has these top-level messages:
LFSPointer
GetLFSPointersRequest
GetLFSPointersResponse
GetNewLFSPointersRequest
GetNewLFSPointersResponse
GetAllLFSPointersRequest
GetAllLFSPointersResponse
CommitStatsRequest
CommitStatsResponse
CommitIsAncestorRequest
......@@ -64,6 +69,8 @@ It has these top-level messages:
FilterShasWithSignaturesResponse
ExtractCommitSignatureRequest
ExtractCommitSignatureResponse
GetCommitSignaturesRequest
GetCommitSignaturesResponse
ListConflictFilesRequest
ConflictFileHeader
ConflictFile
......@@ -116,6 +123,8 @@ It has these top-level messages:
UserCommitFilesResponse
UserRebaseRequest
UserRebaseResponse
UserSquashRequest
UserSquashResponse
FindDefaultBranchNameRequest
FindDefaultBranchNameResponse
FindAllBranchNamesRequest
......@@ -156,8 +165,6 @@ It has these top-level messages:
UpdateRemoteMirrorResponse
RepositoryExistsRequest
RepositoryExistsResponse
RepositoryIsEmptyRequest
RepositoryIsEmptyResponse
RepackIncrementalRequest
RepackIncrementalResponse
RepackFullRequest
......@@ -188,8 +195,20 @@ It has these top-level messages:
CreateForkResponse
IsRebaseInProgressRequest
IsRebaseInProgressResponse
IsSquashInProgressRequest
IsSquashInProgressResponse
CreateRepositoryFromURLRequest
CreateRepositoryFromURLResponse
CreateBundleRequest
CreateBundleResponse
WriteConfigRequest
WriteConfigResponse
CreateRepositoryFromBundleRequest
CreateRepositoryFromBundleResponse
FindLicenseRequest
FindLicenseResponse
ServerInfoRequest
ServerInfoResponse
Repository
GitCommit
CommitAuthor
......@@ -207,6 +226,8 @@ It has these top-level messages:
SSHUploadPackResponse
SSHReceivePackRequest
SSHReceivePackResponse
SSHUploadArchiveRequest
SSHUploadArchiveResponse
WikiCommitDetails
WikiPageVersion
WikiPage
......@@ -224,6 +245,8 @@ It has these top-level messages:
WikiFindFileResponse
WikiGetAllPagesRequest
WikiGetAllPagesResponse
WikiGetFormattedDataRequest
WikiGetFormattedDataResponse
*/
package gitaly
......@@ -318,8 +341,8 @@ func (m *GetBlobResponse) GetOid() string {
type GetBlobsRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// Object IDs (SHA1) of the blobs we want to get
Oids []string `protobuf:"bytes,2,rep,name=oids" json:"oids,omitempty"`
// Revision/Path pairs of the blobs we want to get.
RevisionPaths []*GetBlobsRequest_RevisionPath `protobuf:"bytes,2,rep,name=revision_paths,json=revisionPaths" json:"revision_paths,omitempty"`
// Maximum number of bytes we want to receive. Use '-1' to get the full blobs no matter how big.
Limit int64 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
}
......@@ -336,9 +359,9 @@ func (m *GetBlobsRequest) GetRepository() *Repository {
return nil
}
func (m *GetBlobsRequest) GetOids() []string {
func (m *GetBlobsRequest) GetRevisionPaths() []*GetBlobsRequest_RevisionPath {
if m != nil {
return m.Oids
return m.RevisionPaths
}
return nil
}
......@@ -350,13 +373,41 @@ func (m *GetBlobsRequest) GetLimit() int64 {
return 0
}
type GetBlobsRequest_RevisionPath struct {
Revision string `protobuf:"bytes,1,opt,name=revision" json:"revision,omitempty"`
Path []byte `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
}
func (m *GetBlobsRequest_RevisionPath) Reset() { *m = GetBlobsRequest_RevisionPath{} }
func (m *GetBlobsRequest_RevisionPath) String() string { return proto.CompactTextString(m) }
func (*GetBlobsRequest_RevisionPath) ProtoMessage() {}
func (*GetBlobsRequest_RevisionPath) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
func (m *GetBlobsRequest_RevisionPath) GetRevision() string {
if m != nil {
return m.Revision
}
return ""
}
func (m *GetBlobsRequest_RevisionPath) GetPath() []byte {
if m != nil {
return m.Path
}
return nil
}
type GetBlobsResponse struct {
// Blob size; present only on the first message per blob
Size int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
// Chunk of blob data
// Chunk of blob data, could span over multiple messages.
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// Object ID of the current blob. Only present on the first message per blob. Empty if no blob was found.
Oid string `protobuf:"bytes,3,opt,name=oid" json:"oid,omitempty"`
Oid string `protobuf:"bytes,3,opt,name=oid" json:"oid,omitempty"`
IsSubmodule bool `protobuf:"varint,4,opt,name=is_submodule,json=isSubmodule" json:"is_submodule,omitempty"`
Mode int32 `protobuf:"varint,5,opt,name=mode" json:"mode,omitempty"`
Revision string `protobuf:"bytes,6,opt,name=revision" json:"revision,omitempty"`
Path []byte `protobuf:"bytes,7,opt,name=path,proto3" json:"path,omitempty"`
}
func (m *GetBlobsResponse) Reset() { *m = GetBlobsResponse{} }
......@@ -385,6 +436,34 @@ func (m *GetBlobsResponse) GetOid() string {
return ""
}
func (m *GetBlobsResponse) GetIsSubmodule() bool {
if m != nil {
return m.IsSubmodule
}
return false
}
func (m *GetBlobsResponse) GetMode() int32 {
if m != nil {
return m.Mode
}
return 0
}
func (m *GetBlobsResponse) GetRevision() string {
if m != nil {
return m.Revision
}
return ""
}
func (m *GetBlobsResponse) GetPath() []byte {
if m != nil {
return m.Path
}
return nil
}
type LFSPointer struct {
Size int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
......@@ -457,14 +536,124 @@ func (m *GetLFSPointersResponse) GetLfsPointers() []*LFSPointer {
return nil
}
type GetNewLFSPointersRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
Limit int32 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
// Note: When `not_in_all` is true, `not_in_refs` is ignored
NotInAll bool `protobuf:"varint,4,opt,name=not_in_all,json=notInAll" json:"not_in_all,omitempty"`
NotInRefs [][]byte `protobuf:"bytes,5,rep,name=not_in_refs,json=notInRefs,proto3" json:"not_in_refs,omitempty"`
}
func (m *GetNewLFSPointersRequest) Reset() { *m = GetNewLFSPointersRequest{} }
func (m *GetNewLFSPointersRequest) String() string { return proto.CompactTextString(m) }
func (*GetNewLFSPointersRequest) ProtoMessage() {}
func (*GetNewLFSPointersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *GetNewLFSPointersRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *GetNewLFSPointersRequest) GetRevision() []byte {
if m != nil {
return m.Revision
}
return nil
}
func (m *GetNewLFSPointersRequest) GetLimit() int32 {
if m != nil {
return m.Limit
}
return 0
}
func (m *GetNewLFSPointersRequest) GetNotInAll() bool {
if m != nil {
return m.NotInAll
}
return false
}
func (m *GetNewLFSPointersRequest) GetNotInRefs() [][]byte {
if m != nil {
return m.NotInRefs
}
return nil
}
type GetNewLFSPointersResponse struct {
LfsPointers []*LFSPointer `protobuf:"bytes,1,rep,name=lfs_pointers,json=lfsPointers" json:"lfs_pointers,omitempty"`
}
func (m *GetNewLFSPointersResponse) Reset() { *m = GetNewLFSPointersResponse{} }
func (m *GetNewLFSPointersResponse) String() string { return proto.CompactTextString(m) }
func (*GetNewLFSPointersResponse) ProtoMessage() {}
func (*GetNewLFSPointersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
func (m *GetNewLFSPointersResponse) GetLfsPointers() []*LFSPointer {
if m != nil {
return m.LfsPointers
}
return nil
}
type GetAllLFSPointersRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
}
func (m *GetAllLFSPointersRequest) Reset() { *m = GetAllLFSPointersRequest{} }
func (m *GetAllLFSPointersRequest) String() string { return proto.CompactTextString(m) }
func (*GetAllLFSPointersRequest) ProtoMessage() {}
func (*GetAllLFSPointersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
func (m *GetAllLFSPointersRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *GetAllLFSPointersRequest) GetRevision() []byte {
if m != nil {
return m.Revision
}
return nil
}
type GetAllLFSPointersResponse struct {
LfsPointers []*LFSPointer `protobuf:"bytes,1,rep,name=lfs_pointers,json=lfsPointers" json:"lfs_pointers,omitempty"`
}
func (m *GetAllLFSPointersResponse) Reset() { *m = GetAllLFSPointersResponse{} }
func (m *GetAllLFSPointersResponse) String() string { return proto.CompactTextString(m) }
func (*GetAllLFSPointersResponse) ProtoMessage() {}
func (*GetAllLFSPointersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
func (m *GetAllLFSPointersResponse) GetLfsPointers() []*LFSPointer {
if m != nil {
return m.LfsPointers
}
return nil
}
func init() {
proto.RegisterType((*GetBlobRequest)(nil), "gitaly.GetBlobRequest")
proto.RegisterType((*GetBlobResponse)(nil), "gitaly.GetBlobResponse")
proto.RegisterType((*GetBlobsRequest)(nil), "gitaly.GetBlobsRequest")
proto.RegisterType((*GetBlobsRequest_RevisionPath)(nil), "gitaly.GetBlobsRequest.RevisionPath")
proto.RegisterType((*GetBlobsResponse)(nil), "gitaly.GetBlobsResponse")
proto.RegisterType((*LFSPointer)(nil), "gitaly.LFSPointer")
proto.RegisterType((*GetLFSPointersRequest)(nil), "gitaly.GetLFSPointersRequest")
proto.RegisterType((*GetLFSPointersResponse)(nil), "gitaly.GetLFSPointersResponse")
proto.RegisterType((*GetNewLFSPointersRequest)(nil), "gitaly.GetNewLFSPointersRequest")
proto.RegisterType((*GetNewLFSPointersResponse)(nil), "gitaly.GetNewLFSPointersResponse")
proto.RegisterType((*GetAllLFSPointersRequest)(nil), "gitaly.GetAllLFSPointersRequest")
proto.RegisterType((*GetAllLFSPointersResponse)(nil), "gitaly.GetAllLFSPointersResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
......@@ -482,12 +671,10 @@ type BlobServiceClient interface {
// ID. We use a stream to return a chunked arbitrarily large binary
// response
GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (BlobService_GetBlobClient, error)
// GetBlobsBySHA returns the contents of a blob objects referenced by their object
// ID. We use a stream to return a chunked arbitrarily large binary response.
// The blobs are sent in a continous stream, the caller is responsible for spliting
// them up into multiple blobs by their object IDs.
GetBlobs(ctx context.Context, in *GetBlobsRequest, opts ...grpc.CallOption) (BlobService_GetBlobsClient, error)
GetLFSPointers(ctx context.Context, in *GetLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetLFSPointersClient, error)
GetNewLFSPointers(ctx context.Context, in *GetNewLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetNewLFSPointersClient, error)
GetAllLFSPointers(ctx context.Context, in *GetAllLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetAllLFSPointersClient, error)
}
type blobServiceClient struct {
......@@ -594,6 +781,70 @@ func (x *blobServiceGetLFSPointersClient) Recv() (*GetLFSPointersResponse, error
return m, nil
}
func (c *blobServiceClient) GetNewLFSPointers(ctx context.Context, in *GetNewLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetNewLFSPointersClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[3], c.cc, "/gitaly.BlobService/GetNewLFSPointers", opts...)
if err != nil {
return nil, err
}
x := &blobServiceGetNewLFSPointersClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BlobService_GetNewLFSPointersClient interface {
Recv() (*GetNewLFSPointersResponse, error)
grpc.ClientStream
}
type blobServiceGetNewLFSPointersClient struct {
grpc.ClientStream
}
func (x *blobServiceGetNewLFSPointersClient) Recv() (*GetNewLFSPointersResponse, error) {
m := new(GetNewLFSPointersResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *blobServiceClient) GetAllLFSPointers(ctx context.Context, in *GetAllLFSPointersRequest, opts ...grpc.CallOption) (BlobService_GetAllLFSPointersClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[4], c.cc, "/gitaly.BlobService/GetAllLFSPointers", opts...)
if err != nil {
return nil, err
}
x := &blobServiceGetAllLFSPointersClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BlobService_GetAllLFSPointersClient interface {
Recv() (*GetAllLFSPointersResponse, error)
grpc.ClientStream
}
type blobServiceGetAllLFSPointersClient struct {
grpc.ClientStream
}
func (x *blobServiceGetAllLFSPointersClient) Recv() (*GetAllLFSPointersResponse, error) {
m := new(GetAllLFSPointersResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for BlobService service
type BlobServiceServer interface {
......@@ -601,12 +852,10 @@ type BlobServiceServer interface {
// ID. We use a stream to return a chunked arbitrarily large binary
// response
GetBlob(*GetBlobRequest, BlobService_GetBlobServer) error
// GetBlobsBySHA returns the contents of a blob objects referenced by their object
// ID. We use a stream to return a chunked arbitrarily large binary response.
// The blobs are sent in a continous stream, the caller is responsible for spliting
// them up into multiple blobs by their object IDs.
GetBlobs(*GetBlobsRequest, BlobService_GetBlobsServer) error
GetLFSPointers(*GetLFSPointersRequest, BlobService_GetLFSPointersServer) error
GetNewLFSPointers(*GetNewLFSPointersRequest, BlobService_GetNewLFSPointersServer) error
GetAllLFSPointers(*GetAllLFSPointersRequest, BlobService_GetAllLFSPointersServer) error
}
func RegisterBlobServiceServer(s *grpc.Server, srv BlobServiceServer) {
......@@ -676,6 +925,48 @@ func (x *blobServiceGetLFSPointersServer) Send(m *GetLFSPointersResponse) error
return x.ServerStream.SendMsg(m)
}
func _BlobService_GetNewLFSPointers_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetNewLFSPointersRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BlobServiceServer).GetNewLFSPointers(m, &blobServiceGetNewLFSPointersServer{stream})
}
type BlobService_GetNewLFSPointersServer interface {
Send(*GetNewLFSPointersResponse) error
grpc.ServerStream
}
type blobServiceGetNewLFSPointersServer struct {
grpc.ServerStream
}
func (x *blobServiceGetNewLFSPointersServer) Send(m *GetNewLFSPointersResponse) error {
return x.ServerStream.SendMsg(m)
}
func _BlobService_GetAllLFSPointers_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetAllLFSPointersRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BlobServiceServer).GetAllLFSPointers(m, &blobServiceGetAllLFSPointersServer{stream})
}
type BlobService_GetAllLFSPointersServer interface {
Send(*GetAllLFSPointersResponse) error
grpc.ServerStream
}
type blobServiceGetAllLFSPointersServer struct {
grpc.ServerStream
}
func (x *blobServiceGetAllLFSPointersServer) Send(m *GetAllLFSPointersResponse) error {
return x.ServerStream.SendMsg(m)
}
var _BlobService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.BlobService",
HandlerType: (*BlobServiceServer)(nil),
......@@ -696,6 +987,16 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
Handler: _BlobService_GetLFSPointers_Handler,
ServerStreams: true,
},
{
StreamName: "GetNewLFSPointers",
Handler: _BlobService_GetNewLFSPointers_Handler,
ServerStreams: true,
},
{
StreamName: "GetAllLFSPointers",
Handler: _BlobService_GetAllLFSPointers_Handler,
ServerStreams: true,
},
},
Metadata: "blob.proto",
}
......@@ -703,28 +1004,41 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("blob.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 353 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0xcd, 0x4e, 0xe3, 0x30,
0x10, 0x5e, 0xd7, 0xdd, 0xfe, 0x4c, 0xab, 0xdd, 0x6a, 0xb4, 0x5b, 0x42, 0x24, 0x50, 0x94, 0x53,
0x4e, 0x15, 0x2a, 0xe2, 0x8a, 0x04, 0x87, 0x56, 0x88, 0x4a, 0x20, 0xf7, 0x01, 0xaa, 0x84, 0xb8,
0x60, 0xc9, 0xd4, 0x21, 0x36, 0x48, 0xe5, 0x7d, 0x79, 0x0f, 0x14, 0xa7, 0xf9, 0xa1, 0x55, 0x4f,
0xb9, 0x8d, 0x67, 0xe6, 0xfb, 0xc9, 0x17, 0x1b, 0x20, 0x92, 0x2a, 0x9a, 0x24, 0xa9, 0x32, 0x0a,
0x3b, 0xcf, 0xc2, 0x84, 0x72, 0xeb, 0x0e, 0xf5, 0x4b, 0x98, 0xf2, 0x38, 0xef, 0xfa, 0x12, 0xfe,
0xcc, 0xb9, 0xb9, 0x95, 0x2a, 0x62, 0xfc, 0xed, 0x9d, 0x6b, 0x83, 0x53, 0x80, 0x94, 0x27, 0x4a,
0x0b, 0xa3, 0xd2, 0xad, 0x43, 0x3c, 0x12, 0x0c, 0xa6, 0x38, 0xc9, 0xc1, 0x13, 0x56, 0x4e, 0x58,
0x6d, 0x0b, 0x47, 0x40, 0x95, 0x88, 0x9d, 0x96, 0x47, 0x82, 0x3e, 0xcb, 0x4a, 0xfc, 0x07, 0xbf,
0xa5, 0x78, 0x15, 0xc6, 0xa1, 0x1e, 0x09, 0x28, 0xcb, 0x0f, 0xfe, 0x3d, 0xfc, 0x2d, 0xd5, 0x74,
0xa2, 0x36, 0x9a, 0x23, 0x42, 0x5b, 0x8b, 0x4f, 0x6e, 0x85, 0x28, 0xb3, 0x75, 0xd6, 0x8b, 0x43,
0x13, 0x5a, 0xbe, 0x21, 0xb3, 0x75, 0x21, 0x41, 0x4b, 0x09, 0x5f, 0x95, 0x64, 0xba, 0x89, 0x77,
0x84, 0xb6, 0x12, 0xb1, 0x76, 0x5a, 0x1e, 0x0d, 0xfa, 0xcc, 0xd6, 0x47, 0xdc, 0x2f, 0x60, 0x54,
0x09, 0x36, 0xb6, 0x3f, 0x03, 0x58, 0xcc, 0x96, 0x8f, 0x4a, 0x6c, 0x0c, 0x4f, 0x1b, 0xf0, 0xac,
0xe1, 0xff, 0x9c, 0x9b, 0x8a, 0xaa, 0x51, 0x18, 0xa7, 0xd0, 0xcb, 0xae, 0xcc, 0xaa, 0x0a, 0xa4,
0x9b, 0x9d, 0xef, 0x62, 0xed, 0x3f, 0xc0, 0x78, 0x5f, 0x67, 0x97, 0xc1, 0x15, 0x0c, 0xe5, 0x5a,
0xaf, 0x92, 0x5d, 0xdf, 0x21, 0x1e, 0xad, 0x4b, 0x55, 0x10, 0x36, 0x90, 0x6b, 0x5d, 0xc0, 0xa7,
0x5f, 0x04, 0x06, 0x59, 0x98, 0x4b, 0x9e, 0x7e, 0x88, 0x27, 0x8e, 0xd7, 0xd0, 0xdd, 0xc5, 0x8b,
0xe3, 0x02, 0xfb, 0xf3, 0x6e, 0xba, 0x27, 0x07, 0xfd, 0xdc, 0x82, 0xff, 0xeb, 0x82, 0xe0, 0x0d,
0xf4, 0x8a, 0xdf, 0x83, 0xfb, 0x8b, 0x45, 0x28, 0xae, 0x73, 0x38, 0xa8, 0x51, 0x2c, 0xed, 0x6b,
0xa8, 0x7d, 0x23, 0x9e, 0xd5, 0xf6, 0x0f, 0x33, 0x76, 0xcf, 0x8f, 0x8d, 0x2b, 0xd2, 0xa8, 0x63,
0x5f, 0xda, 0xe5, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xeb, 0x6b, 0x28, 0x11, 0x8d, 0x03, 0x00,
0x00,
// 572 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0x66, 0xeb, 0xe6, 0x6f, 0x6c, 0x4a, 0x59, 0x41, 0xeb, 0x5a, 0x50, 0xb9, 0x16, 0x07, 0x9f,
0x22, 0x14, 0xc4, 0xb5, 0x52, 0x38, 0x34, 0xaa, 0x8a, 0xa0, 0xda, 0x5c, 0x91, 0x2c, 0x07, 0x6f,
0xc8, 0xa2, 0x8d, 0x37, 0x78, 0x37, 0x45, 0xe5, 0x6d, 0x78, 0x06, 0xee, 0x3c, 0x0f, 0x8f, 0x81,
0xbc, 0xfe, 0xc9, 0xe6, 0x8f, 0x8b, 0xe9, 0x6d, 0x76, 0x66, 0xe7, 0x9b, 0x6f, 0xe6, 0x9b, 0xb5,
0x01, 0x26, 0x5c, 0x4c, 0xfa, 0x8b, 0x4c, 0x28, 0x81, 0xdb, 0x5f, 0x98, 0x8a, 0xf9, 0xbd, 0xe7,
0xc8, 0x59, 0x9c, 0xd1, 0xa4, 0xf0, 0x06, 0x1c, 0x8e, 0x46, 0x54, 0xbd, 0xe3, 0x62, 0x42, 0xe8,
0xb7, 0x25, 0x95, 0x0a, 0x0f, 0x00, 0x32, 0xba, 0x10, 0x92, 0x29, 0x91, 0xdd, 0xbb, 0xc8, 0x47,
0xa1, 0x3d, 0xc0, 0xfd, 0x22, 0xb9, 0x4f, 0xea, 0x08, 0x31, 0x6e, 0xe1, 0x63, 0xb0, 0x04, 0x4b,
0xdc, 0x03, 0x1f, 0x85, 0x3d, 0x92, 0x9b, 0xf8, 0x19, 0xb4, 0x38, 0x9b, 0x33, 0xe5, 0x5a, 0x3e,
0x0a, 0x2d, 0x52, 0x1c, 0x82, 0x1b, 0x78, 0x52, 0x57, 0x93, 0x0b, 0x91, 0x4a, 0x8a, 0x31, 0x1c,
0x4a, 0xf6, 0x83, 0xea, 0x42, 0x16, 0xd1, 0x76, 0xee, 0x4b, 0x62, 0x15, 0x6b, 0x3c, 0x87, 0x68,
0xbb, 0x2a, 0x61, 0xd5, 0x25, 0x82, 0x3f, 0xa8, 0x46, 0x93, 0x4d, 0xc8, 0xdf, 0xc0, 0x51, 0x46,
0xef, 0x98, 0x64, 0x22, 0x8d, 0x16, 0xb1, 0x9a, 0x49, 0xf7, 0xc0, 0xb7, 0x42, 0x7b, 0xf0, 0xaa,
0xca, 0xdb, 0x28, 0xd2, 0x27, 0xe5, 0xed, 0xdb, 0x58, 0xcd, 0xc8, 0xe3, 0xcc, 0x38, 0xc9, 0xdd,
0x7d, 0x7b, 0x97, 0xe0, 0x98, 0x49, 0xd8, 0x83, 0x6e, 0x95, 0xa6, 0x49, 0xf6, 0x48, 0x7d, 0xce,
0x9b, 0xcf, 0x59, 0x54, 0xcd, 0xe7, 0x76, 0xf0, 0x0b, 0xc1, 0xf1, 0x8a, 0x45, 0xd3, 0xc9, 0xe1,
0x0b, 0x70, 0x98, 0x8c, 0xe4, 0x72, 0x32, 0x17, 0xc9, 0x92, 0x53, 0xf7, 0xd0, 0x47, 0x61, 0x97,
0xd8, 0x4c, 0x8e, 0x2b, 0x57, 0x0e, 0x34, 0x17, 0x09, 0x75, 0x5b, 0x3e, 0x0a, 0x5b, 0x44, 0xdb,
0x6b, 0xac, 0xdb, 0x7b, 0x58, 0x77, 0x0c, 0xd6, 0x57, 0x00, 0xef, 0xaf, 0xc6, 0xb7, 0x82, 0xa5,
0x8a, 0x66, 0x0d, 0x84, 0x9e, 0xc2, 0xf3, 0x11, 0x55, 0x2b, 0xa8, 0x46, 0x6a, 0x9f, 0x41, 0x37,
0x7f, 0x14, 0x11, 0x4b, 0x0a, 0x9d, 0x7b, 0xa4, 0x93, 0x9f, 0xaf, 0x13, 0x19, 0x7c, 0x84, 0x93,
0xcd, 0x3a, 0xe5, 0xa8, 0xdf, 0x82, 0xc3, 0xa7, 0x32, 0x5a, 0x94, 0x7e, 0x17, 0xe9, 0x05, 0xa9,
0x4b, 0xad, 0x52, 0x88, 0xcd, 0xa7, 0xb2, 0x4a, 0x0f, 0x7e, 0x23, 0x70, 0x47, 0x54, 0x7d, 0xa0,
0xdf, 0xff, 0x13, 0x79, 0x53, 0x81, 0x62, 0x66, 0x2b, 0x05, 0xd6, 0x36, 0xaf, 0x55, 0x6e, 0x1e,
0x7e, 0x01, 0x90, 0x0a, 0x15, 0xb1, 0x34, 0x8a, 0x39, 0x2f, 0x85, 0xee, 0xa6, 0x42, 0x5d, 0xa7,
0x43, 0xce, 0xf1, 0x39, 0xd8, 0x65, 0x34, 0xa3, 0x53, 0xe9, 0xb6, 0x7c, 0x2b, 0x74, 0x48, 0x4f,
0x87, 0x09, 0x9d, 0xca, 0x80, 0xc0, 0xd9, 0x0e, 0xfe, 0xcd, 0x86, 0xf2, 0x55, 0xcf, 0x64, 0xc8,
0xf9, 0xc3, 0xcf, 0xa4, 0xe4, 0xbf, 0x59, 0xab, 0x11, 0xff, 0xc1, 0x4f, 0x0b, 0xec, 0xfc, 0x21,
0x8e, 0x69, 0x76, 0xc7, 0x3e, 0x53, 0x7c, 0x09, 0x9d, 0xf2, 0x69, 0xe2, 0x93, 0x8d, 0x2f, 0x46,
0xd9, 0x96, 0x77, 0xba, 0xe5, 0x2f, 0x28, 0x04, 0x8f, 0x5e, 0x23, 0x3c, 0x84, 0x6e, 0xf5, 0xb4,
0xf1, 0xe9, 0x9e, 0x4f, 0x8e, 0xe7, 0x6e, 0x07, 0x0c, 0x88, 0xb1, 0xfe, 0x88, 0x1b, 0x3d, 0xe2,
0x97, 0xc6, 0xfd, 0xed, 0x39, 0x7b, 0xe7, 0xfb, 0xc2, 0x06, 0xe8, 0x27, 0x78, 0xba, 0xa5, 0x3d,
0xf6, 0x8d, 0xc4, 0x9d, 0x6b, 0xed, 0x5d, 0xfc, 0xe3, 0xc6, 0x16, 0xfa, 0xba, 0x32, 0x6b, 0xe8,
0x3b, 0x17, 0x64, 0x0d, 0x7d, 0xb7, 0xac, 0x39, 0xfa, 0xa4, 0xad, 0x7f, 0x6e, 0x6f, 0xfe, 0x06,
0x00, 0x00, 0xff, 0xff, 0x7a, 0x21, 0xd1, 0xac, 0x00, 0x07, 0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go
View file @ 27bdba30
......@@ -350,6 +350,8 @@ type CountCommitsRequest struct {
Before *google_protobuf.Timestamp `protobuf:"bytes,4,opt,name=before" json:"before,omitempty"`
Path []byte `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
MaxCount int32 `protobuf:"varint,6,opt,name=max_count,json=maxCount" json:"max_count,omitempty"`
// all and revision are mutually exclusive
All bool `protobuf:"varint,7,opt,name=all" json:"all,omitempty"`
}
func (m *CountCommitsRequest) Reset() { *m = CountCommitsRequest{} }
......@@ -399,6 +401,13 @@ func (m *CountCommitsRequest) GetMaxCount() int32 {
return 0
}
func (m *CountCommitsRequest) GetAll() bool {
if m != nil {
return m.All
}
return false
}
type CountCommitsResponse struct {
Count int32 `protobuf:"varint,1,opt,name=count" json:"count,omitempty"`
}
......@@ -489,6 +498,7 @@ type GetTreeEntriesRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
Recursive bool `protobuf:"varint,4,opt,name=recursive" json:"recursive,omitempty"`
}
func (m *GetTreeEntriesRequest) Reset() { *m = GetTreeEntriesRequest{} }
......@@ -517,6 +527,13 @@ func (m *GetTreeEntriesRequest) GetPath() []byte {
return nil
}
func (m *GetTreeEntriesRequest) GetRecursive() bool {
if m != nil {
return m.Recursive
}
return false
}
type GetTreeEntriesResponse struct {
Entries []*TreeEntry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
}
......@@ -733,6 +750,8 @@ type FindCommitsRequest struct {
DisableWalk bool `protobuf:"varint,8,opt,name=disable_walk,json=disableWalk" json:"disable_walk,omitempty"`
After *google_protobuf.Timestamp `protobuf:"bytes,9,opt,name=after" json:"after,omitempty"`
Before *google_protobuf.Timestamp `protobuf:"bytes,10,opt,name=before" json:"before,omitempty"`
// all and revision are mutually exclusive
All bool `protobuf:"varint,11,opt,name=all" json:"all,omitempty"`
}
func (m *FindCommitsRequest) Reset() { *m = FindCommitsRequest{} }
......@@ -810,6 +829,13 @@ func (m *FindCommitsRequest) GetBefore() *google_protobuf.Timestamp {
return nil
}
func (m *FindCommitsRequest) GetAll() bool {
if m != nil {
return m.All
}
return false
}
// A single 'page' of the result set
type FindCommitsResponse struct {
Commits []*GitCommit `protobuf:"bytes,1,rep,name=commits" json:"commits,omitempty"`
......@@ -1165,6 +1191,64 @@ func (m *ExtractCommitSignatureResponse) GetSignedText() []byte {
return nil
}
type GetCommitSignaturesRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
CommitIds []string `protobuf:"bytes,2,rep,name=commit_ids,json=commitIds" json:"commit_ids,omitempty"`
}
func (m *GetCommitSignaturesRequest) Reset() { *m = GetCommitSignaturesRequest{} }
func (m *GetCommitSignaturesRequest) String() string { return proto.CompactTextString(m) }
func (*GetCommitSignaturesRequest) ProtoMessage() {}
func (*GetCommitSignaturesRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{35} }
func (m *GetCommitSignaturesRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *GetCommitSignaturesRequest) GetCommitIds() []string {
if m != nil {
return m.CommitIds
}
return nil
}
type GetCommitSignaturesResponse struct {
// Only present for a new commit signature data.
CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
// See ExtractCommitSignatureResponse above for how these fields should be handled.
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
SignedText []byte `protobuf:"bytes,3,opt,name=signed_text,json=signedText,proto3" json:"signed_text,omitempty"`
}
func (m *GetCommitSignaturesResponse) Reset() { *m = GetCommitSignaturesResponse{} }
func (m *GetCommitSignaturesResponse) String() string { return proto.CompactTextString(m) }
func (*GetCommitSignaturesResponse) ProtoMessage() {}
func (*GetCommitSignaturesResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{36} }
func (m *GetCommitSignaturesResponse) GetCommitId() string {
if m != nil {
return m.CommitId
}
return ""
}
func (m *GetCommitSignaturesResponse) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
func (m *GetCommitSignaturesResponse) GetSignedText() []byte {
if m != nil {
return m.SignedText
}
return nil
}
func init() {
proto.RegisterType((*CommitStatsRequest)(nil), "gitaly.CommitStatsRequest")
proto.RegisterType((*CommitStatsResponse)(nil), "gitaly.CommitStatsResponse")
......@@ -1202,6 +1286,8 @@ func init() {
proto.RegisterType((*FilterShasWithSignaturesResponse)(nil), "gitaly.FilterShasWithSignaturesResponse")
proto.RegisterType((*ExtractCommitSignatureRequest)(nil), "gitaly.ExtractCommitSignatureRequest")
proto.RegisterType((*ExtractCommitSignatureResponse)(nil), "gitaly.ExtractCommitSignatureResponse")
proto.RegisterType((*GetCommitSignaturesRequest)(nil), "gitaly.GetCommitSignaturesRequest")
proto.RegisterType((*GetCommitSignaturesResponse)(nil), "gitaly.GetCommitSignaturesResponse")
proto.RegisterEnum("gitaly.TreeEntryResponse_ObjectType", TreeEntryResponse_ObjectType_name, TreeEntryResponse_ObjectType_value)
proto.RegisterEnum("gitaly.TreeEntry_EntryType", TreeEntry_EntryType_name, TreeEntry_EntryType_value)
proto.RegisterEnum("gitaly.FindAllCommitsRequest_Order", FindAllCommitsRequest_Order_name, FindAllCommitsRequest_Order_value)
......@@ -1239,6 +1325,7 @@ type CommitServiceClient interface {
// arbitrarily large and signature verification is impossible without the
// full text.
ExtractCommitSignature(ctx context.Context, in *ExtractCommitSignatureRequest, opts ...grpc.CallOption) (CommitService_ExtractCommitSignatureClient, error)
GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error)
}
type commitServiceClient struct {
......@@ -1654,6 +1741,38 @@ func (x *commitServiceExtractCommitSignatureClient) Recv() (*ExtractCommitSignat
return m, nil
}
func (c *commitServiceClient) GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error) {
stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[11], c.cc, "/gitaly.CommitService/GetCommitSignatures", opts...)
if err != nil {
return nil, err
}
x := &commitServiceGetCommitSignaturesClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type CommitService_GetCommitSignaturesClient interface {
Recv() (*GetCommitSignaturesResponse, error)
grpc.ClientStream
}
type commitServiceGetCommitSignaturesClient struct {
grpc.ClientStream
}
func (x *commitServiceGetCommitSignaturesClient) Recv() (*GetCommitSignaturesResponse, error) {
m := new(GetCommitSignaturesResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for CommitService service
type CommitServiceServer interface {
......@@ -1678,6 +1797,7 @@ type CommitServiceServer interface {
// arbitrarily large and signature verification is impossible without the
// full text.
ExtractCommitSignature(*ExtractCommitSignatureRequest, CommitService_ExtractCommitSignatureServer) error
GetCommitSignatures(*GetCommitSignaturesRequest, CommitService_GetCommitSignaturesServer) error
}
func RegisterCommitServiceServer(s *grpc.Server, srv CommitServiceServer) {
......@@ -2028,6 +2148,27 @@ func (x *commitServiceExtractCommitSignatureServer) Send(m *ExtractCommitSignatu
return x.ServerStream.SendMsg(m)
}
func _CommitService_GetCommitSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetCommitSignaturesRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(CommitServiceServer).GetCommitSignatures(m, &commitServiceGetCommitSignaturesServer{stream})
}
type CommitService_GetCommitSignaturesServer interface {
Send(*GetCommitSignaturesResponse) error
grpc.ServerStream
}
type commitServiceGetCommitSignaturesServer struct {
grpc.ServerStream
}
func (x *commitServiceGetCommitSignaturesServer) Send(m *GetCommitSignaturesResponse) error {
return x.ServerStream.SendMsg(m)
}
var _CommitService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.CommitService",
HandlerType: (*CommitServiceServer)(nil),
......@@ -2114,6 +2255,11 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
Handler: _CommitService_ExtractCommitSignature_Handler,
ServerStreams: true,
},
{
StreamName: "GetCommitSignatures",
Handler: _CommitService_GetCommitSignatures_Handler,
ServerStreams: true,
},
},
Metadata: "commit.proto",
}
......@@ -2121,103 +2267,109 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("commit.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 1559 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0x1a, 0x47,
0x14, 0xf6, 0x82, 0xc1, 0x70, 0xa0, 0x0e, 0x9e, 0xfc, 0xe1, 0x75, 0x12, 0x3b, 0xdb, 0x26, 0x25,
0x4a, 0x45, 0x2c, 0xaa, 0x56, 0xed, 0x55, 0x65, 0x27, 0xd8, 0x75, 0x6a, 0x87, 0x68, 0x8d, 0x14,
0xa5, 0x37, 0x68, 0xcc, 0x0e, 0x30, 0xf5, 0xc2, 0x92, 0xdd, 0x21, 0x36, 0xad, 0xd4, 0xfb, 0x4a,
0x7d, 0x92, 0x4a, 0x7d, 0x88, 0xbe, 0x42, 0x1f, 0xa3, 0x8f, 0x10, 0xf5, 0xa2, 0x9a, 0x9f, 0xdd,
0x59, 0x60, 0x71, 0x1a, 0x5b, 0xe4, 0x06, 0xed, 0x9c, 0x99, 0x39, 0xe7, 0x3b, 0x67, 0xce, 0x2f,
0x50, 0x6c, 0x7b, 0xfd, 0x3e, 0x65, 0xd5, 0xa1, 0xef, 0x31, 0x0f, 0x65, 0xbb, 0x94, 0x61, 0x77,
0x6c, 0x16, 0x83, 0x1e, 0xf6, 0x89, 0x23, 0xa9, 0xe6, 0x66, 0xd7, 0xf3, 0xba, 0x2e, 0x79, 0x22,
0x56, 0x27, 0xa3, 0xce, 0x13, 0x46, 0xfb, 0x24, 0x60, 0xb8, 0x3f, 0x94, 0x07, 0x2c, 0x07, 0xd0,
0x53, 0xc1, 0xe6, 0x98, 0x61, 0x16, 0xd8, 0xe4, 0xcd, 0x88, 0x04, 0x0c, 0xd5, 0x00, 0x7c, 0x32,
0xf4, 0x02, 0xca, 0x3c, 0x7f, 0x5c, 0x36, 0xb6, 0x8c, 0x4a, 0xa1, 0x86, 0xaa, 0x52, 0x42, 0xd5,
0x8e, 0x76, 0xec, 0xd8, 0x29, 0x64, 0x42, 0xce, 0x27, 0x6f, 0x69, 0x40, 0xbd, 0x41, 0x39, 0xb5,
0x65, 0x54, 0x8a, 0x76, 0xb4, 0xb6, 0xda, 0x70, 0x7d, 0x42, 0x4a, 0x30, 0xf4, 0x06, 0x01, 0x41,
0x25, 0x48, 0x7b, 0xd4, 0x11, 0xfc, 0xf3, 0x36, 0xff, 0x44, 0x77, 0x20, 0x8f, 0x1d, 0x87, 0x32,
0xea, 0x0d, 0x02, 0xc1, 0x25, 0x63, 0x6b, 0x02, 0xdf, 0x75, 0x88, 0x4b, 0xe4, 0x6e, 0x5a, 0xee,
0x46, 0x04, 0xeb, 0x37, 0x03, 0x6e, 0x4b, 0x29, 0x07, 0xc1, 0xce, 0xa0, 0x4d, 0x02, 0xe6, 0xf9,
0x57, 0x51, 0x68, 0x13, 0x0a, 0x58, 0xb1, 0x69, 0x51, 0x47, 0xa0, 0xc9, 0xdb, 0x10, 0x92, 0x0e,
0x1c, 0xb4, 0x0e, 0xb9, 0x76, 0x8f, 0xba, 0x0e, 0xdf, 0x4d, 0x8b, 0xdd, 0x15, 0xb1, 0x3e, 0x70,
0xac, 0x6d, 0x28, 0xcf, 0x42, 0x51, 0x5a, 0xdf, 0x80, 0xcc, 0x5b, 0xec, 0x8e, 0x88, 0x80, 0x91,
0xb3, 0xe5, 0xc2, 0xfa, 0xdd, 0x80, 0x52, 0xd3, 0x27, 0xa4, 0x3e, 0x60, 0xfe, 0x78, 0x41, 0xef,
0x80, 0x10, 0x2c, 0x0f, 0x31, 0xeb, 0x09, 0xb4, 0x45, 0x5b, 0x7c, 0x73, 0x38, 0x2e, 0xed, 0x53,
0x56, 0x5e, 0xde, 0x32, 0x2a, 0x69, 0x5b, 0x2e, 0xac, 0xbf, 0x0d, 0x58, 0x8b, 0xc1, 0x51, 0xd0,
0xbf, 0x81, 0x65, 0x36, 0x1e, 0x4a, 0xe4, 0xab, 0xb5, 0xcf, 0x42, 0x24, 0x33, 0x07, 0xab, 0x8d,
0x93, 0x9f, 0x48, 0x9b, 0x35, 0xc7, 0x43, 0x62, 0x8b, 0x1b, 0xe1, 0x53, 0xa7, 0xf4, 0x53, 0x23,
0x58, 0x0e, 0xe8, 0xcf, 0x44, 0x60, 0x49, 0xdb, 0xe2, 0x9b, 0xd3, 0xfa, 0x9e, 0x43, 0x04, 0x94,
0x8c, 0x2d, 0xbe, 0x39, 0xcd, 0xc1, 0x0c, 0x97, 0x33, 0x12, 0x33, 0xff, 0xb6, 0xbe, 0x02, 0xd0,
0x12, 0x10, 0x40, 0xf6, 0x69, 0xe3, 0xe8, 0xe8, 0xa0, 0x59, 0x5a, 0x42, 0x39, 0x58, 0xde, 0x3d,
0x6c, 0xec, 0x96, 0x0c, 0xfe, 0xd5, 0xb4, 0xeb, 0xf5, 0x52, 0x0a, 0xad, 0x40, 0xba, 0xb9, 0xb3,
0x5f, 0x4a, 0x5b, 0x1e, 0xdc, 0x94, 0xaf, 0x12, 0xec, 0x12, 0x76, 0x46, 0xc8, 0xe0, 0x2a, 0x76,
0x46, 0xb0, 0xdc, 0xf1, 0xbd, 0xbe, 0xb2, 0xb1, 0xf8, 0x46, 0xab, 0x90, 0x62, 0x9e, 0xb2, 0x6e,
0x8a, 0x79, 0x56, 0x1d, 0x6e, 0x4d, 0x0b, 0x54, 0x96, 0x7c, 0x0c, 0x2b, 0x32, 0x7c, 0x83, 0xb2,
0xb1, 0x95, 0xae, 0x14, 0x6a, 0x6b, 0xa1, 0xb8, 0x7d, 0xca, 0xe4, 0x1d, 0x3b, 0x3c, 0x61, 0xfd,
0x6b, 0xf0, 0xf8, 0x19, 0x0d, 0xd4, 0xc6, 0xa2, 0xc2, 0x14, 0x6d, 0x43, 0x06, 0x77, 0x18, 0xf1,
0x85, 0x06, 0x85, 0x9a, 0x59, 0x95, 0xd9, 0xa3, 0x1a, 0x66, 0x8f, 0x6a, 0x33, 0xcc, 0x1e, 0xb6,
0x3c, 0x88, 0x6a, 0x90, 0x3d, 0x21, 0x1d, 0xcf, 0x97, 0x4f, 0x76, 0xf1, 0x15, 0x75, 0x32, 0x72,
0xc2, 0x4c, 0xcc, 0x09, 0x37, 0x20, 0xdf, 0xc7, 0xe7, 0xad, 0x36, 0x57, 0xb2, 0x9c, 0x15, 0xaf,
0x9f, 0xeb, 0xe3, 0x73, 0xa1, 0xb4, 0xf5, 0x05, 0xdc, 0x98, 0xd4, 0x5e, 0x07, 0x92, 0xbc, 0x60,
0x88, 0x0b, 0x72, 0x61, 0xbd, 0x33, 0x20, 0x1f, 0x39, 0x64, 0x42, 0x8a, 0x59, 0x87, 0x9c, 0xef,
0x79, 0xac, 0xa5, 0xdd, 0x71, 0x85, 0xaf, 0x1b, 0xd2, 0x25, 0x67, 0xc2, 0xe3, 0x89, 0x72, 0xf9,
0x65, 0xe1, 0xf2, 0x1b, 0x33, 0x2e, 0x5f, 0x15, 0xbf, 0x31, 0x4f, 0x0f, 0x7d, 0x38, 0x13, 0xf3,
0xe1, 0xbb, 0x00, 0xf2, 0x2d, 0x85, 0xd4, 0xac, 0x90, 0x9a, 0x97, 0x14, 0x2e, 0x77, 0x03, 0xf2,
0x1d, 0x17, 0xb3, 0x96, 0x10, 0xbe, 0x22, 0x1f, 0x85, 0x13, 0x5e, 0x62, 0xd6, 0xb3, 0x1e, 0x43,
0x3e, 0x12, 0x11, 0xb9, 0xf7, 0x52, 0xe4, 0xde, 0x46, 0xcc, 0xfd, 0xd3, 0xd6, 0x2f, 0x70, 0x73,
0x9f, 0xb0, 0x10, 0x1c, 0x25, 0xc1, 0x47, 0xcc, 0x24, 0xdc, 0xdb, 0xa7, 0x85, 0x6b, 0x6f, 0x27,
0x92, 0x34, 0xed, 0xed, 0x3a, 0x75, 0x84, 0x27, 0xac, 0x13, 0x28, 0x1d, 0xd2, 0x80, 0xed, 0x51,
0x77, 0x61, 0xf0, 0xad, 0x47, 0xb0, 0x16, 0x93, 0xa1, 0xfd, 0x89, 0xeb, 0x21, 0x31, 0x16, 0x6d,
0xb9, 0xb0, 0xda, 0xb0, 0xb6, 0x47, 0x07, 0x8e, 0x8a, 0xc9, 0x05, 0xe1, 0xf9, 0x0e, 0x50, 0x5c,
0x88, 0x02, 0xf4, 0x08, 0xb2, 0xd2, 0x49, 0x94, 0x84, 0x84, 0x1c, 0xa1, 0x0e, 0x58, 0x2d, 0xb8,
0xcd, 0x15, 0x0a, 0xb3, 0xcd, 0xb8, 0x41, 0x9d, 0xab, 0x60, 0x8d, 0xd2, 0x75, 0x5a, 0x85, 0x8d,
0xb5, 0x0f, 0xe5, 0x59, 0x01, 0x97, 0x49, 0x66, 0xef, 0x0c, 0xb8, 0xc9, 0x75, 0xdd, 0x71, 0xdd,
0x05, 0xa7, 0xb3, 0x89, 0xa4, 0x92, 0x9e, 0x4c, 0x2a, 0xa2, 0xfc, 0x9c, 0xd2, 0x61, 0x58, 0x6a,
0xf8, 0x37, 0xfa, 0x16, 0x32, 0x9e, 0xef, 0x10, 0x5f, 0xc4, 0xee, 0x6a, 0xed, 0xd3, 0x50, 0x76,
0x22, 0xdc, 0x6a, 0x83, 0x1f, 0xb5, 0xe5, 0x0d, 0xeb, 0x01, 0x64, 0xc4, 0x9a, 0xc7, 0xe5, 0x8b,
0xc6, 0x8b, 0xba, 0x8a, 0xd0, 0xc6, 0xcb, 0x86, 0x2c, 0x45, 0xcf, 0x76, 0x9a, 0xf5, 0x52, 0x8a,
0x87, 0xc8, 0x34, 0xb3, 0xcb, 0xd8, 0xf0, 0x9f, 0x54, 0xdc, 0x5f, 0x16, 0x66, 0xc0, 0xa8, 0x35,
0x90, 0xc6, 0x93, 0x0b, 0x74, 0x0b, 0xb2, 0x5e, 0xa7, 0x13, 0x10, 0xa6, 0x6c, 0xa7, 0x56, 0x3a,
0x7c, 0x32, 0xb1, 0xf0, 0xe1, 0xa7, 0x3b, 0x9e, 0xeb, 0x7a, 0x67, 0x22, 0xed, 0xe5, 0x6c, 0xb5,
0xe2, 0xdd, 0x15, 0xb7, 0x79, 0xab, 0x4f, 0xfc, 0x2e, 0x09, 0x44, 0xd6, 0xcb, 0xd9, 0xc0, 0x49,
0x47, 0x82, 0x82, 0xee, 0x43, 0xd1, 0xa1, 0x01, 0x3e, 0x71, 0x49, 0xeb, 0x0c, 0xbb, 0xa7, 0xe5,
0x9c, 0x38, 0x51, 0x50, 0xb4, 0x57, 0xd8, 0x3d, 0xd5, 0xf5, 0x2a, 0xff, 0xe1, 0xf5, 0x0a, 0xfe,
0x6f, 0xbd, 0xb2, 0x76, 0xe1, 0xfa, 0x84, 0xad, 0x2f, 0xf3, 0x60, 0xbd, 0xb0, 0x11, 0x38, 0xc4,
0x83, 0xee, 0x08, 0x77, 0x17, 0x97, 0xd9, 0xfe, 0x8c, 0xba, 0xe0, 0x98, 0x28, 0x05, 0x79, 0x0f,
0xf2, 0x6e, 0x48, 0x54, 0xa0, 0x2b, 0xa1, 0xa8, 0x39, 0x77, 0xaa, 0x21, 0xc5, 0xd6, 0x57, 0xcd,
0xe7, 0x90, 0x0b, 0xc9, 0x3c, 0x8e, 0x06, 0xb8, 0x4f, 0x54, 0x85, 0x15, 0xdf, 0xdc, 0x13, 0xc4,
0x14, 0x22, 0xc0, 0xa5, 0x6c, 0xb9, 0x90, 0xe5, 0xda, 0xf5, 0x7c, 0xd5, 0x2b, 0xcb, 0x85, 0x35,
0x82, 0x6b, 0x36, 0x3e, 0xdb, 0x75, 0x71, 0x9f, 0x7c, 0xcc, 0x5a, 0xf5, 0x10, 0x4a, 0x5a, 0xac,
0x32, 0x4f, 0xd8, 0x69, 0x1a, 0xb1, 0x4e, 0xf3, 0x57, 0x28, 0x1f, 0xe2, 0x30, 0xed, 0xed, 0x79,
0x3e, 0x2f, 0xc9, 0x1f, 0x13, 0xe7, 0x1e, 0xac, 0x27, 0xc8, 0xff, 0xf0, 0xfa, 0xf0, 0x57, 0xe4,
0x16, 0xc1, 0xee, 0xf8, 0x88, 0x04, 0x01, 0x7f, 0xd2, 0x05, 0xe9, 0xa1, 0x13, 0x44, 0x7a, 0x3a,
0x41, 0xe8, 0x49, 0x23, 0x4a, 0x27, 0x49, 0xed, 0xe0, 0x0d, 0xc8, 0xbc, 0x19, 0x11, 0x7f, 0xac,
0x5a, 0x25, 0xb9, 0xe0, 0x25, 0x68, 0x56, 0x85, 0xcb, 0x44, 0x23, 0x85, 0xcd, 0x3d, 0xea, 0x32,
0xe2, 0x1f, 0xf7, 0x70, 0xf0, 0x8a, 0xb2, 0xde, 0x31, 0xed, 0x0e, 0x30, 0x1b, 0xf9, 0x57, 0x0b,
0x4b, 0x5e, 0x52, 0x7a, 0x38, 0x10, 0x55, 0xb3, 0x68, 0x8b, 0x6f, 0xeb, 0x6b, 0xd8, 0x9a, 0x2f,
0x4a, 0xfb, 0x9d, 0xb8, 0x67, 0xc4, 0xee, 0x0d, 0xe1, 0x6e, 0xfd, 0x9c, 0xf9, 0xb8, 0xad, 0xc0,
0x47, 0xd7, 0xae, 0x02, 0x70, 0x03, 0x54, 0xd3, 0xa9, 0xe7, 0xd9, 0x9c, 0x24, 0x1c, 0x38, 0x56,
0x0b, 0xee, 0xcd, 0x93, 0xa8, 0x70, 0xde, 0x81, 0x7c, 0x10, 0x12, 0x55, 0x90, 0x68, 0x82, 0x48,
0xe8, 0xb4, 0x3b, 0x20, 0x4e, 0x8b, 0x91, 0x73, 0xa6, 0x9c, 0x02, 0x24, 0xa9, 0x49, 0xce, 0x59,
0xed, 0x8f, 0x02, 0x7c, 0xa2, 0x58, 0x13, 0xff, 0x2d, 0x6d, 0x13, 0xf4, 0x0a, 0x4a, 0xd3, 0x53,
0x32, 0xda, 0x9c, 0x4c, 0x48, 0x33, 0xa3, 0xbc, 0xb9, 0x35, 0xff, 0x80, 0xc4, 0x69, 0x2d, 0xa1,
0x67, 0xf1, 0x11, 0xa0, 0x9c, 0x30, 0xa6, 0x4a, 0x56, 0xeb, 0x73, 0x07, 0x58, 0x6b, 0x69, 0xdb,
0x40, 0xc7, 0xb0, 0x3a, 0x39, 0xbd, 0xa1, 0xbb, 0x93, 0xb2, 0xa7, 0xc6, 0x48, 0xf3, 0xde, 0xbc,
0xed, 0x18, 0xd3, 0x1f, 0xa0, 0x18, 0x1f, 0x66, 0xd0, 0x86, 0xbe, 0x33, 0x33, 0xe0, 0x99, 0x77,
0x92, 0x37, 0x23, 0x3d, 0x8f, 0x61, 0x75, 0xb2, 0xe3, 0xd6, 0x08, 0x13, 0xc7, 0x00, 0x8d, 0x30,
0xb9, 0x51, 0x17, 0x08, 0x9f, 0x41, 0x3e, 0xea, 0x8d, 0xb5, 0xf1, 0xa6, 0x5b, 0x72, 0x6d, 0xbc,
0x99, 0x46, 0x5a, 0x70, 0xa9, 0x03, 0xe8, 0xaa, 0x89, 0xd6, 0xe3, 0xad, 0xd4, 0x44, 0x2b, 0x6d,
0x9a, 0x49, 0x5b, 0x91, 0x86, 0xdf, 0x43, 0x21, 0xf6, 0xcf, 0x11, 0x32, 0x27, 0x2d, 0x1c, 0xff,
0xd3, 0xca, 0xdc, 0x48, 0xdc, 0x8b, 0xdb, 0x6a, 0xb2, 0xf5, 0xd2, 0xb6, 0x4a, 0xec, 0xef, 0xb4,
0xad, 0x92, 0x3b, 0x36, 0xa1, 0xe5, 0x73, 0x28, 0xc4, 0x7a, 0x03, 0x94, 0xa0, 0xcb, 0x2c, 0xbc,
0x84, 0x66, 0x42, 0xf0, 0x6a, 0xc2, 0xb5, 0xa9, 0x22, 0x8c, 0xee, 0xcd, 0xad, 0xce, 0x92, 0xe7,
0xe6, 0x7b, 0xaa, 0xb7, 0xb5, 0x84, 0x76, 0x20, 0x17, 0x16, 0x3a, 0x74, 0x3b, 0xca, 0x0f, 0x93,
0x15, 0xd7, 0x2c, 0xcf, 0x6e, 0xc4, 0x80, 0xfd, 0x08, 0x6b, 0x33, 0x35, 0x08, 0x45, 0x61, 0x38,
0xaf, 0x3c, 0x9a, 0xf7, 0x2f, 0x38, 0x11, 0xc1, 0x7b, 0x1d, 0xa6, 0x00, 0x9d, 0xd3, 0xa7, 0x53,
0xc0, 0x4c, 0xc1, 0x9a, 0x4e, 0x01, 0xb3, 0xe5, 0x40, 0xc0, 0x7e, 0x2d, 0xe7, 0xc8, 0xf8, 0xc4,
0xa2, 0x59, 0xcf, 0x19, 0x96, 0x34, 0xeb, 0x79, 0xc3, 0x8e, 0x60, 0x1d, 0x40, 0x79, 0x5e, 0x56,
0x47, 0x9f, 0xeb, 0x77, 0xbe, 0xb0, 0xc4, 0x98, 0x95, 0xf7, 0x1f, 0x0c, 0x45, 0x56, 0x8c, 0x6d,
0x03, 0x9d, 0xc2, 0xad, 0xe4, 0x04, 0x8d, 0x1e, 0x84, 0x9c, 0x2e, 0x2c, 0x19, 0xe6, 0xc3, 0xf7,
0x1d, 0xd3, 0x1a, 0x9e, 0x64, 0x45, 0x43, 0xfc, 0xe5, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc0,
0x6e, 0x68, 0x46, 0x65, 0x16, 0x00, 0x00,
// 1650 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5f, 0x6f, 0x1a, 0xc7,
0x16, 0xf7, 0x82, 0xc1, 0x70, 0xe0, 0x3a, 0x78, 0xf2, 0x0f, 0xaf, 0x9d, 0xd8, 0x99, 0xdc, 0xe4,
0x3a, 0xca, 0x15, 0xb1, 0xb8, 0xba, 0x55, 0xfb, 0x54, 0xd9, 0x09, 0x76, 0x9d, 0xda, 0x21, 0x5a,
0x23, 0x45, 0xe9, 0x0b, 0x5a, 0xb3, 0x03, 0x4c, 0xbd, 0xb0, 0x64, 0x77, 0xb0, 0x4d, 0x1f, 0xfa,
0x5e, 0xa9, 0xca, 0x7b, 0x3f, 0x44, 0x3f, 0x44, 0xbf, 0x42, 0x3f, 0x4e, 0xd4, 0x87, 0x6a, 0xfe,
0xec, 0xce, 0x02, 0x8b, 0xdd, 0xd8, 0x22, 0x2f, 0x68, 0xe6, 0xcc, 0xec, 0x39, 0xbf, 0x73, 0xe6,
0xfc, 0x05, 0x8a, 0x2d, 0xaf, 0xd7, 0xa3, 0xac, 0x32, 0xf0, 0x3d, 0xe6, 0xa1, 0x6c, 0x87, 0x32,
0xdb, 0x1d, 0x99, 0xc5, 0xa0, 0x6b, 0xfb, 0xc4, 0x91, 0x54, 0x73, 0xa3, 0xe3, 0x79, 0x1d, 0x97,
0xbc, 0x10, 0xbb, 0x93, 0x61, 0xfb, 0x05, 0xa3, 0x3d, 0x12, 0x30, 0xbb, 0x37, 0x90, 0x17, 0xb0,
0x03, 0xe8, 0xa5, 0x60, 0x73, 0xcc, 0x6c, 0x16, 0x58, 0xe4, 0xc3, 0x90, 0x04, 0x0c, 0x55, 0x01,
0x7c, 0x32, 0xf0, 0x02, 0xca, 0x3c, 0x7f, 0x54, 0x36, 0x36, 0x8d, 0xad, 0x42, 0x15, 0x55, 0xa4,
0x84, 0x8a, 0x15, 0x9d, 0x58, 0xb1, 0x5b, 0xc8, 0x84, 0x9c, 0x4f, 0xce, 0x68, 0x40, 0xbd, 0x7e,
0x39, 0xb5, 0x69, 0x6c, 0x15, 0xad, 0x68, 0x8f, 0x5b, 0x70, 0x7b, 0x4c, 0x4a, 0x30, 0xf0, 0xfa,
0x01, 0x41, 0x25, 0x48, 0x7b, 0xd4, 0x11, 0xfc, 0xf3, 0x16, 0x5f, 0xa2, 0x75, 0xc8, 0xdb, 0x8e,
0x43, 0x19, 0xf5, 0xfa, 0x81, 0xe0, 0x92, 0xb1, 0x34, 0x81, 0x9f, 0x3a, 0xc4, 0x25, 0xf2, 0x34,
0x2d, 0x4f, 0x23, 0x02, 0xfe, 0xc5, 0x80, 0xfb, 0x52, 0xca, 0x41, 0xb0, 0xd3, 0x6f, 0x91, 0x80,
0x79, 0xfe, 0x4d, 0x14, 0xda, 0x80, 0x82, 0xad, 0xd8, 0x34, 0xa9, 0x23, 0xd0, 0xe4, 0x2d, 0x08,
0x49, 0x07, 0x0e, 0x5a, 0x85, 0x5c, 0xab, 0x4b, 0x5d, 0x87, 0x9f, 0xa6, 0xc5, 0xe9, 0x92, 0xd8,
0x1f, 0x38, 0x78, 0x1b, 0xca, 0xd3, 0x50, 0x94, 0xd6, 0x77, 0x20, 0x73, 0x66, 0xbb, 0x43, 0x22,
0x60, 0xe4, 0x2c, 0xb9, 0xc1, 0xbf, 0x1a, 0x50, 0x6a, 0xf8, 0x84, 0xd4, 0xfa, 0xcc, 0x1f, 0xcd,
0xe9, 0x1d, 0x10, 0x82, 0xc5, 0x81, 0xcd, 0xba, 0x02, 0x6d, 0xd1, 0x12, 0x6b, 0x0e, 0xc7, 0xa5,
0x3d, 0xca, 0xca, 0x8b, 0x9b, 0xc6, 0x56, 0xda, 0x92, 0x1b, 0xfc, 0xa7, 0x01, 0x2b, 0x31, 0x38,
0x0a, 0xfa, 0xd7, 0xb0, 0xc8, 0x46, 0x03, 0x89, 0x7c, 0xb9, 0xfa, 0xef, 0x10, 0xc9, 0xd4, 0xc5,
0x4a, 0xfd, 0xe4, 0x47, 0xd2, 0x62, 0x8d, 0xd1, 0x80, 0x58, 0xe2, 0x8b, 0xf0, 0xa9, 0x53, 0xfa,
0xa9, 0x11, 0x2c, 0x06, 0xf4, 0x27, 0x22, 0xb0, 0xa4, 0x2d, 0xb1, 0xe6, 0xb4, 0x9e, 0xe7, 0x10,
0x01, 0x25, 0x63, 0x89, 0x35, 0xa7, 0x39, 0x36, 0xb3, 0xcb, 0x19, 0x89, 0x99, 0xaf, 0xf1, 0xff,
0x01, 0xb4, 0x04, 0x04, 0x90, 0x7d, 0x59, 0x3f, 0x3a, 0x3a, 0x68, 0x94, 0x16, 0x50, 0x0e, 0x16,
0x77, 0x0f, 0xeb, 0xbb, 0x25, 0x83, 0xaf, 0x1a, 0x56, 0xad, 0x56, 0x4a, 0xa1, 0x25, 0x48, 0x37,
0x76, 0xf6, 0x4b, 0x69, 0xec, 0xc1, 0x5d, 0xf9, 0x2a, 0xc1, 0x2e, 0x61, 0xe7, 0x84, 0xf4, 0x6f,
0x62, 0x67, 0x04, 0x8b, 0x6d, 0xdf, 0xeb, 0x29, 0x1b, 0x8b, 0x35, 0x5a, 0x86, 0x14, 0xf3, 0x94,
0x75, 0x53, 0xcc, 0xc3, 0x35, 0xb8, 0x37, 0x29, 0x50, 0x59, 0xf2, 0x39, 0x2c, 0xc9, 0xf0, 0x0d,
0xca, 0xc6, 0x66, 0x7a, 0xab, 0x50, 0x5d, 0x09, 0xc5, 0xed, 0x53, 0x26, 0xbf, 0xb1, 0xc2, 0x1b,
0xf8, 0x63, 0x8a, 0xc7, 0xcf, 0xb0, 0xaf, 0x0e, 0xe6, 0x15, 0xa6, 0x68, 0x1b, 0x32, 0x76, 0x9b,
0x11, 0x5f, 0x68, 0x50, 0xa8, 0x9a, 0x15, 0x99, 0x3d, 0x2a, 0x61, 0xf6, 0xa8, 0x34, 0xc2, 0xec,
0x61, 0xc9, 0x8b, 0xa8, 0x0a, 0xd9, 0x13, 0xd2, 0xf6, 0x7c, 0xf9, 0x64, 0x97, 0x7f, 0xa2, 0x6e,
0x46, 0x4e, 0x98, 0x89, 0x39, 0xe1, 0x1a, 0xe4, 0x7b, 0xf6, 0x45, 0xb3, 0xc5, 0x95, 0x2c, 0x67,
0xc5, 0xeb, 0xe7, 0x7a, 0xf6, 0x85, 0x50, 0x9a, 0xfb, 0x8e, 0xed, 0xba, 0xe5, 0x25, 0x11, 0x2e,
0x7c, 0x89, 0xff, 0x0b, 0x77, 0xc6, 0xed, 0xa1, 0x43, 0x4b, 0xb2, 0x30, 0x04, 0x0b, 0xb9, 0xc1,
0x9f, 0x0c, 0xc8, 0x47, 0x2e, 0x9a, 0x90, 0x74, 0x56, 0x21, 0xe7, 0x7b, 0x1e, 0x6b, 0x6a, 0x07,
0x5d, 0xe2, 0xfb, 0xba, 0x74, 0xd2, 0xa9, 0x80, 0x79, 0xa1, 0x82, 0x60, 0x51, 0x04, 0xc1, 0xda,
0x54, 0x10, 0x54, 0xc4, 0x6f, 0xcc, 0xf7, 0x43, 0xaf, 0xce, 0xc4, 0xbc, 0xfa, 0x01, 0x80, 0x7c,
0x5d, 0x21, 0x35, 0x2b, 0xa4, 0xe6, 0x25, 0x85, 0xcb, 0x5d, 0x83, 0x7c, 0xdb, 0xb5, 0x59, 0x53,
0x08, 0x5f, 0x92, 0xcf, 0xc4, 0x09, 0x6f, 0x6d, 0xd6, 0xc5, 0xcf, 0x21, 0x1f, 0x89, 0x88, 0x1c,
0x7e, 0x21, 0x72, 0x78, 0x23, 0x16, 0x10, 0x69, 0xfc, 0x9b, 0x01, 0x77, 0xf7, 0x09, 0x0b, 0xd1,
0x51, 0x12, 0x7c, 0xc9, 0xe4, 0xb2, 0x0e, 0x79, 0x9f, 0xb4, 0x86, 0x7e, 0x40, 0xcf, 0xa4, 0xc1,
0x72, 0x96, 0x26, 0xf0, 0xf0, 0x98, 0x84, 0xa6, 0xc3, 0x83, 0x48, 0xd2, 0x64, 0x78, 0xe8, 0x5c,
0x13, 0xde, 0xc0, 0x27, 0x50, 0x3a, 0xa4, 0x01, 0xdb, 0xa3, 0xee, 0xdc, 0x94, 0xc3, 0xcf, 0x60,
0x25, 0x26, 0x43, 0xbb, 0x1b, 0xd7, 0x52, 0x62, 0x2c, 0x5a, 0x72, 0x83, 0x5b, 0xb0, 0xb2, 0x47,
0xfb, 0x8e, 0x0a, 0xe2, 0x39, 0xe1, 0xf9, 0x16, 0x50, 0x5c, 0x88, 0x02, 0xf4, 0x0c, 0xb2, 0xd2,
0x87, 0x94, 0x84, 0x84, 0xa4, 0xa2, 0x2e, 0xe0, 0x26, 0xdc, 0xe7, 0x0a, 0x85, 0xe9, 0x69, 0x54,
0xa7, 0xce, 0x4d, 0xb0, 0x46, 0xf9, 0x3d, 0xad, 0xa2, 0x0a, 0xef, 0x43, 0x79, 0x5a, 0xc0, 0x75,
0xb2, 0xdf, 0x27, 0x03, 0xee, 0x72, 0x5d, 0x77, 0x5c, 0x77, 0xce, 0xf9, 0x6f, 0x2c, 0x0b, 0xa5,
0x27, 0xb2, 0x10, 0xaf, 0x57, 0xa7, 0x74, 0x10, 0xd6, 0x26, 0xbe, 0x46, 0xdf, 0x40, 0xc6, 0xf3,
0x1d, 0xe2, 0x8b, 0xd0, 0x5e, 0xae, 0x3e, 0x0e, 0x65, 0x27, 0xc2, 0xad, 0xd4, 0xf9, 0x55, 0x4b,
0x7e, 0x81, 0x9f, 0x40, 0x46, 0xec, 0x79, 0xd8, 0xbe, 0xa9, 0xbf, 0xa9, 0xa9, 0x00, 0xae, 0xbf,
0xad, 0xcb, 0xda, 0xf5, 0x6a, 0xa7, 0x51, 0x2b, 0xa5, 0x78, 0x88, 0x4c, 0x32, 0xbb, 0x8e, 0x0d,
0xff, 0x4a, 0xc5, 0xfd, 0x65, 0x6e, 0x06, 0x8c, 0x7a, 0x09, 0x69, 0x3c, 0xb9, 0x41, 0xf7, 0x20,
0xeb, 0xb5, 0xdb, 0x01, 0x61, 0xca, 0x76, 0x6a, 0xa7, 0xc3, 0x27, 0x13, 0x0b, 0x1f, 0x7e, 0xbb,
0xed, 0xb9, 0xae, 0x77, 0x2e, 0xb2, 0x62, 0xce, 0x52, 0x3b, 0xde, 0x8e, 0x71, 0x9b, 0x37, 0x7b,
0xc4, 0xef, 0x90, 0x40, 0x55, 0x03, 0xe0, 0xa4, 0x23, 0x41, 0x41, 0x8f, 0xa0, 0xe8, 0xd0, 0xc0,
0x3e, 0x71, 0x49, 0xf3, 0xdc, 0x76, 0x4f, 0xcb, 0x39, 0x71, 0xa3, 0xa0, 0x68, 0xef, 0x6c, 0xf7,
0x54, 0x17, 0xb8, 0xfc, 0xe7, 0x17, 0x38, 0xf8, 0xc7, 0x05, 0x4e, 0xd5, 0xab, 0x82, 0xae, 0x57,
0xbb, 0x70, 0x7b, 0xcc, 0xfa, 0xd7, 0x79, 0xc2, 0x6e, 0xd8, 0x4b, 0x1c, 0xda, 0xfd, 0xce, 0xd0,
0xee, 0xcc, 0x2f, 0xd7, 0xfd, 0x1e, 0x35, 0xd2, 0x31, 0x51, 0x0a, 0xf2, 0x1e, 0xe4, 0xdd, 0x90,
0xa8, 0x40, 0x6f, 0x85, 0xa2, 0x66, 0x7c, 0x53, 0x09, 0x29, 0x96, 0xfe, 0xd4, 0x7c, 0x0d, 0xb9,
0x90, 0xcc, 0x23, 0xab, 0x6f, 0xf7, 0x88, 0x2a, 0xc9, 0x62, 0xcd, 0x7d, 0x43, 0x0c, 0x32, 0x02,
0x5c, 0xca, 0x92, 0x1b, 0x59, 0xdf, 0x5d, 0xcf, 0x57, 0xed, 0xb6, 0xdc, 0xe0, 0x21, 0xdc, 0xb2,
0xec, 0xf3, 0x5d, 0xd7, 0xee, 0x91, 0x2f, 0x58, 0xdb, 0xf0, 0x53, 0x28, 0x69, 0xb1, 0xca, 0x3c,
0x61, 0xb3, 0x6a, 0xc4, 0x9a, 0xd5, 0x9f, 0xa1, 0x7c, 0x68, 0x87, 0x89, 0x70, 0xcf, 0xf3, 0x79,
0x0d, 0xff, 0x92, 0x38, 0xf7, 0x60, 0x35, 0x41, 0xfe, 0xe7, 0x57, 0x8c, 0x3f, 0x22, 0xb7, 0x08,
0x76, 0x47, 0x47, 0x24, 0x08, 0xf8, 0x93, 0xce, 0x49, 0x0f, 0x9d, 0x32, 0xd2, 0x93, 0x29, 0x43,
0x0f, 0x2b, 0x51, 0x82, 0x49, 0xea, 0x28, 0xef, 0x40, 0xe6, 0xc3, 0x90, 0xf8, 0x23, 0xd5, 0x5b,
0xc9, 0x0d, 0x2f, 0x4a, 0xd3, 0x2a, 0x5c, 0x27, 0x1a, 0x29, 0x6c, 0xec, 0x51, 0x97, 0x11, 0xff,
0xb8, 0x6b, 0x07, 0xef, 0x28, 0xeb, 0x1e, 0xd3, 0x4e, 0xdf, 0x66, 0x43, 0xff, 0x66, 0x61, 0xc9,
0x8b, 0x4c, 0xd7, 0x0e, 0x44, 0x1d, 0x2d, 0x5a, 0x62, 0x8d, 0xbf, 0x82, 0xcd, 0xd9, 0xa2, 0xb4,
0xdf, 0x89, 0xef, 0x8c, 0xd8, 0x77, 0x03, 0x78, 0x50, 0xbb, 0x60, 0xbe, 0xdd, 0x52, 0xe0, 0xa3,
0xcf, 0x6e, 0x02, 0x70, 0x0d, 0x54, 0x97, 0xaa, 0x47, 0xe2, 0x9c, 0x24, 0x1c, 0x38, 0xb8, 0x09,
0x0f, 0x67, 0x49, 0x54, 0x38, 0xd7, 0x21, 0x1f, 0x84, 0x44, 0x15, 0x24, 0x9a, 0x20, 0x52, 0x3c,
0xed, 0xf4, 0x89, 0xd3, 0x64, 0xe4, 0x82, 0x29, 0xa7, 0x00, 0x49, 0x6a, 0x90, 0x0b, 0x86, 0x3d,
0x30, 0xf7, 0xc9, 0x24, 0xf3, 0x1b, 0x19, 0x5c, 0xf7, 0xe1, 0xd4, 0x09, 0x54, 0xfb, 0x92, 0x0f,
0x15, 0x0a, 0xf0, 0x08, 0xd6, 0x12, 0x05, 0x2a, 0x75, 0xc6, 0xac, 0x61, 0x8c, 0x5b, 0x63, 0x5c,
0xd7, 0xd4, 0x15, 0xba, 0xa6, 0x27, 0x75, 0xad, 0x7e, 0x2c, 0xc2, 0xbf, 0x94, 0x60, 0xe2, 0x9f,
0xd1, 0x16, 0x41, 0xef, 0xa0, 0x34, 0xf9, 0xa7, 0x02, 0xda, 0x18, 0x4f, 0xbe, 0x53, 0xff, 0x7c,
0x98, 0x9b, 0xb3, 0x2f, 0x48, 0x25, 0xf0, 0x02, 0x7a, 0x15, 0x9f, 0x8f, 0xca, 0x09, 0x53, 0xbd,
0x64, 0xb5, 0x3a, 0x73, 0xde, 0xc7, 0x0b, 0xdb, 0x06, 0x3a, 0x86, 0xe5, 0xf1, 0x61, 0x17, 0x3d,
0x18, 0x97, 0x3d, 0x31, 0x75, 0x9b, 0x0f, 0x67, 0x1d, 0xc7, 0x98, 0x7e, 0x0f, 0xc5, 0xf8, 0xa4,
0x87, 0xd6, 0xf4, 0x37, 0x53, 0xf3, 0xb0, 0xb9, 0x9e, 0x7c, 0x18, 0xe9, 0x79, 0x0c, 0xcb, 0xe3,
0xf3, 0x86, 0x46, 0x98, 0x38, 0x22, 0x69, 0x84, 0xc9, 0x63, 0x8a, 0x40, 0xf8, 0x0a, 0xf2, 0xd1,
0x64, 0xa0, 0x8d, 0x37, 0x39, 0x90, 0x68, 0xe3, 0x4d, 0x8d, 0x11, 0x82, 0x4b, 0x0d, 0x40, 0x77,
0x08, 0x68, 0x35, 0xde, 0x48, 0x8e, 0x0d, 0x12, 0xa6, 0x99, 0x74, 0x14, 0x69, 0xf8, 0x1d, 0x14,
0x62, 0x7f, 0xb4, 0x21, 0x73, 0xdc, 0xc2, 0xf1, 0xff, 0xf8, 0xcc, 0xb5, 0xc4, 0xb3, 0xb8, 0xad,
0xc6, 0x1b, 0x4f, 0x6d, 0xab, 0xc4, 0xee, 0x56, 0xdb, 0x2a, 0xb9, 0x5f, 0x15, 0x5a, 0xbe, 0x86,
0x42, 0xac, 0x0f, 0x42, 0x09, 0xba, 0x4c, 0xc3, 0x4b, 0x68, 0x9c, 0x04, 0xaf, 0x06, 0xdc, 0x9a,
0x68, 0x38, 0xd0, 0xc3, 0x99, 0x9d, 0x88, 0xe4, 0xb9, 0x71, 0x45, 0xa7, 0x82, 0x17, 0xd0, 0x0e,
0xe4, 0xc2, 0xa2, 0x8e, 0xee, 0x47, 0xb9, 0x63, 0xbc, 0xbb, 0x30, 0xcb, 0xd3, 0x07, 0x31, 0x60,
0x3f, 0xc0, 0xca, 0x54, 0xbd, 0x45, 0x51, 0x18, 0xce, 0x6a, 0x05, 0xcc, 0x47, 0x97, 0xdc, 0x88,
0xe0, 0xbd, 0x0f, 0x53, 0x80, 0xae, 0x5f, 0x93, 0x29, 0x60, 0xaa, 0x38, 0x4f, 0xa6, 0x80, 0xe9,
0xd2, 0x27, 0x60, 0xbf, 0x97, 0x53, 0x74, 0x7c, 0x5e, 0xd3, 0xac, 0x67, 0x8c, 0x8a, 0x9a, 0xf5,
0xac, 0x51, 0x4f, 0xb0, 0x0e, 0xa0, 0x3c, 0xab, 0x82, 0xa1, 0xff, 0xe8, 0x77, 0xbe, 0xb4, 0x9c,
0x9a, 0x5b, 0x57, 0x5f, 0x0c, 0x45, 0x6e, 0x19, 0xdb, 0x06, 0x3a, 0x85, 0x7b, 0xc9, 0xc5, 0x08,
0x3d, 0x09, 0x39, 0x5d, 0x5a, 0x1e, 0xcd, 0xa7, 0x57, 0x5d, 0x8b, 0x69, 0x78, 0x02, 0xb7, 0x13,
0xea, 0x04, 0xc2, 0xb1, 0xfc, 0x31, 0xa3, 0x6a, 0x99, 0x8f, 0x2f, 0xbd, 0xa3, 0x65, 0x9c, 0x64,
0xc5, 0xc8, 0xf1, 0xbf, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x80, 0x60, 0xe9, 0xf3, 0xf8, 0x17,
0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/helper/inforefs.go 0 → 100644
View file @ 27bdba30
package helper
import (
"io"
pb "gitlab.com/gitlab-org/gitaly-proto/go"
)
type InfoRefsClient interface {
Recv() (*pb.InfoRefsResponse, error)
}
type InfoRefsClientWriterTo struct {
InfoRefsClient
}
func (clientReader *InfoRefsClientWriterTo) WriteTo(w io.Writer) (total int64, err error) {
for {
response, err := clientReader.Recv()
if err == io.EOF {
return total, nil
} else if err != nil {
return total, err
}
n, err := w.Write(response.GetData())
total += int64(n)
if err != nil {
return total, err
}
}
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/helper/stream.go 0 → 100644
View file @ 27bdba30
package helper
import (
"io"
)
// NewReceiveReader turns receiver into an io.Reader. Errors from the
// receiver function are passed on unmodified. This means receiver should
// emit io.EOF when done.
func NewReceiveReader(receiver func() ([]byte, error)) io.Reader {
return &receiveReader{receiver: receiver}
}
type receiveReader struct {
receiver func() ([]byte, error)
data []byte
err error
}
func (rr *receiveReader) Read(p []byte) (int, error) {
if len(rr.data) == 0 {
rr.data, rr.err = rr.receiver()
}
n := copy(p, rr.data)
rr.data = rr.data[n:]
if len(rr.data) == 0 {
return n, rr.err
}
return n, nil
}
// NewSendWriter turns sender into an io.Writer. The number of 'bytes
// written' reported back is always len(p).
func NewSendWriter(sender func(p []byte) error) io.Writer {
return &sendWriter{sender: sender}
}
type sendWriter struct {
sender func([]byte) error
}
func (sw *sendWriter) Write(p []byte) (int, error) {
return len(p), sw.sender(p)
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/operations.pb.go
View file @ 27bdba30
......@@ -356,7 +356,8 @@ type UserMergeBranchResponse struct {
CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
// Second message
// If set, the merge has been applied to the branch.
BranchUpdate *OperationBranchUpdate `protobuf:"bytes,3,opt,name=branch_update,json=branchUpdate" json:"branch_update,omitempty"`
BranchUpdate *OperationBranchUpdate `protobuf:"bytes,3,opt,name=branch_update,json=branchUpdate" json:"branch_update,omitempty"`
PreReceiveError string `protobuf:"bytes,4,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
}
func (m *UserMergeBranchResponse) Reset() { *m = UserMergeBranchResponse{} }
......@@ -378,6 +379,13 @@ func (m *UserMergeBranchResponse) GetBranchUpdate() *OperationBranchUpdate {
return nil
}
func (m *UserMergeBranchResponse) GetPreReceiveError() string {
if m != nil {
return m.PreReceiveError
}
return ""
}
type OperationBranchUpdate struct {
// If this string is non-empty the branch has been updated.
CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
......@@ -1163,6 +1171,102 @@ func (m *UserRebaseResponse) GetGitError() string {
return ""
}
type UserSquashRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
User *User `protobuf:"bytes,2,opt,name=user" json:"user,omitempty"`
SquashId string `protobuf:"bytes,3,opt,name=squash_id,json=squashId" json:"squash_id,omitempty"`
Branch []byte `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
StartSha string `protobuf:"bytes,5,opt,name=start_sha,json=startSha" json:"start_sha,omitempty"`
EndSha string `protobuf:"bytes,6,opt,name=end_sha,json=endSha" json:"end_sha,omitempty"`
Author *User `protobuf:"bytes,7,opt,name=author" json:"author,omitempty"`
CommitMessage []byte `protobuf:"bytes,8,opt,name=commit_message,json=commitMessage,proto3" json:"commit_message,omitempty"`
}
func (m *UserSquashRequest) Reset() { *m = UserSquashRequest{} }
func (m *UserSquashRequest) String() string { return proto.CompactTextString(m) }
func (*UserSquashRequest) ProtoMessage() {}
func (*UserSquashRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{24} }
func (m *UserSquashRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *UserSquashRequest) GetUser() *User {
if m != nil {
return m.User
}
return nil
}
func (m *UserSquashRequest) GetSquashId() string {
if m != nil {
return m.SquashId
}
return ""
}
func (m *UserSquashRequest) GetBranch() []byte {
if m != nil {
return m.Branch
}
return nil
}
func (m *UserSquashRequest) GetStartSha() string {
if m != nil {
return m.StartSha
}
return ""
}
func (m *UserSquashRequest) GetEndSha() string {
if m != nil {
return m.EndSha
}
return ""
}
func (m *UserSquashRequest) GetAuthor() *User {
if m != nil {
return m.Author
}
return nil
}
func (m *UserSquashRequest) GetCommitMessage() []byte {
if m != nil {
return m.CommitMessage
}
return nil
}
type UserSquashResponse struct {
SquashSha string `protobuf:"bytes,1,opt,name=squash_sha,json=squashSha" json:"squash_sha,omitempty"`
GitError string `protobuf:"bytes,3,opt,name=git_error,json=gitError" json:"git_error,omitempty"`
}
func (m *UserSquashResponse) Reset() { *m = UserSquashResponse{} }
func (m *UserSquashResponse) String() string { return proto.CompactTextString(m) }
func (*UserSquashResponse) ProtoMessage() {}
func (*UserSquashResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{25} }
func (m *UserSquashResponse) GetSquashSha() string {
if m != nil {
return m.SquashSha
}
return ""
}
func (m *UserSquashResponse) GetGitError() string {
if m != nil {
return m.GitError
}
return ""
}
func init() {
proto.RegisterType((*UserCreateBranchRequest)(nil), "gitaly.UserCreateBranchRequest")
proto.RegisterType((*UserCreateBranchResponse)(nil), "gitaly.UserCreateBranchResponse")
......@@ -1188,6 +1292,8 @@ func init() {
proto.RegisterType((*UserCommitFilesResponse)(nil), "gitaly.UserCommitFilesResponse")
proto.RegisterType((*UserRebaseRequest)(nil), "gitaly.UserRebaseRequest")
proto.RegisterType((*UserRebaseResponse)(nil), "gitaly.UserRebaseResponse")
proto.RegisterType((*UserSquashRequest)(nil), "gitaly.UserSquashRequest")
proto.RegisterType((*UserSquashResponse)(nil), "gitaly.UserSquashResponse")
proto.RegisterEnum("gitaly.UserCommitFilesActionHeader_ActionType", UserCommitFilesActionHeader_ActionType_name, UserCommitFilesActionHeader_ActionType_value)
}
......@@ -1212,6 +1318,7 @@ type OperationServiceClient interface {
UserRevert(ctx context.Context, in *UserRevertRequest, opts ...grpc.CallOption) (*UserRevertResponse, error)
UserCommitFiles(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserCommitFilesClient, error)
UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error)
UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error)
}
type operationServiceClient struct {
......@@ -1359,6 +1466,15 @@ func (c *operationServiceClient) UserRebase(ctx context.Context, in *UserRebaseR
return out, nil
}
func (c *operationServiceClient) UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error) {
out := new(UserSquashResponse)
err := grpc.Invoke(ctx, "/gitaly.OperationService/UserSquash", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for OperationService service
type OperationServiceServer interface {
......@@ -1372,6 +1488,7 @@ type OperationServiceServer interface {
UserRevert(context.Context, *UserRevertRequest) (*UserRevertResponse, error)
UserCommitFiles(OperationService_UserCommitFilesServer) error
UserRebase(context.Context, *UserRebaseRequest) (*UserRebaseResponse, error)
UserSquash(context.Context, *UserSquashRequest) (*UserSquashResponse, error)
}
func RegisterOperationServiceServer(s *grpc.Server, srv OperationServiceServer) {
......@@ -1574,6 +1691,24 @@ func _OperationService_UserRebase_Handler(srv interface{}, ctx context.Context,
return interceptor(ctx, in, info, handler)
}
func _OperationService_UserSquash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UserSquashRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperationServiceServer).UserSquash(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.OperationService/UserSquash",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperationServiceServer).UserSquash(ctx, req.(*UserSquashRequest))
}
return interceptor(ctx, in, info, handler)
}
var _OperationService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.OperationService",
HandlerType: (*OperationServiceServer)(nil),
......@@ -1610,6 +1745,10 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
MethodName: "UserRebase",
Handler: _OperationService_UserRebase_Handler,
},
{
MethodName: "UserSquash",
Handler: _OperationService_UserSquash_Handler,
},
},
Streams: []grpc.StreamDesc{
{
......@@ -1630,90 +1769,97 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("operations.proto", fileDescriptor7) }
var fileDescriptor7 = []byte{
// 1357 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
0x14, 0xf7, 0xda, 0xee, 0xc6, 0x79, 0x76, 0x1c, 0x7b, 0xfa, 0x81, 0xeb, 0x36, 0x4d, 0xba, 0xa5,
0x50, 0x2a, 0x64, 0xa1, 0x80, 0xe0, 0x54, 0x50, 0x3e, 0x1c, 0xd2, 0x42, 0xda, 0xb0, 0x4d, 0x0a,
0xb7, 0xd5, 0xc4, 0x1e, 0xec, 0x15, 0xb6, 0x77, 0x99, 0x9d, 0x44, 0x35, 0x42, 0x88, 0x0b, 0x70,
0xe5, 0xc4, 0x81, 0x13, 0x12, 0x37, 0x6e, 0x5c, 0x38, 0x70, 0xe0, 0xc4, 0x89, 0x6b, 0x0f, 0xfc,
0x3b, 0x68, 0x66, 0xde, 0xda, 0xbb, 0xeb, 0xdd, 0x28, 0x81, 0x44, 0x54, 0x88, 0xdb, 0xee, 0x7b,
0x6f, 0xde, 0xbc, 0xf7, 0x7b, 0x1f, 0xf3, 0x66, 0xa0, 0xe6, 0xf9, 0x8c, 0x53, 0xe1, 0x7a, 0xa3,
0xa0, 0xe5, 0x73, 0x4f, 0x78, 0xc4, 0xec, 0xb9, 0x82, 0x0e, 0xc6, 0xcd, 0x4a, 0xd0, 0xa7, 0x9c,
0x75, 0x35, 0xd5, 0xfa, 0xd9, 0x80, 0x17, 0xf6, 0x03, 0xc6, 0x37, 0x38, 0xa3, 0x82, 0xad, 0x73,
0x3a, 0xea, 0xf4, 0x6d, 0xf6, 0xe9, 0x21, 0x0b, 0x04, 0x59, 0x05, 0xe0, 0xcc, 0xf7, 0x02, 0x57,
0x78, 0x7c, 0xdc, 0x30, 0x56, 0x8c, 0x3b, 0xe5, 0x55, 0xd2, 0xd2, 0x6a, 0x5a, 0xf6, 0x84, 0x63,
0x47, 0xa4, 0xc8, 0x32, 0x94, 0x0f, 0x94, 0x12, 0x67, 0x44, 0x87, 0xac, 0x91, 0x5f, 0x31, 0xee,
0x54, 0x6c, 0xd0, 0xa4, 0x87, 0x74, 0xc8, 0xc8, 0x0a, 0x14, 0x0f, 0x03, 0xc6, 0x1b, 0x05, 0xa5,
0xae, 0x12, 0xaa, 0x93, 0x36, 0xd8, 0x8a, 0x23, 0x55, 0x04, 0x82, 0x72, 0xe1, 0xf8, 0x9e, 0x3b,
0x12, 0x8d, 0xa2, 0x56, 0xa1, 0x48, 0xbb, 0x92, 0x62, 0x8d, 0xa0, 0x31, 0x6b, 0x72, 0xe0, 0x7b,
0xa3, 0x80, 0x91, 0x97, 0xc0, 0xd4, 0x9b, 0xa1, 0xbd, 0xd5, 0x70, 0x03, 0x94, 0x43, 0x2e, 0xb9,
0x0b, 0x75, 0x9f, 0x33, 0x87, 0xb3, 0x0e, 0x73, 0x8f, 0x98, 0xc3, 0x38, 0xf7, 0xb8, 0xb2, 0x76,
0xde, 0x5e, 0xf4, 0x39, 0xb3, 0x35, 0xbd, 0x2d, 0xc9, 0xd6, 0xb7, 0x88, 0xd1, 0x26, 0x1b, 0xb0,
0xe7, 0x03, 0x23, 0x6b, 0x4b, 0x43, 0x10, 0xb7, 0x08, 0x21, 0x48, 0x75, 0xcd, 0x48, 0x77, 0xed,
0x1b, 0x03, 0x2e, 0x4d, 0x15, 0xed, 0xd1, 0xde, 0x3f, 0xf1, 0xeb, 0x2a, 0x94, 0x04, 0xed, 0x45,
0x9d, 0x9a, 0x13, 0xb4, 0x77, 0x42, 0x8f, 0x36, 0xe0, 0x72, 0xc2, 0x90, 0xbf, 0xe1, 0xce, 0x1f,
0xe8, 0x8e, 0x4e, 0x8d, 0x7f, 0xd1, 0x1d, 0xf2, 0x32, 0x2c, 0x0a, 0xca, 0x7b, 0x4c, 0x38, 0x9c,
0x1d, 0xb9, 0x81, 0xeb, 0x8d, 0x30, 0x91, 0xab, 0x9a, 0x6c, 0x23, 0x95, 0x34, 0x60, 0x6e, 0xc8,
0x82, 0x80, 0xf6, 0x58, 0xe3, 0x82, 0xde, 0x04, 0x7f, 0xad, 0xcf, 0x34, 0x22, 0x11, 0x5f, 0x10,
0x91, 0x25, 0x28, 0x08, 0xda, 0x43, 0x2f, 0xca, 0xe1, 0xe6, 0x52, 0x42, 0xd2, 0xc9, 0x15, 0x30,
0xd9, 0x53, 0x37, 0x10, 0x81, 0xb2, 0xba, 0x64, 0xe3, 0x5f, 0x3a, 0x90, 0x85, 0x74, 0x20, 0x9f,
0x19, 0x70, 0x45, 0x6e, 0xbe, 0xc3, 0x78, 0xef, 0x0c, 0x32, 0x3e, 0xc4, 0x2b, 0x9f, 0x89, 0xd7,
0x35, 0x98, 0xef, 0x78, 0xc3, 0xa1, 0x2b, 0x1c, 0xb7, 0x8b, 0x46, 0x95, 0x34, 0xe1, 0x7e, 0x57,
0x7a, 0x84, 0x45, 0xad, 0x31, 0x0c, 0x8b, 0x38, 0x13, 0x3b, 0x72, 0x09, 0x2e, 0x50, 0xdf, 0x1f,
0x8c, 0x1b, 0xa6, 0x82, 0x40, 0xff, 0x58, 0x5f, 0x62, 0x21, 0xc7, 0xbc, 0x42, 0x50, 0x63, 0x06,
0x18, 0x09, 0x03, 0xd6, 0x61, 0x01, 0x2b, 0xf6, 0xd0, 0xef, 0x52, 0xc1, 0x30, 0xf0, 0x4b, 0xa1,
0x23, 0x8f, 0xc2, 0x66, 0xab, 0x95, 0xee, 0x2b, 0x21, 0xbb, 0x72, 0x10, 0xf9, 0x7b, 0x50, 0x2c,
0xe5, 0x6b, 0x05, 0xeb, 0x0b, 0xb8, 0x9c, 0x2a, 0x7c, 0xfc, 0xfe, 0x37, 0xa1, 0x22, 0xd1, 0x74,
0x3a, 0x2a, 0x17, 0xba, 0x18, 0xd8, 0xb2, 0xa4, 0xe9, 0xf4, 0xe8, 0x92, 0xdb, 0x50, 0x45, 0x13,
0x43, 0xa1, 0x82, 0x12, 0x42, 0xc3, 0x51, 0xcc, 0xfa, 0xc1, 0x80, 0x8b, 0x12, 0x82, 0xad, 0xad,
0xe7, 0x35, 0xaa, 0xd6, 0xd7, 0x58, 0xc4, 0x53, 0x13, 0x31, 0x44, 0x33, 0x51, 0x30, 0x4e, 0x1d,
0x85, 0x53, 0xf5, 0xfd, 0xdf, 0xf2, 0x58, 0x81, 0x7d, 0xc6, 0xf9, 0x78, 0xd7, 0xed, 0x7c, 0x72,
0xbe, 0x68, 0xbd, 0x02, 0xa6, 0x06, 0x07, 0xd3, 0xab, 0x1e, 0xca, 0xbc, 0xeb, 0x8a, 0x0d, 0xc5,
0xb0, 0x51, 0x20, 0x79, 0x84, 0x14, 0x67, 0x8e, 0x90, 0xec, 0xd2, 0xb8, 0x0b, 0x75, 0x7d, 0xbc,
0x46, 0x15, 0x98, 0x4a, 0x66, 0x51, 0x31, 0xd6, 0xa7, 0x5a, 0xee, 0x41, 0x4d, 0xcb, 0x46, 0xbc,
0x9d, 0xcb, 0xf4, 0x56, 0x2f, 0x9f, 0x12, 0xac, 0x3f, 0xb1, 0x8b, 0x44, 0x01, 0x3c, 0xdb, 0x58,
0xea, 0x5c, 0x77, 0x04, 0x67, 0x89, 0x58, 0x6a, 0xc6, 0x1e, 0x67, 0x3a, 0x96, 0xb2, 0x82, 0x30,
0x13, 0xa3, 0x7d, 0xaf, 0xac, 0x69, 0x5a, 0x24, 0x35, 0x35, 0x8a, 0xe9, 0xa9, 0xf1, 0x6b, 0x1e,
0xea, 0x2a, 0x72, 0xec, 0x88, 0x49, 0x97, 0xff, 0x4f, 0x8b, 0x53, 0xa4, 0xc5, 0x33, 0x03, 0x48,
0x14, 0xbc, 0xff, 0x46, 0x4a, 0x7c, 0x9f, 0x87, 0x6b, 0x2a, 0xd9, 0xd5, 0xfa, 0x2d, 0x77, 0xc0,
0x82, 0xb5, 0x8e, 0x34, 0x77, 0x9b, 0xd1, 0x2e, 0xe3, 0x64, 0x0b, 0x4c, 0xaa, 0xfe, 0x95, 0x5f,
0xd5, 0xd5, 0x56, 0x34, 0xd4, 0x19, 0x8b, 0x5a, 0xfa, 0x67, 0x6f, 0xec, 0x33, 0x1b, 0x57, 0xcb,
0x9e, 0xfa, 0xb1, 0x3b, 0x60, 0x8e, 0x4f, 0x45, 0x1f, 0xe7, 0x92, 0x92, 0x24, 0xec, 0x52, 0xd1,
0x27, 0xb7, 0x60, 0xc1, 0x97, 0x03, 0x87, 0x77, 0x18, 0x68, 0x81, 0x82, 0x12, 0xa8, 0x84, 0x44,
0x25, 0x24, 0x8f, 0x0a, 0x1a, 0xb0, 0x37, 0xdf, 0x70, 0x3a, 0xde, 0x48, 0x30, 0x9c, 0xb1, 0xe5,
0x51, 0xa1, 0xa8, 0x1b, 0x9a, 0x68, 0x3d, 0x00, 0x98, 0x6e, 0x4f, 0x00, 0xcc, 0x0d, 0xbb, 0xbd,
0xb6, 0xd7, 0xae, 0xe5, 0x48, 0x15, 0x40, 0x7f, 0x3b, 0x9b, 0xf7, 0xed, 0x9a, 0x21, 0x79, 0xfb,
0xbb, 0x9b, 0x92, 0x97, 0x27, 0x25, 0x28, 0xee, 0x3c, 0x7a, 0xd2, 0xae, 0x15, 0x24, 0x75, 0xb3,
0xfd, 0x7e, 0x7b, 0xaf, 0x5d, 0x2b, 0x5a, 0xdf, 0x19, 0xd8, 0x4a, 0x93, 0x7e, 0x92, 0x7b, 0x60,
0xf6, 0x95, 0xaf, 0x18, 0xee, 0x5b, 0x27, 0x80, 0x65, 0x3b, 0x67, 0xe3, 0x22, 0xd2, 0x84, 0xb9,
0xd0, 0x09, 0x85, 0xc5, 0x76, 0xce, 0x0e, 0x09, 0xeb, 0x16, 0xac, 0xc8, 0x02, 0x72, 0x30, 0xca,
0x12, 0xa4, 0xc0, 0xd1, 0x28, 0x3a, 0x3e, 0x1d, 0x0f, 0x3c, 0xda, 0xb5, 0xbe, 0x2a, 0xc0, 0xf5,
0xc4, 0x4e, 0x58, 0xcd, 0x18, 0xb6, 0xf3, 0xa9, 0xe9, 0x44, 0xa1, 0x16, 0x66, 0x0a, 0xf5, 0x36,
0x54, 0xd1, 0xec, 0xb0, 0x5e, 0x75, 0x31, 0x2f, 0x68, 0xea, 0x0e, 0x56, 0xed, 0xab, 0x40, 0x50,
0x8c, 0x1e, 0x8a, 0xbe, 0xc7, 0xb5, 0x3a, 0x5d, 0xda, 0x35, 0xcd, 0x59, 0x53, 0x0c, 0xa5, 0xb4,
0x05, 0x17, 0xe3, 0xd2, 0x6c, 0x48, 0xdd, 0x01, 0x56, 0x79, 0x3d, 0x2a, 0xde, 0x96, 0x8c, 0xf4,
0x9e, 0x30, 0x77, 0xf2, 0x9e, 0x50, 0x3a, 0x79, 0x4f, 0xf8, 0x25, 0x3c, 0x2a, 0x66, 0xe2, 0x40,
0xde, 0x4e, 0x64, 0xc8, 0x8b, 0x19, 0x19, 0x12, 0x8b, 0x5b, 0x24, 0x45, 0xde, 0x9a, 0x14, 0x5e,
0x3e, 0xde, 0x50, 0xd2, 0x33, 0x2c, 0x17, 0x56, 0xda, 0xfa, 0x2d, 0xb8, 0x39, 0x9b, 0x3f, 0x5c,
0xef, 0x32, 0x49, 0xa0, 0x9f, 0xc2, 0x0b, 0x74, 0xd4, 0x90, 0x33, 0xec, 0x68, 0xcb, 0x50, 0x76,
0x47, 0x5d, 0xf6, 0x34, 0xd6, 0xcb, 0x40, 0x91, 0x8e, 0xe9, 0x51, 0x19, 0x63, 0xfd, 0x8f, 0x93,
0x63, 0x4b, 0x96, 0xfa, 0xb9, 0xcf, 0x7e, 0x5c, 0x6d, 0x13, 0x99, 0xfd, 0x34, 0xe1, 0x98, 0x89,
0x7e, 0x09, 0xb0, 0x08, 0x9c, 0xa0, 0x4f, 0x55, 0x1e, 0xcf, 0xdb, 0xf3, 0x9a, 0xf2, 0xb8, 0x4f,
0xc9, 0x3b, 0x50, 0xe7, 0x6c, 0xe8, 0x09, 0x16, 0xcd, 0x32, 0x33, 0xd3, 0xe0, 0x9a, 0x16, 0x9e,
0x52, 0x64, 0x7f, 0x44, 0x05, 0xb8, 0xbd, 0xce, 0xe6, 0x8a, 0x26, 0xea, 0x30, 0x58, 0x9f, 0x87,
0xc7, 0x93, 0x06, 0x69, 0x72, 0xeb, 0x02, 0xf4, 0x47, 0x9a, 0xa6, 0x27, 0x74, 0xf4, 0x50, 0x9a,
0x76, 0x8a, 0xc1, 0x52, 0x42, 0xd3, 0x4b, 0x1c, 0x3b, 0xa5, 0x1e, 0x9e, 0x39, 0xab, 0xbf, 0x9b,
0x50, 0x9b, 0x24, 0xc6, 0x63, 0xc6, 0x8f, 0xdc, 0x0e, 0x23, 0x1f, 0x42, 0x2d, 0xf9, 0xe4, 0x41,
0x96, 0x63, 0x79, 0x3c, 0xfb, 0x7e, 0xd3, 0x5c, 0xc9, 0x16, 0xd0, 0x3e, 0x59, 0xb9, 0x50, 0x71,
0xf4, 0x21, 0x21, 0xae, 0x38, 0xe5, 0xd1, 0x23, 0xae, 0x38, 0xed, 0x0d, 0xc2, 0xca, 0x91, 0x87,
0xb0, 0x10, 0xbb, 0xbd, 0x92, 0xeb, 0xb3, 0xd6, 0x4c, 0x2f, 0xe8, 0xcd, 0xa5, 0x0c, 0x6e, 0x52,
0xdf, 0xe4, 0x7d, 0x20, 0xae, 0x2f, 0xf9, 0x7e, 0x11, 0xd7, 0x37, 0xf3, 0xa8, 0x60, 0xe5, 0xc8,
0x47, 0xb0, 0x98, 0xb8, 0x0a, 0x92, 0x1b, 0xd1, 0x35, 0xb3, 0x37, 0xdf, 0xe6, 0x72, 0x26, 0x3f,
0xd4, 0x7a, 0xc7, 0x78, 0xcd, 0x20, 0xef, 0x41, 0x25, 0x7a, 0x7d, 0x21, 0xd7, 0xa2, 0xcb, 0x12,
0xf7, 0xae, 0xe6, 0xf5, 0x74, 0xe6, 0xc4, 0xcc, 0x0f, 0xa0, 0x1a, 0x9f, 0xa0, 0x49, 0x1c, 0xa9,
0xe4, 0xd5, 0xa4, 0x79, 0x23, 0x8b, 0x3d, 0x51, 0xd9, 0x06, 0x98, 0x4e, 0x5f, 0xe4, 0x6a, 0xac,
0x74, 0xa3, 0xe3, 0x6c, 0xb3, 0x99, 0xc6, 0x9a, 0xa8, 0x79, 0xa2, 0x01, 0x8c, 0xf4, 0xbd, 0x38,
0x80, 0xb3, 0x9d, 0x39, 0x0e, 0x60, 0x4a, 0xc3, 0x94, 0x00, 0x4e, 0xcd, 0x93, 0x95, 0x95, 0x34,
0x2f, 0xd2, 0xb6, 0x92, 0xe6, 0x45, 0x8b, 0xd5, 0xca, 0x1d, 0x98, 0xea, 0x7d, 0xf3, 0xf5, 0xbf,
0x02, 0x00, 0x00, 0xff, 0xff, 0x39, 0x0c, 0xa6, 0xa6, 0x09, 0x15, 0x00, 0x00,
// 1459 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4f, 0x73, 0xdb, 0x44,
0x14, 0xb7, 0x6c, 0x57, 0x76, 0x5e, 0x1c, 0xc7, 0xd9, 0xfe, 0x73, 0xdd, 0xa6, 0x49, 0xd5, 0x16,
0x4a, 0x87, 0xc9, 0x30, 0x81, 0x81, 0x53, 0x61, 0x9a, 0xc4, 0xa1, 0x2d, 0xb4, 0x0d, 0x6a, 0x5a,
0xb8, 0x69, 0xb6, 0xf6, 0x62, 0x6b, 0xb0, 0x2d, 0x75, 0xa5, 0x64, 0x6a, 0x86, 0xe1, 0x06, 0x1c,
0xb8, 0x70, 0xe2, 0xc0, 0x09, 0x86, 0x1b, 0xc3, 0x85, 0x0b, 0x07, 0x0e, 0x7c, 0x00, 0xae, 0x3d,
0xf0, 0x75, 0x98, 0xdd, 0xf7, 0x64, 0x4b, 0xb2, 0x94, 0x49, 0x21, 0x19, 0x3a, 0x0c, 0x37, 0xe9,
0xbd, 0xb7, 0x6f, 0xdf, 0xfb, 0xbd, 0x7f, 0xbb, 0x0b, 0x0d, 0xcf, 0x17, 0x92, 0x87, 0xae, 0x37,
0x0a, 0xd6, 0x7c, 0xe9, 0x85, 0x1e, 0x33, 0x7b, 0x6e, 0xc8, 0x07, 0xe3, 0x56, 0x2d, 0xe8, 0x73,
0x29, 0xba, 0x48, 0xb5, 0x7e, 0x31, 0xe0, 0xec, 0xc3, 0x40, 0xc8, 0x4d, 0x29, 0x78, 0x28, 0x36,
0x24, 0x1f, 0x75, 0xfa, 0xb6, 0x78, 0xb2, 0x27, 0x82, 0x90, 0xad, 0x03, 0x48, 0xe1, 0x7b, 0x81,
0x1b, 0x7a, 0x72, 0xdc, 0x34, 0x56, 0x8d, 0x6b, 0xf3, 0xeb, 0x6c, 0x0d, 0xd5, 0xac, 0xd9, 0x13,
0x8e, 0x1d, 0x93, 0x62, 0x2b, 0x30, 0xff, 0x58, 0x2b, 0x71, 0x46, 0x7c, 0x28, 0x9a, 0xc5, 0x55,
0xe3, 0x5a, 0xcd, 0x06, 0x24, 0xdd, 0xe3, 0x43, 0xc1, 0x56, 0xa1, 0xbc, 0x17, 0x08, 0xd9, 0x2c,
0x69, 0x75, 0xb5, 0x48, 0x9d, 0xb2, 0xc1, 0xd6, 0x1c, 0xa5, 0x22, 0x08, 0xb9, 0x0c, 0x1d, 0xdf,
0x73, 0x47, 0x61, 0xb3, 0x8c, 0x2a, 0x34, 0x69, 0x47, 0x51, 0xac, 0x11, 0x34, 0x67, 0x4d, 0x0e,
0x7c, 0x6f, 0x14, 0x08, 0xf6, 0x12, 0x98, 0xb8, 0x19, 0xd9, 0x5b, 0x8f, 0x36, 0x20, 0x39, 0xe2,
0xb2, 0xeb, 0xb0, 0xe4, 0x4b, 0xe1, 0x48, 0xd1, 0x11, 0xee, 0xbe, 0x70, 0x84, 0x94, 0x9e, 0xd4,
0xd6, 0xce, 0xd9, 0x8b, 0xbe, 0x14, 0x36, 0xd2, 0xdb, 0x8a, 0x6c, 0x7d, 0x43, 0x18, 0x6d, 0x89,
0x81, 0x78, 0x31, 0x30, 0xb2, 0xb6, 0x11, 0x82, 0xa4, 0x45, 0x04, 0x41, 0xa6, 0x6b, 0x46, 0xb6,
0x6b, 0x5f, 0x19, 0x70, 0x6a, 0xaa, 0x68, 0x97, 0xf7, 0xfe, 0x89, 0x5f, 0xe7, 0xa0, 0x1a, 0xf2,
0x5e, 0xdc, 0xa9, 0x4a, 0xc8, 0x7b, 0x87, 0xf4, 0x68, 0x13, 0x4e, 0xa7, 0x0c, 0xf9, 0x1b, 0xee,
0xfc, 0x41, 0xee, 0x60, 0x6a, 0xfc, 0x8b, 0xee, 0xb0, 0x97, 0x61, 0x31, 0xe4, 0xb2, 0x27, 0x42,
0x47, 0x8a, 0x7d, 0x37, 0x70, 0xbd, 0x11, 0x25, 0x72, 0x1d, 0xc9, 0x36, 0x51, 0x59, 0x13, 0x2a,
0x43, 0x11, 0x04, 0xbc, 0x27, 0x9a, 0x27, 0x70, 0x13, 0xfa, 0xb5, 0x3e, 0x45, 0x44, 0x62, 0xbe,
0x10, 0x22, 0xcb, 0x50, 0x0a, 0x79, 0x8f, 0xbc, 0x98, 0x8f, 0x36, 0x57, 0x12, 0x8a, 0xce, 0xce,
0x80, 0x29, 0x9e, 0xba, 0x41, 0x18, 0x68, 0xab, 0xab, 0x36, 0xfd, 0x65, 0x03, 0x59, 0xca, 0x06,
0xf2, 0x99, 0x01, 0x67, 0xd4, 0xe6, 0x77, 0x85, 0xec, 0x1d, 0x41, 0xc6, 0x47, 0x78, 0x15, 0x73,
0xf1, 0x3a, 0x0f, 0x73, 0x1d, 0x6f, 0x38, 0x74, 0x43, 0xc7, 0xed, 0x92, 0x51, 0x55, 0x24, 0xdc,
0xee, 0x2a, 0x8f, 0xa8, 0xa8, 0x11, 0xc3, 0xa8, 0x88, 0x73, 0xb1, 0x63, 0xa7, 0xe0, 0x04, 0xf7,
0xfd, 0xc1, 0xb8, 0x69, 0x6a, 0x08, 0xf0, 0xc7, 0xfa, 0x99, 0x0a, 0x39, 0xe1, 0x15, 0x81, 0x9a,
0x30, 0xc0, 0x48, 0x19, 0xb0, 0x01, 0x0b, 0x54, 0xb1, 0x7b, 0x7e, 0x97, 0x87, 0x82, 0x02, 0xbf,
0x1c, 0x39, 0x72, 0x3f, 0x6a, 0xb6, 0xa8, 0xf4, 0xa1, 0x16, 0xb2, 0x6b, 0x8f, 0x63, 0x7f, 0xd9,
0xf0, 0x97, 0x33, 0xe1, 0xbf, 0x53, 0xae, 0x16, 0x1b, 0x25, 0xeb, 0x73, 0x38, 0x9d, 0xa9, 0xf8,
0x60, 0x5b, 0x2f, 0x41, 0x4d, 0x21, 0xef, 0x74, 0x74, 0xde, 0x74, 0x29, 0x09, 0xe6, 0x15, 0x0d,
0x53, 0xa9, 0xcb, 0xae, 0x42, 0x9d, 0xdc, 0x89, 0x84, 0x4a, 0x5a, 0x88, 0x9c, 0x24, 0x31, 0xeb,
0x7b, 0x03, 0x4e, 0x2a, 0xb8, 0xb6, 0xb7, 0x5f, 0xd4, 0x0c, 0xb0, 0xbe, 0xa4, 0x82, 0x9f, 0x9a,
0x48, 0xe1, 0x9c, 0x89, 0x98, 0x71, 0x44, 0x11, 0xcb, 0x99, 0x11, 0xbf, 0x17, 0xa9, 0x5a, 0xfb,
0x42, 0xca, 0xf1, 0x8e, 0xdb, 0xf9, 0xe4, 0x78, 0xd1, 0x7a, 0x05, 0x4c, 0x04, 0x87, 0x52, 0x71,
0x29, 0x92, 0x79, 0xd7, 0x0d, 0x37, 0x35, 0xc3, 0x26, 0x81, 0xf4, 0xb8, 0x29, 0xcf, 0x8c, 0x9b,
0xfc, 0x32, 0xba, 0x0e, 0x4b, 0x38, 0x8a, 0xe3, 0x0a, 0x4c, 0x2d, 0xb3, 0xa8, 0x19, 0x1b, 0x53,
0x2d, 0x37, 0xa0, 0x81, 0xb2, 0x31, 0x6f, 0x2b, 0xb9, 0xde, 0xe2, 0xf2, 0x29, 0xc1, 0xfa, 0x93,
0x3a, 0x4e, 0x1c, 0xc0, 0xa3, 0x8d, 0x25, 0xe6, 0xba, 0x13, 0x4a, 0x91, 0x8a, 0x25, 0x32, 0x76,
0xa5, 0xc0, 0x58, 0xaa, 0x0a, 0xa2, 0x4c, 0x8c, 0xf7, 0xc8, 0x79, 0xa4, 0xa1, 0xc8, 0x73, 0x14,
0xb3, 0xf5, 0x5b, 0x11, 0x96, 0x74, 0xe4, 0xc4, 0xbe, 0x50, 0x2e, 0xff, 0x9f, 0x16, 0xcf, 0x91,
0x16, 0xcf, 0x0c, 0x60, 0x71, 0xf0, 0xfe, 0x1b, 0x29, 0xf1, 0x5d, 0x11, 0xce, 0xeb, 0x64, 0xd7,
0xeb, 0xb7, 0xdd, 0x81, 0x08, 0x6e, 0x76, 0x94, 0xb9, 0xb7, 0x04, 0xef, 0x0a, 0xc9, 0xb6, 0xc1,
0xe4, 0xfa, 0x5f, 0xfb, 0x55, 0x5f, 0x5f, 0x8b, 0x87, 0x3a, 0x67, 0xd1, 0x1a, 0xfe, 0xec, 0x8e,
0x7d, 0x61, 0xd3, 0x6a, 0xd5, 0x53, 0x3f, 0x76, 0x07, 0xc2, 0xf1, 0x79, 0xd8, 0xa7, 0x33, 0x4c,
0x55, 0x11, 0x76, 0x78, 0xd8, 0x67, 0x97, 0x61, 0xc1, 0x57, 0x87, 0x13, 0x6f, 0x2f, 0x40, 0x81,
0x92, 0x16, 0xa8, 0x45, 0x44, 0x2d, 0xa4, 0x46, 0x05, 0x0f, 0xc4, 0x9b, 0x6f, 0x38, 0x1d, 0x6f,
0x14, 0x0a, 0x3a, 0x8f, 0xab, 0x51, 0xa1, 0xa9, 0x9b, 0x48, 0xb4, 0xee, 0x00, 0x4c, 0xb7, 0x67,
0x00, 0xe6, 0xa6, 0xdd, 0xbe, 0xb9, 0xdb, 0x6e, 0x14, 0x58, 0x1d, 0x00, 0xbf, 0x9d, 0xad, 0xdb,
0x76, 0xc3, 0x50, 0xbc, 0x87, 0x3b, 0x5b, 0x8a, 0x57, 0x64, 0x55, 0x28, 0xdf, 0xbd, 0xff, 0xa8,
0xdd, 0x28, 0x29, 0xea, 0x56, 0xfb, 0xfd, 0xf6, 0x6e, 0xbb, 0x51, 0xb6, 0xbe, 0x35, 0xa8, 0x95,
0xa6, 0xfd, 0x64, 0x37, 0xc0, 0xec, 0x6b, 0x5f, 0x29, 0xdc, 0x97, 0x0f, 0x01, 0xcb, 0xad, 0x82,
0x4d, 0x8b, 0x58, 0x0b, 0x2a, 0x91, 0x13, 0x1a, 0x8b, 0x5b, 0x05, 0x3b, 0x22, 0x6c, 0x58, 0xb0,
0xaa, 0x0a, 0xc8, 0xa1, 0x28, 0x2b, 0x90, 0x02, 0x07, 0x51, 0x74, 0x7c, 0x3e, 0x1e, 0x78, 0xbc,
0x6b, 0x7d, 0x51, 0x82, 0x0b, 0xa9, 0x9d, 0xa8, 0x9a, 0x29, 0x6c, 0xc7, 0x53, 0xd3, 0xa9, 0x42,
0x2d, 0xcd, 0x14, 0xea, 0x55, 0xa8, 0x93, 0xd9, 0x51, 0xbd, 0x62, 0x31, 0x2f, 0x20, 0xf5, 0x2e,
0x55, 0xed, 0xab, 0xc0, 0x48, 0x8c, 0xef, 0x85, 0x7d, 0x4f, 0xa2, 0x3a, 0x2c, 0xed, 0x06, 0x72,
0x6e, 0x6a, 0x86, 0x56, 0xba, 0x06, 0x27, 0x93, 0xd2, 0x62, 0xc8, 0xdd, 0x01, 0x55, 0xf9, 0x52,
0x5c, 0xbc, 0xad, 0x18, 0xd9, 0x3d, 0xa1, 0x72, 0xf8, 0x9e, 0x50, 0x3d, 0x7c, 0x4f, 0xf8, 0x35,
0x1a, 0x15, 0x33, 0x71, 0x60, 0x6f, 0xa7, 0x32, 0xe4, 0x4a, 0x4e, 0x86, 0x24, 0xe2, 0x16, 0x4b,
0x91, 0xb7, 0x26, 0x85, 0x57, 0x4c, 0x36, 0x94, 0xec, 0x0c, 0x2b, 0x44, 0x95, 0xb6, 0x71, 0x19,
0x2e, 0xcd, 0xe6, 0x8f, 0xc4, 0x5d, 0x26, 0x09, 0xf4, 0x53, 0x74, 0xd9, 0x8e, 0x1b, 0x72, 0x84,
0x1d, 0x6d, 0x05, 0xe6, 0xdd, 0x51, 0x57, 0x3c, 0x4d, 0xf4, 0x32, 0xd0, 0xa4, 0x03, 0x7a, 0x54,
0xce, 0x15, 0xe0, 0xc7, 0xc9, 0xd8, 0x52, 0xa5, 0x7e, 0xec, 0x67, 0x3f, 0xa9, 0xb7, 0x89, 0x9d,
0xfd, 0x90, 0x70, 0xc0, 0xe9, 0x7f, 0x19, 0xa8, 0x08, 0x9c, 0xa0, 0xcf, 0x75, 0x1e, 0xcf, 0xd9,
0x73, 0x48, 0x79, 0xd0, 0xe7, 0xec, 0x1d, 0x58, 0x92, 0x62, 0xe8, 0x85, 0x22, 0x9e, 0x65, 0x66,
0xae, 0xc1, 0x0d, 0x14, 0x9e, 0x52, 0x54, 0x7f, 0x24, 0x05, 0xb4, 0x3d, 0x66, 0x73, 0x0d, 0x89,
0x18, 0x06, 0xeb, 0xb3, 0x68, 0x3c, 0x21, 0x48, 0x93, 0x1b, 0x1a, 0x90, 0x3f, 0xca, 0x34, 0x3c,
0xa1, 0x93, 0x87, 0xca, 0xb4, 0xe7, 0x38, 0x58, 0x2a, 0x68, 0x7a, 0xa9, 0xb1, 0x53, 0xed, 0xd1,
0xcc, 0xb1, 0x7e, 0xa0, 0x18, 0x3d, 0x78, 0xb2, 0xc7, 0x83, 0xe3, 0x3f, 0x9f, 0x07, 0x7a, 0x9b,
0x58, 0x8c, 0x90, 0x70, 0x40, 0x8c, 0xd4, 0x22, 0x5d, 0xe9, 0xd3, 0x10, 0x55, 0x35, 0x41, 0xc1,
0x70, 0x16, 0x2a, 0x62, 0xd4, 0xd5, 0x2c, 0x53, 0xb3, 0x4c, 0x31, 0xea, 0x2a, 0xc6, 0x15, 0x30,
0xb1, 0xe9, 0xd0, 0x49, 0x21, 0x69, 0x0e, 0xf1, 0x32, 0xda, 0x5e, 0x35, 0xa3, 0xed, 0x59, 0x2e,
0x46, 0x28, 0x82, 0x68, 0x1a, 0x21, 0xf2, 0x26, 0x16, 0x21, 0xa4, 0x28, 0x0b, 0x0e, 0x42, 0x1d,
0x6f, 0x67, 0xf6, 0x6c, 0x08, 0xd7, 0xbf, 0xae, 0x40, 0x63, 0x52, 0xa7, 0x0f, 0x84, 0xdc, 0x77,
0x3b, 0x82, 0x7d, 0x08, 0x8d, 0xf4, 0x6b, 0x15, 0x5b, 0x49, 0xb4, 0x95, 0xd9, 0xa7, 0xb7, 0xd6,
0x6a, 0xbe, 0x00, 0x3a, 0x60, 0x15, 0x22, 0xc5, 0xf1, 0x37, 0xa0, 0xa4, 0xe2, 0x8c, 0xf7, 0xaa,
0xa4, 0xe2, 0xac, 0xe7, 0x23, 0xab, 0xc0, 0xee, 0xc1, 0x42, 0xe2, 0xe1, 0x81, 0x5d, 0x98, 0xb5,
0x66, 0xfa, 0xb6, 0xd2, 0x5a, 0xce, 0xe1, 0xa6, 0xf5, 0x4d, 0x9e, 0x76, 0x92, 0xfa, 0xd2, 0x4f,
0x4f, 0x49, 0x7d, 0x33, 0xef, 0x41, 0x56, 0x81, 0x7d, 0x04, 0x8b, 0xa9, 0x5b, 0x3c, 0xbb, 0x18,
0x5f, 0x33, 0xfb, 0x68, 0xd1, 0x5a, 0xc9, 0xe5, 0x47, 0x5a, 0xaf, 0x19, 0xaf, 0x19, 0xec, 0x3d,
0xa8, 0xc5, 0x6f, 0x93, 0xec, 0x7c, 0x7c, 0x59, 0xea, 0x1a, 0xdc, 0xba, 0x90, 0xcd, 0x9c, 0x98,
0xf9, 0x01, 0xd4, 0x93, 0x17, 0x1a, 0x96, 0x44, 0x2a, 0x7d, 0x53, 0x6c, 0x5d, 0xcc, 0x63, 0x4f,
0x54, 0xb6, 0x01, 0xa6, 0x87, 0x61, 0x76, 0x2e, 0x51, 0x16, 0xf1, 0xdb, 0x45, 0xab, 0x95, 0xc5,
0x9a, 0xa8, 0x79, 0x84, 0x00, 0xc6, 0xc6, 0x50, 0x12, 0xc0, 0xd9, 0x41, 0x99, 0x04, 0x30, 0x63,
0x7e, 0x29, 0x00, 0xa7, 0xe6, 0xa9, 0x46, 0x97, 0x36, 0x2f, 0x36, 0x45, 0xd2, 0xe6, 0xc5, 0x7b,
0xe7, 0xd4, 0x4b, 0xac, 0xd8, 0xa4, 0x9a, 0x44, 0xa3, 0x4b, 0xaa, 0x49, 0x16, 0xb8, 0x55, 0x78,
0x6c, 0xea, 0x17, 0xee, 0xd7, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x36, 0x90, 0x2b, 0x73, 0x0b,
0x17, 0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go
View file @ 27bdba30
......@@ -621,8 +621,10 @@ func (m *FindBranchResponse) GetBranch() *Branch {
}
type DeleteRefsRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
ExceptWithPrefix [][]byte `protobuf:"bytes,2,rep,name=except_with_prefix,json=exceptWithPrefix,proto3" json:"except_with_prefix,omitempty"`
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// The following two fields are mutually exclusive
ExceptWithPrefix [][]byte `protobuf:"bytes,2,rep,name=except_with_prefix,json=exceptWithPrefix,proto3" json:"except_with_prefix,omitempty"`
Refs [][]byte `protobuf:"bytes,3,rep,name=refs,proto3" json:"refs,omitempty"`
}
func (m *DeleteRefsRequest) Reset() { *m = DeleteRefsRequest{} }
......@@ -644,7 +646,15 @@ func (m *DeleteRefsRequest) GetExceptWithPrefix() [][]byte {
return nil
}
func (m *DeleteRefsRequest) GetRefs() [][]byte {
if m != nil {
return m.Refs
}
return nil
}
type DeleteRefsResponse struct {
GitError string `protobuf:"bytes,1,opt,name=git_error,json=gitError" json:"git_error,omitempty"`
}
func (m *DeleteRefsResponse) Reset() { *m = DeleteRefsResponse{} }
......@@ -652,9 +662,19 @@ func (m *DeleteRefsResponse) String() string { return proto.CompactTe
func (*DeleteRefsResponse) ProtoMessage() {}
func (*DeleteRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{25} }
func (m *DeleteRefsResponse) GetGitError() string {
if m != nil {
return m.GitError
}
return ""
}
type ListBranchNamesContainingCommitRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
// Limit the number of tag names to be returned
// If the limit is set to zero, all items will be returned
Limit uint32 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
}
func (m *ListBranchNamesContainingCommitRequest) Reset() {
......@@ -680,6 +700,13 @@ func (m *ListBranchNamesContainingCommitRequest) GetCommitId() string {
return ""
}
func (m *ListBranchNamesContainingCommitRequest) GetLimit() uint32 {
if m != nil {
return m.Limit
}
return 0
}
type ListBranchNamesContainingCommitResponse struct {
BranchNames [][]byte `protobuf:"bytes,2,rep,name=branch_names,json=branchNames,proto3" json:"branch_names,omitempty"`
}
......@@ -703,6 +730,9 @@ func (m *ListBranchNamesContainingCommitResponse) GetBranchNames() [][]byte {
type ListTagNamesContainingCommitRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
// Limit the number of tag names to be returned
// If the limit is set to zero, all items will be returned
Limit uint32 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
}
func (m *ListTagNamesContainingCommitRequest) Reset() { *m = ListTagNamesContainingCommitRequest{} }
......@@ -726,6 +756,13 @@ func (m *ListTagNamesContainingCommitRequest) GetCommitId() string {
return ""
}
func (m *ListTagNamesContainingCommitRequest) GetLimit() uint32 {
if m != nil {
return m.Limit
}
return 0
}
type ListTagNamesContainingCommitResponse struct {
TagNames [][]byte `protobuf:"bytes,2,rep,name=tag_names,json=tagNames,proto3" json:"tag_names,omitempty"`
}
......@@ -805,8 +842,8 @@ type RefServiceClient interface {
DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*DeleteBranchResponse, error)
FindBranch(ctx context.Context, in *FindBranchRequest, opts ...grpc.CallOption) (*FindBranchResponse, error)
DeleteRefs(ctx context.Context, in *DeleteRefsRequest, opts ...grpc.CallOption) (*DeleteRefsResponse, error)
ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListBranchNamesContainingCommitResponse, error)
ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListTagNamesContainingCommitResponse, error)
ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListBranchNamesContainingCommitClient, error)
ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListTagNamesContainingCommitClient, error)
}
type refServiceClient struct {
......@@ -1040,22 +1077,68 @@ func (c *refServiceClient) DeleteRefs(ctx context.Context, in *DeleteRefsRequest
return out, nil
}
func (c *refServiceClient) ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListBranchNamesContainingCommitResponse, error) {
out := new(ListBranchNamesContainingCommitResponse)
err := grpc.Invoke(ctx, "/gitaly.RefService/ListBranchNamesContainingCommit", in, out, c.cc, opts...)
func (c *refServiceClient) ListBranchNamesContainingCommit(ctx context.Context, in *ListBranchNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListBranchNamesContainingCommitClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[5], c.cc, "/gitaly.RefService/ListBranchNamesContainingCommit", opts...)
if err != nil {
return nil, err
}
return out, nil
x := &refServiceListBranchNamesContainingCommitClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type RefService_ListBranchNamesContainingCommitClient interface {
Recv() (*ListBranchNamesContainingCommitResponse, error)
grpc.ClientStream
}
type refServiceListBranchNamesContainingCommitClient struct {
grpc.ClientStream
}
func (x *refServiceListBranchNamesContainingCommitClient) Recv() (*ListBranchNamesContainingCommitResponse, error) {
m := new(ListBranchNamesContainingCommitResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *refServiceClient) ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (*ListTagNamesContainingCommitResponse, error) {
out := new(ListTagNamesContainingCommitResponse)
err := grpc.Invoke(ctx, "/gitaly.RefService/ListTagNamesContainingCommit", in, out, c.cc, opts...)
func (c *refServiceClient) ListTagNamesContainingCommit(ctx context.Context, in *ListTagNamesContainingCommitRequest, opts ...grpc.CallOption) (RefService_ListTagNamesContainingCommitClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[6], c.cc, "/gitaly.RefService/ListTagNamesContainingCommit", opts...)
if err != nil {
return nil, err
}
return out, nil
x := &refServiceListTagNamesContainingCommitClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type RefService_ListTagNamesContainingCommitClient interface {
Recv() (*ListTagNamesContainingCommitResponse, error)
grpc.ClientStream
}
type refServiceListTagNamesContainingCommitClient struct {
grpc.ClientStream
}
func (x *refServiceListTagNamesContainingCommitClient) Recv() (*ListTagNamesContainingCommitResponse, error) {
m := new(ListTagNamesContainingCommitResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for RefService service
......@@ -1075,8 +1158,8 @@ type RefServiceServer interface {
DeleteBranch(context.Context, *DeleteBranchRequest) (*DeleteBranchResponse, error)
FindBranch(context.Context, *FindBranchRequest) (*FindBranchResponse, error)
DeleteRefs(context.Context, *DeleteRefsRequest) (*DeleteRefsResponse, error)
ListBranchNamesContainingCommit(context.Context, *ListBranchNamesContainingCommitRequest) (*ListBranchNamesContainingCommitResponse, error)
ListTagNamesContainingCommit(context.Context, *ListTagNamesContainingCommitRequest) (*ListTagNamesContainingCommitResponse, error)
ListBranchNamesContainingCommit(*ListBranchNamesContainingCommitRequest, RefService_ListBranchNamesContainingCommitServer) error
ListTagNamesContainingCommit(*ListTagNamesContainingCommitRequest, RefService_ListTagNamesContainingCommitServer) error
}
func RegisterRefServiceServer(s *grpc.Server, srv RefServiceServer) {
......@@ -1314,40 +1397,46 @@ func _RefService_DeleteRefs_Handler(srv interface{}, ctx context.Context, dec fu
return interceptor(ctx, in, info, handler)
}
func _RefService_ListBranchNamesContainingCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBranchNamesContainingCommitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RefServiceServer).ListBranchNamesContainingCommit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RefService/ListBranchNamesContainingCommit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RefServiceServer).ListBranchNamesContainingCommit(ctx, req.(*ListBranchNamesContainingCommitRequest))
func _RefService_ListBranchNamesContainingCommit_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ListBranchNamesContainingCommitRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return interceptor(ctx, in, info, handler)
return srv.(RefServiceServer).ListBranchNamesContainingCommit(m, &refServiceListBranchNamesContainingCommitServer{stream})
}
func _RefService_ListTagNamesContainingCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListTagNamesContainingCommitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RefServiceServer).ListTagNamesContainingCommit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RefService/ListTagNamesContainingCommit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RefServiceServer).ListTagNamesContainingCommit(ctx, req.(*ListTagNamesContainingCommitRequest))
type RefService_ListBranchNamesContainingCommitServer interface {
Send(*ListBranchNamesContainingCommitResponse) error
grpc.ServerStream
}
type refServiceListBranchNamesContainingCommitServer struct {
grpc.ServerStream
}
func (x *refServiceListBranchNamesContainingCommitServer) Send(m *ListBranchNamesContainingCommitResponse) error {
return x.ServerStream.SendMsg(m)
}
func _RefService_ListTagNamesContainingCommit_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ListTagNamesContainingCommitRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return interceptor(ctx, in, info, handler)
return srv.(RefServiceServer).ListTagNamesContainingCommit(m, &refServiceListTagNamesContainingCommitServer{stream})
}
type RefService_ListTagNamesContainingCommitServer interface {
Send(*ListTagNamesContainingCommitResponse) error
grpc.ServerStream
}
type refServiceListTagNamesContainingCommitServer struct {
grpc.ServerStream
}
func (x *refServiceListTagNamesContainingCommitServer) Send(m *ListTagNamesContainingCommitResponse) error {
return x.ServerStream.SendMsg(m)
}
var _RefService_serviceDesc = grpc.ServiceDesc{
......@@ -1382,14 +1471,6 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
MethodName: "DeleteRefs",
Handler: _RefService_DeleteRefs_Handler,
},
{
MethodName: "ListBranchNamesContainingCommit",
Handler: _RefService_ListBranchNamesContainingCommit_Handler,
},
{
MethodName: "ListTagNamesContainingCommit",
Handler: _RefService_ListTagNamesContainingCommit_Handler,
},
},
Streams: []grpc.StreamDesc{
{
......@@ -1417,6 +1498,16 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
Handler: _RefService_FindAllTags_Handler,
ServerStreams: true,
},
{
StreamName: "ListBranchNamesContainingCommit",
Handler: _RefService_ListBranchNamesContainingCommit_Handler,
ServerStreams: true,
},
{
StreamName: "ListTagNamesContainingCommit",
Handler: _RefService_ListTagNamesContainingCommit_Handler,
ServerStreams: true,
},
},
Metadata: "ref.proto",
}
......@@ -1424,82 +1515,85 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("ref.proto", fileDescriptor8) }
var fileDescriptor8 = []byte{
// 1218 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xdd, 0x72, 0x22, 0x45,
0x14, 0xce, 0x10, 0x16, 0xe1, 0x80, 0x64, 0xd2, 0x89, 0x59, 0x32, 0xc4, 0x25, 0xe9, 0xdd, 0xcd,
0x4f, 0xb9, 0x45, 0x2c, 0xb6, 0xf4, 0x46, 0x2f, 0x24, 0x80, 0x1b, 0x76, 0x23, 0x49, 0x35, 0xb8,
0xa6, 0x4a, 0xad, 0xa9, 0x01, 0x1a, 0x32, 0x16, 0x30, 0x38, 0xd3, 0x64, 0x43, 0x59, 0x7a, 0xe5,
0x9d, 0xf7, 0x3e, 0x82, 0xaf, 0xe2, 0x85, 0x4f, 0xe2, 0x5b, 0x58, 0x74, 0xf7, 0xfc, 0x40, 0x06,
0x92, 0x12, 0xe3, 0x15, 0xcc, 0xe9, 0x73, 0xbe, 0xd3, 0xe7, 0xa7, 0xbf, 0x73, 0x20, 0x61, 0xd3,
0x4e, 0x7e, 0x68, 0x5b, 0xcc, 0x42, 0xb1, 0xae, 0xc9, 0x8c, 0xde, 0x58, 0x4b, 0x39, 0x57, 0x86,
0x4d, 0xdb, 0x42, 0xaa, 0xe5, 0xba, 0x96, 0xd5, 0xed, 0xd1, 0x63, 0xfe, 0xd5, 0x1c, 0x75, 0x8e,
0x99, 0xd9, 0xa7, 0x0e, 0x33, 0xfa, 0x43, 0xa1, 0x80, 0x09, 0xec, 0x7c, 0x69, 0x0e, 0xda, 0x65,
0xda, 0x31, 0x46, 0x3d, 0x76, 0x62, 0x1b, 0x83, 0xd6, 0x55, 0xcd, 0xe8, 0x53, 0x42, 0x7f, 0x1c,
0x51, 0x87, 0xa1, 0x02, 0x80, 0x4d, 0x87, 0x96, 0x63, 0x32, 0xcb, 0x1e, 0x67, 0x94, 0x5d, 0xe5,
0x30, 0x59, 0x40, 0x79, 0xe1, 0x2b, 0x4f, 0xbc, 0x13, 0x12, 0xd0, 0xc2, 0x2f, 0xe1, 0xc3, 0x39,
0x98, 0xce, 0xd0, 0x1a, 0x38, 0x14, 0x21, 0x88, 0x0e, 0x8c, 0x3e, 0xe5, 0x70, 0x29, 0xc2, 0xff,
0xe3, 0x73, 0xd8, 0x9e, 0x18, 0x15, 0x7b, 0x3d, 0xdf, 0xc0, 0x59, 0xe6, 0x16, 0x05, 0xd0, 0xc2,
0x00, 0xe5, 0x15, 0x36, 0xe1, 0xd1, 0xc4, 0xad, 0x93, 0x51, 0x76, 0x57, 0x0f, 0x53, 0x44, 0x7c,
0xe0, 0x33, 0xd8, 0x92, 0x36, 0x0d, 0xa3, 0xbb, 0xf4, 0x0d, 0x8e, 0xe1, 0xf1, 0x2d, 0xb4, 0x85,
0xee, 0x7f, 0x06, 0x34, 0x31, 0x20, 0xb4, 0xb3, 0x64, 0x09, 0x50, 0x16, 0x12, 0x2d, 0xab, 0xdf,
0x37, 0x99, 0x6e, 0xb6, 0x33, 0x91, 0x5d, 0xe5, 0x30, 0x41, 0xe2, 0x42, 0x50, 0x6d, 0xa3, 0x2d,
0x88, 0x0d, 0x6d, 0xda, 0x31, 0x6f, 0x32, 0xab, 0xbc, 0x00, 0xf2, 0x0b, 0x1f, 0xc1, 0xc6, 0x94,
0xfb, 0x05, 0xd5, 0xfa, 0x53, 0x81, 0xcc, 0x44, 0xf7, 0xcc, 0x6a, 0x19, 0x32, 0xbf, 0x4b, 0xe5,
0x0a, 0x7d, 0x01, 0xef, 0x39, 0x96, 0xcd, 0xf4, 0xe6, 0x98, 0x5f, 0x37, 0x5d, 0x38, 0x70, 0x0d,
0xe6, 0xb9, 0xc9, 0xd7, 0x2d, 0x9b, 0x9d, 0x8c, 0x49, 0xcc, 0xe1, 0xbf, 0xf8, 0x13, 0x88, 0x09,
0x09, 0x8a, 0x43, 0xb4, 0x56, 0xfc, 0xaa, 0xa2, 0xae, 0xa0, 0x35, 0x48, 0x7e, 0x7d, 0x51, 0x2e,
0x36, 0x2a, 0x65, 0xbd, 0x58, 0x2f, 0xa9, 0x0a, 0x52, 0x21, 0xe5, 0x0a, 0xca, 0x95, 0x7a, 0x49,
0x8d, 0xe0, 0x4b, 0xd1, 0x77, 0x33, 0x1e, 0x64, 0xe8, 0x9f, 0x41, 0xbc, 0x29, 0x65, 0xbc, 0x52,
0xc9, 0x42, 0x6e, 0xce, 0xb5, 0x5c, 0x13, 0xe2, 0x19, 0xe0, 0xdf, 0x22, 0xa2, 0xfe, 0x21, 0x5a,
0x61, 0x39, 0x5d, 0x5c, 0xb3, 0xe7, 0x90, 0x96, 0x87, 0xce, 0xa8, 0xf9, 0x03, 0x6d, 0x31, 0x59,
0xbb, 0xf7, 0x85, 0xb4, 0x2e, 0x84, 0xe8, 0x14, 0xa4, 0x40, 0x37, 0x46, 0xec, 0xca, 0xb2, 0x33,
0x51, 0x9e, 0xfd, 0xa7, 0x73, 0x6e, 0x5d, 0xe2, 0xba, 0x45, 0xae, 0x4a, 0x52, 0xad, 0xc0, 0x17,
0xaa, 0x81, 0x2a, 0x91, 0xc4, 0x0f, 0xa3, 0x76, 0xe6, 0xd1, 0xfd, 0xc1, 0xd6, 0x84, 0x55, 0xc9,
0xb5, 0xc5, 0xef, 0x20, 0xbb, 0x40, 0x3f, 0x34, 0x21, 0x9b, 0xf0, 0x88, 0xf6, 0x0d, 0xb3, 0xc7,
0x93, 0x91, 0x22, 0xe2, 0x03, 0xe5, 0x21, 0xda, 0x36, 0x18, 0xe5, 0xf1, 0x27, 0x0b, 0x5a, 0x5e,
0x30, 0x5c, 0xde, 0x65, 0xb8, 0x7c, 0xc3, 0x65, 0x38, 0xc2, 0xf5, 0xf0, 0xef, 0x8a, 0xf7, 0xa8,
0xff, 0x8b, 0x46, 0xcd, 0x41, 0xb2, 0x4f, 0xed, 0x2e, 0x6d, 0xeb, 0xd6, 0xa0, 0x27, 0x9a, 0x35,
0x4e, 0x40, 0x88, 0xce, 0x07, 0xbd, 0x31, 0x3a, 0x80, 0x35, 0xa9, 0xe0, 0xb5, 0xce, 0x2a, 0x7f,
0xe4, 0x69, 0x21, 0x76, 0x2f, 0x81, 0xff, 0x50, 0x3c, 0x7e, 0xb8, 0xd5, 0x78, 0x27, 0xb7, 0x1a,
0x6f, 0x3f, 0x98, 0xf5, 0x10, 0x93, 0xbc, 0xec, 0x30, 0xcf, 0x4e, 0x7b, 0x05, 0x31, 0x21, 0x0b,
0x4d, 0xee, 0x11, 0xc4, 0x98, 0x61, 0x77, 0x29, 0xe3, 0x21, 0x24, 0x0b, 0xeb, 0x2e, 0xfe, 0x2b,
0xb7, 0x6a, 0x44, 0x2a, 0xe0, 0x53, 0x41, 0x4b, 0x82, 0xc7, 0x96, 0x62, 0xc4, 0x4f, 0x05, 0xc3,
0x78, 0x48, 0x32, 0xda, 0x1c, 0x44, 0x99, 0xd1, 0x75, 0x23, 0x4d, 0xba, 0x20, 0x0d, 0xa3, 0x4b,
0xf8, 0x01, 0xbe, 0x04, 0x95, 0xd0, 0x4e, 0xe5, 0xc6, 0x74, 0xd8, 0x52, 0xc5, 0x53, 0x61, 0xd5,
0xa6, 0x1d, 0xd9, 0x4f, 0x93, 0xbf, 0xf8, 0x08, 0xd6, 0x03, 0xc8, 0x3e, 0x3b, 0x5f, 0x1b, 0xbd,
0x91, 0x48, 0x58, 0x9c, 0x88, 0x0f, 0xfc, 0x0b, 0x6c, 0x94, 0x6c, 0x6a, 0x30, 0xea, 0xbe, 0xe5,
0x7f, 0x7f, 0x0f, 0xb7, 0x20, 0x91, 0x40, 0x41, 0x72, 0x90, 0x74, 0x98, 0x61, 0x33, 0x7d, 0x68,
0x99, 0x03, 0xf7, 0x79, 0x03, 0x17, 0x5d, 0x4c, 0x24, 0xf8, 0x2f, 0x05, 0x36, 0xa7, 0x2f, 0xe0,
0xb1, 0x54, 0xcc, 0x61, 0x06, 0x1b, 0x39, 0xdc, 0x7b, 0xda, 0x7f, 0xa0, 0x61, 0xda, 0xf9, 0x3a,
0x57, 0x25, 0xd2, 0x04, 0xed, 0x43, 0x4c, 0x74, 0x8c, 0xec, 0x83, 0xb4, 0x6b, 0x2c, 0xcd, 0xe4,
0x29, 0xae, 0x41, 0x4c, 0x58, 0xa2, 0x18, 0x44, 0xce, 0xdf, 0xa8, 0x2b, 0x28, 0x0d, 0x50, 0x21,
0x44, 0xaf, 0x5c, 0x56, 0xeb, 0x8d, 0xba, 0xaa, 0x4c, 0xc8, 0x76, 0xf2, 0x5d, 0xad, 0xbd, 0x2d,
0x9e, 0x55, 0xcb, 0x6a, 0x04, 0x65, 0xe1, 0x71, 0x40, 0xa0, 0xd7, 0x1b, 0x45, 0xd2, 0xd0, 0x2f,
0xce, 0xab, 0xb5, 0x86, 0xba, 0x8a, 0xbf, 0x87, 0x8d, 0x32, 0xed, 0xd1, 0x07, 0xca, 0x26, 0xde,
0x82, 0xcd, 0x69, 0x78, 0x11, 0x3d, 0xfe, 0x16, 0xd6, 0x27, 0x1d, 0xf8, 0x30, 0x4e, 0x3f, 0x17,
0x0f, 0x65, 0xa6, 0x3c, 0x7e, 0x86, 0x95, 0x85, 0x19, 0x1e, 0xc1, 0xba, 0xb8, 0x32, 0xa1, 0x9d,
0xa5, 0xba, 0xfc, 0x05, 0x20, 0x7a, 0xd3, 0xa2, 0x43, 0xa6, 0xbf, 0x33, 0xd9, 0x95, 0x2e, 0x67,
0x7d, 0x84, 0x93, 0x90, 0x2a, 0x4e, 0xbe, 0x31, 0xd9, 0xd5, 0x85, 0x98, 0xfa, 0x9b, 0x80, 0x82,
0x6e, 0x65, 0x9e, 0xc6, 0xb0, 0x7f, 0x66, 0x3a, 0x81, 0xe5, 0xcd, 0x29, 0x59, 0x03, 0x66, 0x98,
0x03, 0x73, 0xd0, 0x95, 0xf4, 0xf0, 0x40, 0xeb, 0x09, 0x26, 0x70, 0x70, 0xa7, 0x6b, 0x99, 0xda,
0x3d, 0x48, 0x89, 0xe4, 0xe9, 0x62, 0x9b, 0x12, 0x31, 0x26, 0x9b, 0xbe, 0xe9, 0xeb, 0x68, 0x5c,
0x51, 0x23, 0xf8, 0x1a, 0x9e, 0x4e, 0x30, 0xdd, 0x3d, 0xec, 0x7f, 0x8b, 0xa5, 0x0a, 0xcf, 0x16,
0xfb, 0x95, 0x81, 0x64, 0x21, 0xc1, 0x8c, 0xee, 0x54, 0x14, 0x71, 0x26, 0x8d, 0x44, 0x08, 0x85,
0xbf, 0x13, 0x00, 0x84, 0x76, 0xea, 0xd4, 0xbe, 0x36, 0x5b, 0x14, 0x75, 0xe0, 0x83, 0xd0, 0x25,
0x1b, 0x3d, 0x0b, 0x0e, 0x8a, 0x79, 0x7b, 0xbd, 0xf6, 0xfc, 0x0e, 0x2d, 0xd9, 0x06, 0x2b, 0x48,
0xf7, 0xc8, 0x3f, 0x50, 0x10, 0xb4, 0x17, 0x3a, 0x8d, 0x82, 0x1b, 0xb3, 0x86, 0x17, 0xa9, 0xb8,
0xf0, 0x1f, 0x2b, 0xe8, 0x2d, 0xac, 0xcd, 0x6c, 0xc9, 0xe8, 0xc9, 0x8c, 0xe9, 0xcc, 0x32, 0xae,
0xe5, 0xe6, 0x9e, 0x07, 0x70, 0x4f, 0x21, 0x19, 0xd8, 0x66, 0x91, 0x16, 0xb4, 0x99, 0xde, 0xb0,
0xb5, 0x6c, 0xe8, 0x99, 0x97, 0x82, 0xef, 0x04, 0x67, 0x4c, 0xad, 0x88, 0x68, 0xf7, 0xae, 0xfd,
0x54, 0xdb, 0x5b, 0xa0, 0x11, 0x1a, 0xbf, 0x87, 0xfd, 0x64, 0xee, 0xac, 0x0f, 0x8f, 0x3f, 0x14,
0xf7, 0xb5, 0x88, 0x5f, 0xce, 0xda, 0xe9, 0xf8, 0xa7, 0x47, 0xf9, 0x74, 0xfc, 0x33, 0xc3, 0x99,
0x63, 0x9d, 0x40, 0xc2, 0x9b, 0x92, 0x28, 0xe3, 0x3f, 0x88, 0xe9, 0x91, 0xac, 0x6d, 0x87, 0x9c,
0x78, 0x59, 0x7c, 0x03, 0xa9, 0xe0, 0x3c, 0x42, 0xd9, 0xf0, 0x29, 0x25, 0x90, 0x76, 0x16, 0x8d,
0x30, 0x01, 0x16, 0xa4, 0x77, 0x1f, 0x2c, 0x64, 0xa6, 0xf8, 0x60, 0xa1, 0x13, 0x61, 0x05, 0x55,
0x00, 0x7c, 0xda, 0x46, 0xdb, 0xc1, 0x64, 0x4c, 0x03, 0x69, 0x61, 0x47, 0x41, 0x18, 0x9f, 0x48,
0x7d, 0x98, 0x5b, 0x9c, 0xee, 0xc3, 0x84, 0xf0, 0xee, 0x0a, 0xfa, 0x55, 0x81, 0xdc, 0x1d, 0xfc,
0x87, 0xf2, 0x2e, 0xc2, 0xfd, 0x38, 0x5a, 0x3b, 0xbe, 0xb7, 0xbe, 0x77, 0x8d, 0x9f, 0x60, 0x67,
0x11, 0x73, 0xa1, 0x8f, 0x82, 0x90, 0x77, 0xf0, 0xaa, 0xf6, 0xe2, 0x7e, 0xca, 0xae, 0xf3, 0x66,
0x8c, 0x6f, 0xf3, 0x2f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x58, 0x18, 0xe8, 0x58, 0xe0, 0x10,
// 1266 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xdd, 0x6e, 0x1a, 0xc7,
0x17, 0xf7, 0x62, 0xcc, 0x1f, 0x0e, 0x04, 0xaf, 0x27, 0xfe, 0x27, 0x64, 0x49, 0x83, 0x33, 0xf9,
0xb4, 0x1a, 0xe1, 0x96, 0xa8, 0xbd, 0x69, 0x2f, 0x8a, 0x81, 0xc6, 0x24, 0x2e, 0xb6, 0x06, 0x9a,
0x5a, 0x6a, 0xab, 0xd5, 0x02, 0xc3, 0x7a, 0x2b, 0x60, 0xe9, 0xee, 0x90, 0xd8, 0x17, 0xe9, 0x65,
0xa5, 0xaa, 0x95, 0x7a, 0xd7, 0x47, 0xe8, 0xab, 0xf4, 0xa2, 0xcf, 0xd2, 0x77, 0xa8, 0x76, 0x66,
0xf6, 0x03, 0xbc, 0x60, 0xab, 0xd4, 0xea, 0x15, 0x3b, 0x67, 0xce, 0xf9, 0xcd, 0xf9, 0x98, 0xf9,
0x9d, 0x03, 0x64, 0x1c, 0x3a, 0x28, 0x4f, 0x1c, 0x9b, 0xd9, 0x28, 0x65, 0x5a, 0xcc, 0x18, 0x9e,
0x6b, 0x39, 0xf7, 0xd4, 0x70, 0x68, 0x5f, 0x48, 0xb5, 0x92, 0x69, 0xdb, 0xe6, 0x90, 0xee, 0xf1,
0x55, 0x77, 0x3a, 0xd8, 0x63, 0xd6, 0x88, 0xba, 0xcc, 0x18, 0x4d, 0x84, 0x02, 0x26, 0x70, 0xf7,
0x73, 0x6b, 0xdc, 0xaf, 0xd3, 0x81, 0x31, 0x1d, 0xb2, 0x7d, 0xc7, 0x18, 0xf7, 0x4e, 0x5b, 0xc6,
0x88, 0x12, 0xfa, 0xfd, 0x94, 0xba, 0x0c, 0x55, 0x00, 0x1c, 0x3a, 0xb1, 0x5d, 0x8b, 0xd9, 0xce,
0x79, 0x41, 0xd9, 0x51, 0x9e, 0x66, 0x2b, 0xa8, 0x2c, 0xce, 0x2a, 0x93, 0x60, 0x87, 0x44, 0xb4,
0xf0, 0x73, 0x78, 0x6f, 0x01, 0xa6, 0x3b, 0xb1, 0xc7, 0x2e, 0x45, 0x08, 0x92, 0x63, 0x63, 0x44,
0x39, 0x5c, 0x8e, 0xf0, 0x6f, 0x7c, 0x04, 0x77, 0x3c, 0xa3, 0xea, 0x70, 0x18, 0x1a, 0xb8, 0xab,
0x78, 0x51, 0x01, 0x2d, 0x0e, 0x50, 0xba, 0xb0, 0x0d, 0x1b, 0xde, 0xb1, 0x6e, 0x41, 0xd9, 0x59,
0x7f, 0x9a, 0x23, 0x62, 0x81, 0x0f, 0xe1, 0x96, 0xb4, 0xe9, 0x18, 0xe6, 0xca, 0x1e, 0xec, 0xc1,
0xed, 0x0b, 0x68, 0x4b, 0x8f, 0x7f, 0x07, 0xc8, 0x33, 0x20, 0x74, 0xb0, 0x62, 0x09, 0x50, 0x11,
0x32, 0x3d, 0x7b, 0x34, 0xb2, 0x98, 0x6e, 0xf5, 0x0b, 0x89, 0x1d, 0xe5, 0x69, 0x86, 0xa4, 0x85,
0xa0, 0xd9, 0x47, 0xb7, 0x20, 0x35, 0x71, 0xe8, 0xc0, 0x3a, 0x2b, 0xac, 0xf3, 0x02, 0xc8, 0x15,
0xde, 0x85, 0x9b, 0x33, 0xc7, 0x2f, 0xa9, 0xd6, 0x1f, 0x0a, 0x14, 0x3c, 0xdd, 0x43, 0xbb, 0x67,
0xc8, 0xfc, 0xae, 0x94, 0x2b, 0xf4, 0x19, 0xfc, 0xcf, 0xb5, 0x1d, 0xa6, 0x77, 0xcf, 0xb9, 0xbb,
0xf9, 0xca, 0x13, 0xdf, 0x60, 0xd1, 0x31, 0xe5, 0xb6, 0xed, 0xb0, 0xfd, 0x73, 0x92, 0x72, 0xf9,
0x2f, 0xfe, 0x08, 0x52, 0x42, 0x82, 0xd2, 0x90, 0x6c, 0x55, 0xbf, 0x68, 0xa8, 0x6b, 0x68, 0x13,
0xb2, 0x5f, 0x1e, 0xd7, 0xab, 0x9d, 0x46, 0x5d, 0xaf, 0xb6, 0x6b, 0xaa, 0x82, 0x54, 0xc8, 0xf9,
0x82, 0x7a, 0xa3, 0x5d, 0x53, 0x13, 0xf8, 0x44, 0xdc, 0xbb, 0xb9, 0x13, 0x64, 0xe8, 0x9f, 0x40,
0xba, 0x2b, 0x65, 0xbc, 0x52, 0xd9, 0x4a, 0x69, 0x81, 0x5b, 0xbe, 0x09, 0x09, 0x0c, 0xf0, 0xcf,
0x09, 0x51, 0xff, 0x18, 0xad, 0xb8, 0x9c, 0x2e, 0xaf, 0xd9, 0x23, 0xc8, 0xcb, 0x4d, 0x77, 0xda,
0xfd, 0x8e, 0xf6, 0x98, 0xac, 0xdd, 0x0d, 0x21, 0x6d, 0x0b, 0x21, 0x3a, 0x00, 0x29, 0xd0, 0x8d,
0x29, 0x3b, 0xb5, 0x9d, 0x42, 0x92, 0x67, 0xff, 0xc1, 0x02, 0xaf, 0x6b, 0x5c, 0xb7, 0xca, 0x55,
0x49, 0xae, 0x17, 0x59, 0xa1, 0x16, 0xa8, 0x12, 0x49, 0xfc, 0x30, 0xea, 0x14, 0x36, 0xae, 0x0e,
0xb6, 0x29, 0xac, 0x6a, 0xbe, 0x2d, 0x7e, 0x0b, 0xc5, 0x25, 0xfa, 0xb1, 0x09, 0xd9, 0x86, 0x0d,
0x3a, 0x32, 0xac, 0x21, 0x4f, 0x46, 0x8e, 0x88, 0x05, 0x2a, 0x43, 0xb2, 0x6f, 0x30, 0xca, 0xe3,
0xcf, 0x56, 0xb4, 0xb2, 0x60, 0xb8, 0xb2, 0xcf, 0x70, 0xe5, 0x8e, 0xcf, 0x70, 0x84, 0xeb, 0xe1,
0xdf, 0x94, 0xe0, 0x51, 0xff, 0x1b, 0x17, 0xb5, 0x04, 0xd9, 0x11, 0x75, 0x4c, 0xda, 0xd7, 0xed,
0xf1, 0x50, 0x5c, 0xd6, 0x34, 0x01, 0x21, 0x3a, 0x1a, 0x0f, 0xcf, 0xd1, 0x13, 0xd8, 0x94, 0x0a,
0xc1, 0xd5, 0x59, 0xe7, 0x8f, 0x3c, 0x2f, 0xc4, 0xbe, 0x13, 0xf8, 0x77, 0x25, 0xe0, 0x87, 0x0b,
0x17, 0x6f, 0xff, 0xc2, 0xc5, 0x7b, 0x1c, 0xcd, 0x7a, 0x8c, 0x49, 0x59, 0xde, 0xb0, 0xc0, 0x4e,
0x7b, 0x01, 0x29, 0x21, 0x8b, 0x4d, 0xee, 0x2e, 0xa4, 0x98, 0xe1, 0x98, 0x94, 0xf1, 0x10, 0xb2,
0x95, 0x2d, 0x1f, 0xff, 0x85, 0x5f, 0x35, 0x22, 0x15, 0xf0, 0x81, 0xa0, 0x25, 0xc1, 0x63, 0x2b,
0x31, 0xe2, 0xc7, 0x82, 0x61, 0x02, 0x24, 0x19, 0x6d, 0x09, 0x92, 0xcc, 0x30, 0xfd, 0x48, 0xb3,
0x3e, 0x48, 0xc7, 0x30, 0x09, 0xdf, 0xc0, 0x27, 0xa0, 0x12, 0x3a, 0x68, 0x9c, 0x59, 0x2e, 0x5b,
0xa9, 0x78, 0x2a, 0xac, 0x3b, 0x74, 0x20, 0xef, 0x93, 0xf7, 0x89, 0x77, 0x61, 0x2b, 0x82, 0x1c,
0xb2, 0xf3, 0x1b, 0x63, 0x38, 0x15, 0x09, 0x4b, 0x13, 0xb1, 0xc0, 0x3f, 0xc0, 0xcd, 0x9a, 0x43,
0x0d, 0x46, 0xfd, 0xb7, 0xfc, 0xcf, 0xfd, 0xf0, 0x0b, 0x92, 0x88, 0x14, 0xa4, 0x04, 0x59, 0x97,
0x19, 0x0e, 0xd3, 0x27, 0xb6, 0x35, 0xf6, 0x9f, 0x37, 0x70, 0xd1, 0xb1, 0x27, 0xc1, 0x7f, 0x2a,
0xb0, 0x3d, 0xeb, 0x40, 0xc0, 0x52, 0x29, 0x97, 0x19, 0x6c, 0xea, 0xf2, 0xd3, 0xf3, 0xe1, 0x03,
0x8d, 0xd3, 0x2e, 0xb7, 0xb9, 0x2a, 0x91, 0x26, 0xe8, 0x31, 0xa4, 0xc4, 0x8d, 0x91, 0xf7, 0x20,
0xef, 0x1b, 0x4b, 0x33, 0xb9, 0x8b, 0x5b, 0x90, 0x12, 0x96, 0x28, 0x05, 0x89, 0xa3, 0x57, 0xea,
0x1a, 0xca, 0x03, 0x34, 0x08, 0xd1, 0x1b, 0x27, 0xcd, 0x76, 0xa7, 0xad, 0x2a, 0x1e, 0xd9, 0x7a,
0xeb, 0x66, 0xeb, 0x75, 0xf5, 0xb0, 0x59, 0x57, 0x13, 0xa8, 0x08, 0xb7, 0x23, 0x02, 0xbd, 0xdd,
0xa9, 0x92, 0x8e, 0x7e, 0x7c, 0xd4, 0x6c, 0x75, 0xd4, 0x75, 0xfc, 0x2d, 0xdc, 0xac, 0xd3, 0x21,
0xbd, 0xa6, 0x6c, 0xe2, 0x5b, 0xb0, 0x3d, 0x0b, 0x2f, 0xa2, 0xc7, 0x5f, 0xc3, 0x96, 0x77, 0x03,
0xaf, 0xe7, 0xd0, 0x4f, 0xc5, 0x43, 0x99, 0x2b, 0x4f, 0x98, 0x61, 0x65, 0x69, 0x86, 0x7f, 0x52,
0x60, 0x4b, 0xf8, 0x4c, 0xe8, 0x60, 0xa5, 0x6b, 0xfe, 0x0c, 0x10, 0x3d, 0xeb, 0xd1, 0x09, 0xd3,
0xdf, 0x5a, 0xec, 0x54, 0x97, 0xcd, 0x3e, 0xc1, 0x59, 0x48, 0x15, 0x3b, 0x5f, 0x59, 0xec, 0xf4,
0x98, 0xcb, 0xbd, 0x48, 0x1c, 0x3a, 0xf0, 0x59, 0x8a, 0x7f, 0xe3, 0x0f, 0x01, 0x45, 0x5d, 0x91,
0x91, 0x14, 0x21, 0x63, 0x5a, 0x4c, 0xa7, 0x8e, 0x63, 0x3b, 0xdc, 0x95, 0x0c, 0x49, 0x9b, 0x16,
0x6b, 0x78, 0x6b, 0xfc, 0xab, 0x02, 0x8f, 0x0f, 0x2d, 0x37, 0x32, 0xef, 0xb9, 0x35, 0x7b, 0xcc,
0x0c, 0x6b, 0x6c, 0x8d, 0x4d, 0xc9, 0x28, 0xd7, 0x35, 0xd1, 0x6c, 0xc3, 0xc6, 0xd0, 0x1a, 0x59,
0xe2, 0xd5, 0xdc, 0x20, 0x62, 0x81, 0x09, 0x3c, 0xb9, 0xd4, 0x21, 0x19, 0xd9, 0x7d, 0xc8, 0x89,
0x2a, 0xe8, 0x62, 0x2c, 0x13, 0xb9, 0xca, 0x76, 0x43, 0xd3, 0x97, 0xc9, 0xb4, 0xa2, 0x26, 0xf0,
0x2f, 0x0a, 0x3c, 0xf0, 0x40, 0xfd, 0x89, 0xee, 0x3f, 0x0e, 0xb1, 0x09, 0x0f, 0x97, 0x7b, 0x13,
0x56, 0x8e, 0x19, 0xe6, 0x4c, 0x70, 0x69, 0x26, 0x8d, 0x44, 0x64, 0x95, 0xbf, 0x32, 0x00, 0x84,
0x0e, 0xda, 0xd4, 0x79, 0x63, 0xf5, 0x28, 0x1a, 0xc0, 0xff, 0x63, 0x87, 0x78, 0xf4, 0x30, 0xda,
0x88, 0x16, 0xfd, 0x6f, 0xd0, 0x1e, 0x5d, 0xa2, 0x25, 0x9f, 0xe3, 0x1a, 0xd2, 0x83, 0xe6, 0x12,
0xa9, 0x13, 0xba, 0x1f, 0xdb, 0xed, 0xa2, 0x13, 0xb9, 0x86, 0x97, 0xa9, 0xf8, 0xf0, 0x1f, 0x28,
0xe8, 0x35, 0x6c, 0xce, 0x4d, 0xe1, 0xe8, 0xde, 0x9c, 0xe9, 0xdc, 0xb0, 0xaf, 0x95, 0x16, 0xee,
0x47, 0x70, 0x0f, 0x20, 0x1b, 0x99, 0x96, 0x91, 0x16, 0xb5, 0x99, 0x9d, 0xe0, 0xb5, 0x62, 0xec,
0x5e, 0x90, 0x82, 0x6f, 0x04, 0x27, 0xcd, 0x8c, 0xa0, 0x68, 0xe7, 0xb2, 0xf9, 0x57, 0xbb, 0xbf,
0x44, 0x23, 0x36, 0xfe, 0x00, 0xfb, 0xde, 0xc2, 0x59, 0x22, 0x3e, 0xfe, 0x58, 0xdc, 0x97, 0x22,
0x7e, 0xd9, 0xcb, 0x67, 0xe3, 0x9f, 0x1d, 0x15, 0x66, 0xe3, 0x9f, 0x6b, 0xfe, 0x1c, 0x6b, 0x1f,
0x32, 0x41, 0x17, 0x46, 0x85, 0xf0, 0x99, 0xcc, 0xb6, 0x7c, 0xed, 0x4e, 0xcc, 0x4e, 0x90, 0xc5,
0x57, 0x90, 0x8b, 0xf6, 0x3b, 0x54, 0x8c, 0xef, 0x82, 0x02, 0xe9, 0xee, 0xb2, 0x16, 0x29, 0xc0,
0xa2, 0xed, 0x23, 0x04, 0x8b, 0xe9, 0x59, 0x21, 0x58, 0x6c, 0xc7, 0x59, 0x43, 0x0d, 0x80, 0xb0,
0x2d, 0xa0, 0x3b, 0xd1, 0x64, 0xcc, 0x02, 0x69, 0x71, 0x5b, 0x51, 0x98, 0x90, 0x93, 0x43, 0x98,
0x0b, 0x2d, 0x23, 0x84, 0xb9, 0x48, 0xe1, 0x78, 0x0d, 0xfd, 0xa8, 0x40, 0xe9, 0x12, 0x5a, 0x44,
0x65, 0x1f, 0xe1, 0x6a, 0x84, 0xae, 0xed, 0x5d, 0x59, 0x3f, 0x52, 0xf4, 0x77, 0x70, 0x77, 0x19,
0x77, 0xa1, 0xf7, 0xa3, 0xa0, 0x97, 0xf0, 0xad, 0xf6, 0xec, 0x6a, 0xca, 0xe1, 0xf1, 0xdd, 0x14,
0xff, 0xc7, 0xf0, 0xfc, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0xfb, 0x20, 0x30, 0x44, 0x11,
0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go
View file @ 27bdba30
......@@ -43,7 +43,7 @@ func (x GetArchiveRequest_Format) String() string {
return proto.EnumName(GetArchiveRequest_Format_name, int32(x))
}
func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) {
return fileDescriptor10, []int{18, 0}
return fileDescriptor10, []int{16, 0}
}
type RepositoryExistsRequest struct {
......@@ -78,38 +78,6 @@ func (m *RepositoryExistsResponse) GetExists() bool {
return false
}
type RepositoryIsEmptyRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
}
func (m *RepositoryIsEmptyRequest) Reset() { *m = RepositoryIsEmptyRequest{} }
func (m *RepositoryIsEmptyRequest) String() string { return proto.CompactTextString(m) }
func (*RepositoryIsEmptyRequest) ProtoMessage() {}
func (*RepositoryIsEmptyRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
func (m *RepositoryIsEmptyRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
type RepositoryIsEmptyResponse struct {
IsEmpty bool `protobuf:"varint,1,opt,name=is_empty,json=isEmpty" json:"is_empty,omitempty"`
}
func (m *RepositoryIsEmptyResponse) Reset() { *m = RepositoryIsEmptyResponse{} }
func (m *RepositoryIsEmptyResponse) String() string { return proto.CompactTextString(m) }
func (*RepositoryIsEmptyResponse) ProtoMessage() {}
func (*RepositoryIsEmptyResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
func (m *RepositoryIsEmptyResponse) GetIsEmpty() bool {
if m != nil {
return m.IsEmpty
}
return false
}
type RepackIncrementalRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
}
......@@ -117,7 +85,7 @@ type RepackIncrementalRequest struct {
func (m *RepackIncrementalRequest) Reset() { *m = RepackIncrementalRequest{} }
func (m *RepackIncrementalRequest) String() string { return proto.CompactTextString(m) }
func (*RepackIncrementalRequest) ProtoMessage() {}
func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{4} }
func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
func (m *RepackIncrementalRequest) GetRepository() *Repository {
if m != nil {
......@@ -132,7 +100,7 @@ type RepackIncrementalResponse struct {
func (m *RepackIncrementalResponse) Reset() { *m = RepackIncrementalResponse{} }
func (m *RepackIncrementalResponse) String() string { return proto.CompactTextString(m) }
func (*RepackIncrementalResponse) ProtoMessage() {}
func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{5} }
func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
type RepackFullRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -142,7 +110,7 @@ type RepackFullRequest struct {
func (m *RepackFullRequest) Reset() { *m = RepackFullRequest{} }
func (m *RepackFullRequest) String() string { return proto.CompactTextString(m) }
func (*RepackFullRequest) ProtoMessage() {}
func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{6} }
func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{4} }
func (m *RepackFullRequest) GetRepository() *Repository {
if m != nil {
......@@ -164,7 +132,7 @@ type RepackFullResponse struct {
func (m *RepackFullResponse) Reset() { *m = RepackFullResponse{} }
func (m *RepackFullResponse) String() string { return proto.CompactTextString(m) }
func (*RepackFullResponse) ProtoMessage() {}
func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{7} }
func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{5} }
type GarbageCollectRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -174,7 +142,7 @@ type GarbageCollectRequest struct {
func (m *GarbageCollectRequest) Reset() { *m = GarbageCollectRequest{} }
func (m *GarbageCollectRequest) String() string { return proto.CompactTextString(m) }
func (*GarbageCollectRequest) ProtoMessage() {}
func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{8} }
func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{6} }
func (m *GarbageCollectRequest) GetRepository() *Repository {
if m != nil {
......@@ -196,7 +164,7 @@ type GarbageCollectResponse struct {
func (m *GarbageCollectResponse) Reset() { *m = GarbageCollectResponse{} }
func (m *GarbageCollectResponse) String() string { return proto.CompactTextString(m) }
func (*GarbageCollectResponse) ProtoMessage() {}
func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{9} }
func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{7} }
type RepositorySizeRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -205,7 +173,7 @@ type RepositorySizeRequest struct {
func (m *RepositorySizeRequest) Reset() { *m = RepositorySizeRequest{} }
func (m *RepositorySizeRequest) String() string { return proto.CompactTextString(m) }
func (*RepositorySizeRequest) ProtoMessage() {}
func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{10} }
func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{8} }
func (m *RepositorySizeRequest) GetRepository() *Repository {
if m != nil {
......@@ -222,7 +190,7 @@ type RepositorySizeResponse struct {
func (m *RepositorySizeResponse) Reset() { *m = RepositorySizeResponse{} }
func (m *RepositorySizeResponse) String() string { return proto.CompactTextString(m) }
func (*RepositorySizeResponse) ProtoMessage() {}
func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{11} }
func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{9} }
func (m *RepositorySizeResponse) GetSize() int64 {
if m != nil {
......@@ -239,7 +207,7 @@ type ApplyGitattributesRequest struct {
func (m *ApplyGitattributesRequest) Reset() { *m = ApplyGitattributesRequest{} }
func (m *ApplyGitattributesRequest) String() string { return proto.CompactTextString(m) }
func (*ApplyGitattributesRequest) ProtoMessage() {}
func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{12} }
func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{10} }
func (m *ApplyGitattributesRequest) GetRepository() *Repository {
if m != nil {
......@@ -261,7 +229,7 @@ type ApplyGitattributesResponse struct {
func (m *ApplyGitattributesResponse) Reset() { *m = ApplyGitattributesResponse{} }
func (m *ApplyGitattributesResponse) String() string { return proto.CompactTextString(m) }
func (*ApplyGitattributesResponse) ProtoMessage() {}
func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{13} }
func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{11} }
type FetchRemoteRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -271,12 +239,13 @@ type FetchRemoteRequest struct {
Timeout int32 `protobuf:"varint,5,opt,name=timeout" json:"timeout,omitempty"`
SshKey string `protobuf:"bytes,6,opt,name=ssh_key,json=sshKey" json:"ssh_key,omitempty"`
KnownHosts string `protobuf:"bytes,7,opt,name=known_hosts,json=knownHosts" json:"known_hosts,omitempty"`
NoPrune bool `protobuf:"varint,9,opt,name=no_prune,json=noPrune" json:"no_prune,omitempty"`
}
func (m *FetchRemoteRequest) Reset() { *m = FetchRemoteRequest{} }
func (m *FetchRemoteRequest) String() string { return proto.CompactTextString(m) }
func (*FetchRemoteRequest) ProtoMessage() {}
func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{14} }
func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{12} }
func (m *FetchRemoteRequest) GetRepository() *Repository {
if m != nil {
......@@ -327,13 +296,20 @@ func (m *FetchRemoteRequest) GetKnownHosts() string {
return ""
}
func (m *FetchRemoteRequest) GetNoPrune() bool {
if m != nil {
return m.NoPrune
}
return false
}
type FetchRemoteResponse struct {
}
func (m *FetchRemoteResponse) Reset() { *m = FetchRemoteResponse{} }
func (m *FetchRemoteResponse) String() string { return proto.CompactTextString(m) }
func (*FetchRemoteResponse) ProtoMessage() {}
func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{15} }
func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{13} }
type CreateRepositoryRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -342,7 +318,7 @@ type CreateRepositoryRequest struct {
func (m *CreateRepositoryRequest) Reset() { *m = CreateRepositoryRequest{} }
func (m *CreateRepositoryRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryRequest) ProtoMessage() {}
func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{16} }
func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{14} }
func (m *CreateRepositoryRequest) GetRepository() *Repository {
if m != nil {
......@@ -357,7 +333,7 @@ type CreateRepositoryResponse struct {
func (m *CreateRepositoryResponse) Reset() { *m = CreateRepositoryResponse{} }
func (m *CreateRepositoryResponse) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryResponse) ProtoMessage() {}
func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{17} }
func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{15} }
type GetArchiveRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -369,7 +345,7 @@ type GetArchiveRequest struct {
func (m *GetArchiveRequest) Reset() { *m = GetArchiveRequest{} }
func (m *GetArchiveRequest) String() string { return proto.CompactTextString(m) }
func (*GetArchiveRequest) ProtoMessage() {}
func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{18} }
func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{16} }
func (m *GetArchiveRequest) GetRepository() *Repository {
if m != nil {
......@@ -406,7 +382,7 @@ type GetArchiveResponse struct {
func (m *GetArchiveResponse) Reset() { *m = GetArchiveResponse{} }
func (m *GetArchiveResponse) String() string { return proto.CompactTextString(m) }
func (*GetArchiveResponse) ProtoMessage() {}
func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{19} }
func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{17} }
func (m *GetArchiveResponse) GetData() []byte {
if m != nil {
......@@ -422,7 +398,7 @@ type HasLocalBranchesRequest struct {
func (m *HasLocalBranchesRequest) Reset() { *m = HasLocalBranchesRequest{} }
func (m *HasLocalBranchesRequest) String() string { return proto.CompactTextString(m) }
func (*HasLocalBranchesRequest) ProtoMessage() {}
func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{20} }
func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{18} }
func (m *HasLocalBranchesRequest) GetRepository() *Repository {
if m != nil {
......@@ -438,7 +414,7 @@ type HasLocalBranchesResponse struct {
func (m *HasLocalBranchesResponse) Reset() { *m = HasLocalBranchesResponse{} }
func (m *HasLocalBranchesResponse) String() string { return proto.CompactTextString(m) }
func (*HasLocalBranchesResponse) ProtoMessage() {}
func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{21} }
func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{19} }
func (m *HasLocalBranchesResponse) GetValue() bool {
if m != nil {
......@@ -457,7 +433,7 @@ type FetchSourceBranchRequest struct {
func (m *FetchSourceBranchRequest) Reset() { *m = FetchSourceBranchRequest{} }
func (m *FetchSourceBranchRequest) String() string { return proto.CompactTextString(m) }
func (*FetchSourceBranchRequest) ProtoMessage() {}
func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{22} }
func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{20} }
func (m *FetchSourceBranchRequest) GetRepository() *Repository {
if m != nil {
......@@ -494,7 +470,7 @@ type FetchSourceBranchResponse struct {
func (m *FetchSourceBranchResponse) Reset() { *m = FetchSourceBranchResponse{} }
func (m *FetchSourceBranchResponse) String() string { return proto.CompactTextString(m) }
func (*FetchSourceBranchResponse) ProtoMessage() {}
func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{23} }
func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{21} }
func (m *FetchSourceBranchResponse) GetResult() bool {
if m != nil {
......@@ -510,7 +486,7 @@ type FsckRequest struct {
func (m *FsckRequest) Reset() { *m = FsckRequest{} }
func (m *FsckRequest) String() string { return proto.CompactTextString(m) }
func (*FsckRequest) ProtoMessage() {}
func (*FsckRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{24} }
func (*FsckRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{22} }
func (m *FsckRequest) GetRepository() *Repository {
if m != nil {
......@@ -526,7 +502,7 @@ type FsckResponse struct {
func (m *FsckResponse) Reset() { *m = FsckResponse{} }
func (m *FsckResponse) String() string { return proto.CompactTextString(m) }
func (*FsckResponse) ProtoMessage() {}
func (*FsckResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{25} }
func (*FsckResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{23} }
func (m *FsckResponse) GetError() []byte {
if m != nil {
......@@ -547,7 +523,7 @@ type WriteRefRequest struct {
func (m *WriteRefRequest) Reset() { *m = WriteRefRequest{} }
func (m *WriteRefRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRefRequest) ProtoMessage() {}
func (*WriteRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{26} }
func (*WriteRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{24} }
func (m *WriteRefRequest) GetRepository() *Repository {
if m != nil {
......@@ -598,7 +574,7 @@ type WriteRefResponse struct {
func (m *WriteRefResponse) Reset() { *m = WriteRefResponse{} }
func (m *WriteRefResponse) String() string { return proto.CompactTextString(m) }
func (*WriteRefResponse) ProtoMessage() {}
func (*WriteRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{27} }
func (*WriteRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{25} }
func (m *WriteRefResponse) GetError() []byte {
if m != nil {
......@@ -618,7 +594,7 @@ type FindMergeBaseRequest struct {
func (m *FindMergeBaseRequest) Reset() { *m = FindMergeBaseRequest{} }
func (m *FindMergeBaseRequest) String() string { return proto.CompactTextString(m) }
func (*FindMergeBaseRequest) ProtoMessage() {}
func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{28} }
func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{26} }
func (m *FindMergeBaseRequest) GetRepository() *Repository {
if m != nil {
......@@ -641,7 +617,7 @@ type FindMergeBaseResponse struct {
func (m *FindMergeBaseResponse) Reset() { *m = FindMergeBaseResponse{} }
func (m *FindMergeBaseResponse) String() string { return proto.CompactTextString(m) }
func (*FindMergeBaseResponse) ProtoMessage() {}
func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{29} }
func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{27} }
func (m *FindMergeBaseResponse) GetBase() string {
if m != nil {
......@@ -658,7 +634,7 @@ type CreateForkRequest struct {
func (m *CreateForkRequest) Reset() { *m = CreateForkRequest{} }
func (m *CreateForkRequest) String() string { return proto.CompactTextString(m) }
func (*CreateForkRequest) ProtoMessage() {}
func (*CreateForkRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{30} }
func (*CreateForkRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{28} }
func (m *CreateForkRequest) GetRepository() *Repository {
if m != nil {
......@@ -680,7 +656,7 @@ type CreateForkResponse struct {
func (m *CreateForkResponse) Reset() { *m = CreateForkResponse{} }
func (m *CreateForkResponse) String() string { return proto.CompactTextString(m) }
func (*CreateForkResponse) ProtoMessage() {}
func (*CreateForkResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{31} }
func (*CreateForkResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{29} }
type IsRebaseInProgressRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -690,7 +666,7 @@ type IsRebaseInProgressRequest struct {
func (m *IsRebaseInProgressRequest) Reset() { *m = IsRebaseInProgressRequest{} }
func (m *IsRebaseInProgressRequest) String() string { return proto.CompactTextString(m) }
func (*IsRebaseInProgressRequest) ProtoMessage() {}
func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{32} }
func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{30} }
func (m *IsRebaseInProgressRequest) GetRepository() *Repository {
if m != nil {
......@@ -713,7 +689,7 @@ type IsRebaseInProgressResponse struct {
func (m *IsRebaseInProgressResponse) Reset() { *m = IsRebaseInProgressResponse{} }
func (m *IsRebaseInProgressResponse) String() string { return proto.CompactTextString(m) }
func (*IsRebaseInProgressResponse) ProtoMessage() {}
func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{33} }
func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{31} }
func (m *IsRebaseInProgressResponse) GetInProgress() bool {
if m != nil {
......@@ -722,6 +698,46 @@ func (m *IsRebaseInProgressResponse) GetInProgress() bool {
return false
}
type IsSquashInProgressRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
SquashId string `protobuf:"bytes,2,opt,name=squash_id,json=squashId" json:"squash_id,omitempty"`
}
func (m *IsSquashInProgressRequest) Reset() { *m = IsSquashInProgressRequest{} }
func (m *IsSquashInProgressRequest) String() string { return proto.CompactTextString(m) }
func (*IsSquashInProgressRequest) ProtoMessage() {}
func (*IsSquashInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{32} }
func (m *IsSquashInProgressRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *IsSquashInProgressRequest) GetSquashId() string {
if m != nil {
return m.SquashId
}
return ""
}
type IsSquashInProgressResponse struct {
InProgress bool `protobuf:"varint,1,opt,name=in_progress,json=inProgress" json:"in_progress,omitempty"`
}
func (m *IsSquashInProgressResponse) Reset() { *m = IsSquashInProgressResponse{} }
func (m *IsSquashInProgressResponse) String() string { return proto.CompactTextString(m) }
func (*IsSquashInProgressResponse) ProtoMessage() {}
func (*IsSquashInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{33} }
func (m *IsSquashInProgressResponse) GetInProgress() bool {
if m != nil {
return m.InProgress
}
return false
}
type CreateRepositoryFromURLRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Url string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"`
......@@ -758,11 +774,150 @@ func (*CreateRepositoryFromURLResponse) Descriptor() ([]byte, []int) {
return fileDescriptor10, []int{35}
}
type CreateBundleRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
}
func (m *CreateBundleRequest) Reset() { *m = CreateBundleRequest{} }
func (m *CreateBundleRequest) String() string { return proto.CompactTextString(m) }
func (*CreateBundleRequest) ProtoMessage() {}
func (*CreateBundleRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{36} }
func (m *CreateBundleRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
type CreateBundleResponse struct {
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *CreateBundleResponse) Reset() { *m = CreateBundleResponse{} }
func (m *CreateBundleResponse) String() string { return proto.CompactTextString(m) }
func (*CreateBundleResponse) ProtoMessage() {}
func (*CreateBundleResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{37} }
func (m *CreateBundleResponse) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type WriteConfigRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
FullPath string `protobuf:"bytes,2,opt,name=full_path,json=fullPath" json:"full_path,omitempty"`
}
func (m *WriteConfigRequest) Reset() { *m = WriteConfigRequest{} }
func (m *WriteConfigRequest) String() string { return proto.CompactTextString(m) }
func (*WriteConfigRequest) ProtoMessage() {}
func (*WriteConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{38} }
func (m *WriteConfigRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *WriteConfigRequest) GetFullPath() string {
if m != nil {
return m.FullPath
}
return ""
}
type WriteConfigResponse struct {
Error []byte `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}
func (m *WriteConfigResponse) Reset() { *m = WriteConfigResponse{} }
func (m *WriteConfigResponse) String() string { return proto.CompactTextString(m) }
func (*WriteConfigResponse) ProtoMessage() {}
func (*WriteConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{39} }
func (m *WriteConfigResponse) GetError() []byte {
if m != nil {
return m.Error
}
return nil
}
type CreateRepositoryFromBundleRequest struct {
// Only available on the first message
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *CreateRepositoryFromBundleRequest) Reset() { *m = CreateRepositoryFromBundleRequest{} }
func (m *CreateRepositoryFromBundleRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryFromBundleRequest) ProtoMessage() {}
func (*CreateRepositoryFromBundleRequest) Descriptor() ([]byte, []int) {
return fileDescriptor10, []int{40}
}
func (m *CreateRepositoryFromBundleRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *CreateRepositoryFromBundleRequest) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type CreateRepositoryFromBundleResponse struct {
}
func (m *CreateRepositoryFromBundleResponse) Reset() { *m = CreateRepositoryFromBundleResponse{} }
func (m *CreateRepositoryFromBundleResponse) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryFromBundleResponse) ProtoMessage() {}
func (*CreateRepositoryFromBundleResponse) Descriptor() ([]byte, []int) {
return fileDescriptor10, []int{41}
}
type FindLicenseRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
}
func (m *FindLicenseRequest) Reset() { *m = FindLicenseRequest{} }
func (m *FindLicenseRequest) String() string { return proto.CompactTextString(m) }
func (*FindLicenseRequest) ProtoMessage() {}
func (*FindLicenseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{42} }
func (m *FindLicenseRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
type FindLicenseResponse struct {
LicenseShortName string `protobuf:"bytes,1,opt,name=license_short_name,json=licenseShortName" json:"license_short_name,omitempty"`
}
func (m *FindLicenseResponse) Reset() { *m = FindLicenseResponse{} }
func (m *FindLicenseResponse) String() string { return proto.CompactTextString(m) }
func (*FindLicenseResponse) ProtoMessage() {}
func (*FindLicenseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{43} }
func (m *FindLicenseResponse) GetLicenseShortName() string {
if m != nil {
return m.LicenseShortName
}
return ""
}
func init() {
proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse")
proto.RegisterType((*RepositoryIsEmptyRequest)(nil), "gitaly.RepositoryIsEmptyRequest")
proto.RegisterType((*RepositoryIsEmptyResponse)(nil), "gitaly.RepositoryIsEmptyResponse")
proto.RegisterType((*RepackIncrementalRequest)(nil), "gitaly.RepackIncrementalRequest")
proto.RegisterType((*RepackIncrementalResponse)(nil), "gitaly.RepackIncrementalResponse")
proto.RegisterType((*RepackFullRequest)(nil), "gitaly.RepackFullRequest")
......@@ -793,8 +948,18 @@ func init() {
proto.RegisterType((*CreateForkResponse)(nil), "gitaly.CreateForkResponse")
proto.RegisterType((*IsRebaseInProgressRequest)(nil), "gitaly.IsRebaseInProgressRequest")
proto.RegisterType((*IsRebaseInProgressResponse)(nil), "gitaly.IsRebaseInProgressResponse")
proto.RegisterType((*IsSquashInProgressRequest)(nil), "gitaly.IsSquashInProgressRequest")
proto.RegisterType((*IsSquashInProgressResponse)(nil), "gitaly.IsSquashInProgressResponse")
proto.RegisterType((*CreateRepositoryFromURLRequest)(nil), "gitaly.CreateRepositoryFromURLRequest")
proto.RegisterType((*CreateRepositoryFromURLResponse)(nil), "gitaly.CreateRepositoryFromURLResponse")
proto.RegisterType((*CreateBundleRequest)(nil), "gitaly.CreateBundleRequest")
proto.RegisterType((*CreateBundleResponse)(nil), "gitaly.CreateBundleResponse")
proto.RegisterType((*WriteConfigRequest)(nil), "gitaly.WriteConfigRequest")
proto.RegisterType((*WriteConfigResponse)(nil), "gitaly.WriteConfigResponse")
proto.RegisterType((*CreateRepositoryFromBundleRequest)(nil), "gitaly.CreateRepositoryFromBundleRequest")
proto.RegisterType((*CreateRepositoryFromBundleResponse)(nil), "gitaly.CreateRepositoryFromBundleResponse")
proto.RegisterType((*FindLicenseRequest)(nil), "gitaly.FindLicenseRequest")
proto.RegisterType((*FindLicenseResponse)(nil), "gitaly.FindLicenseResponse")
proto.RegisterEnum("gitaly.GetArchiveRequest_Format", GetArchiveRequest_Format_name, GetArchiveRequest_Format_value)
}
......@@ -810,7 +975,6 @@ const _ = grpc.SupportPackageIsVersion4
type RepositoryServiceClient interface {
RepositoryExists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error)
RepositoryIsEmpty(ctx context.Context, in *RepositoryIsEmptyRequest, opts ...grpc.CallOption) (*RepositoryIsEmptyResponse, error)
RepackIncremental(ctx context.Context, in *RepackIncrementalRequest, opts ...grpc.CallOption) (*RepackIncrementalResponse, error)
RepackFull(ctx context.Context, in *RepackFullRequest, opts ...grpc.CallOption) (*RepackFullResponse, error)
GarbageCollect(ctx context.Context, in *GarbageCollectRequest, opts ...grpc.CallOption) (*GarbageCollectResponse, error)
......@@ -826,7 +990,12 @@ type RepositoryServiceClient interface {
FindMergeBase(ctx context.Context, in *FindMergeBaseRequest, opts ...grpc.CallOption) (*FindMergeBaseResponse, error)
CreateFork(ctx context.Context, in *CreateForkRequest, opts ...grpc.CallOption) (*CreateForkResponse, error)
IsRebaseInProgress(ctx context.Context, in *IsRebaseInProgressRequest, opts ...grpc.CallOption) (*IsRebaseInProgressResponse, error)
IsSquashInProgress(ctx context.Context, in *IsSquashInProgressRequest, opts ...grpc.CallOption) (*IsSquashInProgressResponse, error)
CreateRepositoryFromURL(ctx context.Context, in *CreateRepositoryFromURLRequest, opts ...grpc.CallOption) (*CreateRepositoryFromURLResponse, error)
CreateBundle(ctx context.Context, in *CreateBundleRequest, opts ...grpc.CallOption) (RepositoryService_CreateBundleClient, error)
CreateRepositoryFromBundle(ctx context.Context, opts ...grpc.CallOption) (RepositoryService_CreateRepositoryFromBundleClient, error)
WriteConfig(ctx context.Context, in *WriteConfigRequest, opts ...grpc.CallOption) (*WriteConfigResponse, error)
FindLicense(ctx context.Context, in *FindLicenseRequest, opts ...grpc.CallOption) (*FindLicenseResponse, error)
}
type repositoryServiceClient struct {
......@@ -846,15 +1015,6 @@ func (c *repositoryServiceClient) RepositoryExists(ctx context.Context, in *Repo
return out, nil
}
func (c *repositoryServiceClient) RepositoryIsEmpty(ctx context.Context, in *RepositoryIsEmptyRequest, opts ...grpc.CallOption) (*RepositoryIsEmptyResponse, error) {
out := new(RepositoryIsEmptyResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/RepositoryIsEmpty", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *repositoryServiceClient) RepackIncremental(ctx context.Context, in *RepackIncrementalRequest, opts ...grpc.CallOption) (*RepackIncrementalResponse, error) {
out := new(RepackIncrementalResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/RepackIncremental", in, out, c.cc, opts...)
......@@ -1013,6 +1173,15 @@ func (c *repositoryServiceClient) IsRebaseInProgress(ctx context.Context, in *Is
return out, nil
}
func (c *repositoryServiceClient) IsSquashInProgress(ctx context.Context, in *IsSquashInProgressRequest, opts ...grpc.CallOption) (*IsSquashInProgressResponse, error) {
out := new(IsSquashInProgressResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/IsSquashInProgress", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *repositoryServiceClient) CreateRepositoryFromURL(ctx context.Context, in *CreateRepositoryFromURLRequest, opts ...grpc.CallOption) (*CreateRepositoryFromURLResponse, error) {
out := new(CreateRepositoryFromURLResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/CreateRepositoryFromURL", in, out, c.cc, opts...)
......@@ -1022,11 +1191,94 @@ func (c *repositoryServiceClient) CreateRepositoryFromURL(ctx context.Context, i
return out, nil
}
func (c *repositoryServiceClient) CreateBundle(ctx context.Context, in *CreateBundleRequest, opts ...grpc.CallOption) (RepositoryService_CreateBundleClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RepositoryService_serviceDesc.Streams[1], c.cc, "/gitaly.RepositoryService/CreateBundle", opts...)
if err != nil {
return nil, err
}
x := &repositoryServiceCreateBundleClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type RepositoryService_CreateBundleClient interface {
Recv() (*CreateBundleResponse, error)
grpc.ClientStream
}
type repositoryServiceCreateBundleClient struct {
grpc.ClientStream
}
func (x *repositoryServiceCreateBundleClient) Recv() (*CreateBundleResponse, error) {
m := new(CreateBundleResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *repositoryServiceClient) CreateRepositoryFromBundle(ctx context.Context, opts ...grpc.CallOption) (RepositoryService_CreateRepositoryFromBundleClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RepositoryService_serviceDesc.Streams[2], c.cc, "/gitaly.RepositoryService/CreateRepositoryFromBundle", opts...)
if err != nil {
return nil, err
}
x := &repositoryServiceCreateRepositoryFromBundleClient{stream}
return x, nil
}
type RepositoryService_CreateRepositoryFromBundleClient interface {
Send(*CreateRepositoryFromBundleRequest) error
CloseAndRecv() (*CreateRepositoryFromBundleResponse, error)
grpc.ClientStream
}
type repositoryServiceCreateRepositoryFromBundleClient struct {
grpc.ClientStream
}
func (x *repositoryServiceCreateRepositoryFromBundleClient) Send(m *CreateRepositoryFromBundleRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *repositoryServiceCreateRepositoryFromBundleClient) CloseAndRecv() (*CreateRepositoryFromBundleResponse, error) {
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
m := new(CreateRepositoryFromBundleResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *repositoryServiceClient) WriteConfig(ctx context.Context, in *WriteConfigRequest, opts ...grpc.CallOption) (*WriteConfigResponse, error) {
out := new(WriteConfigResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/WriteConfig", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *repositoryServiceClient) FindLicense(ctx context.Context, in *FindLicenseRequest, opts ...grpc.CallOption) (*FindLicenseResponse, error) {
out := new(FindLicenseResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/FindLicense", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for RepositoryService service
type RepositoryServiceServer interface {
RepositoryExists(context.Context, *RepositoryExistsRequest) (*RepositoryExistsResponse, error)
RepositoryIsEmpty(context.Context, *RepositoryIsEmptyRequest) (*RepositoryIsEmptyResponse, error)
RepackIncremental(context.Context, *RepackIncrementalRequest) (*RepackIncrementalResponse, error)
RepackFull(context.Context, *RepackFullRequest) (*RepackFullResponse, error)
GarbageCollect(context.Context, *GarbageCollectRequest) (*GarbageCollectResponse, error)
......@@ -1042,7 +1294,12 @@ type RepositoryServiceServer interface {
FindMergeBase(context.Context, *FindMergeBaseRequest) (*FindMergeBaseResponse, error)
CreateFork(context.Context, *CreateForkRequest) (*CreateForkResponse, error)
IsRebaseInProgress(context.Context, *IsRebaseInProgressRequest) (*IsRebaseInProgressResponse, error)
IsSquashInProgress(context.Context, *IsSquashInProgressRequest) (*IsSquashInProgressResponse, error)
CreateRepositoryFromURL(context.Context, *CreateRepositoryFromURLRequest) (*CreateRepositoryFromURLResponse, error)
CreateBundle(*CreateBundleRequest, RepositoryService_CreateBundleServer) error
CreateRepositoryFromBundle(RepositoryService_CreateRepositoryFromBundleServer) error
WriteConfig(context.Context, *WriteConfigRequest) (*WriteConfigResponse, error)
FindLicense(context.Context, *FindLicenseRequest) (*FindLicenseResponse, error)
}
func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
......@@ -1067,24 +1324,6 @@ func _RepositoryService_RepositoryExists_Handler(srv interface{}, ctx context.Co
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_RepositoryIsEmpty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RepositoryIsEmptyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).RepositoryIsEmpty(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RepositoryService/RepositoryIsEmpty",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).RepositoryIsEmpty(ctx, req.(*RepositoryIsEmptyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_RepackIncremental_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RepackIncrementalRequest)
if err := dec(in); err != nil {
......@@ -1358,6 +1597,24 @@ func _RepositoryService_IsRebaseInProgress_Handler(srv interface{}, ctx context.
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_IsSquashInProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(IsSquashInProgressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).IsSquashInProgress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RepositoryService/IsSquashInProgress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).IsSquashInProgress(ctx, req.(*IsSquashInProgressRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_CreateRepositoryFromURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRepositoryFromURLRequest)
if err := dec(in); err != nil {
......@@ -1376,6 +1633,89 @@ func _RepositoryService_CreateRepositoryFromURL_Handler(srv interface{}, ctx con
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_CreateBundle_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(CreateBundleRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(RepositoryServiceServer).CreateBundle(m, &repositoryServiceCreateBundleServer{stream})
}
type RepositoryService_CreateBundleServer interface {
Send(*CreateBundleResponse) error
grpc.ServerStream
}
type repositoryServiceCreateBundleServer struct {
grpc.ServerStream
}
func (x *repositoryServiceCreateBundleServer) Send(m *CreateBundleResponse) error {
return x.ServerStream.SendMsg(m)
}
func _RepositoryService_CreateRepositoryFromBundle_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(RepositoryServiceServer).CreateRepositoryFromBundle(&repositoryServiceCreateRepositoryFromBundleServer{stream})
}
type RepositoryService_CreateRepositoryFromBundleServer interface {
SendAndClose(*CreateRepositoryFromBundleResponse) error
Recv() (*CreateRepositoryFromBundleRequest, error)
grpc.ServerStream
}
type repositoryServiceCreateRepositoryFromBundleServer struct {
grpc.ServerStream
}
func (x *repositoryServiceCreateRepositoryFromBundleServer) SendAndClose(m *CreateRepositoryFromBundleResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *repositoryServiceCreateRepositoryFromBundleServer) Recv() (*CreateRepositoryFromBundleRequest, error) {
m := new(CreateRepositoryFromBundleRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _RepositoryService_WriteConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteConfigRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).WriteConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RepositoryService/WriteConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).WriteConfig(ctx, req.(*WriteConfigRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_FindLicense_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FindLicenseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).FindLicense(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RepositoryService/FindLicense",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).FindLicense(ctx, req.(*FindLicenseRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RepositoryService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.RepositoryService",
HandlerType: (*RepositoryServiceServer)(nil),
......@@ -1384,10 +1724,6 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
MethodName: "RepositoryExists",
Handler: _RepositoryService_RepositoryExists_Handler,
},
{
MethodName: "RepositoryIsEmpty",
Handler: _RepositoryService_RepositoryIsEmpty_Handler,
},
{
MethodName: "RepackIncremental",
Handler: _RepositoryService_RepackIncremental_Handler,
......@@ -1444,10 +1780,22 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
MethodName: "IsRebaseInProgress",
Handler: _RepositoryService_IsRebaseInProgress_Handler,
},
{
MethodName: "IsSquashInProgress",
Handler: _RepositoryService_IsSquashInProgress_Handler,
},
{
MethodName: "CreateRepositoryFromURL",
Handler: _RepositoryService_CreateRepositoryFromURL_Handler,
},
{
MethodName: "WriteConfig",
Handler: _RepositoryService_WriteConfig_Handler,
},
{
MethodName: "FindLicense",
Handler: _RepositoryService_FindLicense_Handler,
},
},
Streams: []grpc.StreamDesc{
{
......@@ -1455,6 +1803,16 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
Handler: _RepositoryService_GetArchive_Handler,
ServerStreams: true,
},
{
StreamName: "CreateBundle",
Handler: _RepositoryService_CreateBundle_Handler,
ServerStreams: true,
},
{
StreamName: "CreateRepositoryFromBundle",
Handler: _RepositoryService_CreateRepositoryFromBundle_Handler,
ClientStreams: true,
},
},
Metadata: "repository-service.proto",
}
......@@ -1462,84 +1820,97 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("repository-service.proto", fileDescriptor10) }
var fileDescriptor10 = []byte{
// 1250 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xdd, 0x6e, 0xdb, 0x36,
0x14, 0xb6, 0xe3, 0xc6, 0x49, 0x8e, 0xdd, 0xce, 0x61, 0x9d, 0x46, 0x56, 0x7f, 0x92, 0x72, 0xc3,
0x16, 0x60, 0x5b, 0x50, 0x38, 0xc0, 0xb0, 0x9b, 0xa1, 0x48, 0x8a, 0x3a, 0x35, 0xfa, 0x83, 0x4e,
0xed, 0x50, 0x20, 0xc0, 0x60, 0xc8, 0x32, 0x6d, 0x0b, 0x96, 0x45, 0x8f, 0xa4, 0xb3, 0xba, 0x4f,
0xb0, 0xe7, 0xda, 0x2b, 0xec, 0x11, 0x76, 0xd9, 0x97, 0x18, 0x44, 0xd2, 0xa2, 0x64, 0x49, 0xd9,
0x85, 0x30, 0xec, 0x4e, 0x3c, 0x24, 0xbf, 0x73, 0x78, 0x7e, 0x3f, 0x1b, 0x2c, 0x46, 0x16, 0x94,
0xfb, 0x82, 0xb2, 0xd5, 0xf7, 0x9c, 0xb0, 0x6b, 0xdf, 0x23, 0xa7, 0x0b, 0x46, 0x05, 0x45, 0xf5,
0x89, 0x2f, 0xdc, 0x60, 0x65, 0x37, 0xf9, 0xd4, 0x65, 0x64, 0xa4, 0xa4, 0xf8, 0x35, 0x1c, 0x3a,
0xf1, 0x8d, 0xe7, 0x1f, 0x7d, 0x2e, 0xb8, 0x43, 0x7e, 0x5b, 0x12, 0x2e, 0x50, 0x17, 0xc0, 0x80,
0x59, 0xd5, 0xe3, 0xea, 0x49, 0xa3, 0x8b, 0x4e, 0x15, 0xca, 0xa9, 0xb9, 0xe4, 0x24, 0x4e, 0xe1,
0x2e, 0x58, 0x59, 0x38, 0xbe, 0xa0, 0x21, 0x27, 0xe8, 0x1e, 0xd4, 0x89, 0x94, 0x48, 0xac, 0x5d,
0x47, 0xaf, 0xf0, 0x9b, 0xe4, 0x9d, 0x3e, 0x7f, 0x3e, 0x5f, 0x88, 0x55, 0x19, 0x1b, 0x7e, 0x80,
0x4e, 0x0e, 0x9e, 0x36, 0xa2, 0x03, 0xbb, 0x3e, 0x1f, 0x90, 0x48, 0xa6, 0xcd, 0xd8, 0xf1, 0xd5,
0x11, 0x6d, 0x87, 0xeb, 0xcd, 0xfa, 0xa1, 0xc7, 0xc8, 0x9c, 0x84, 0xc2, 0x0d, 0xca, 0xd8, 0x71,
0x5f, 0xda, 0xb1, 0x89, 0xa7, 0xec, 0xc0, 0x01, 0xec, 0xab, 0xcd, 0xde, 0x32, 0x28, 0xa3, 0x05,
0x7d, 0x09, 0xb7, 0x3d, 0x46, 0x5c, 0x41, 0x06, 0x43, 0x5f, 0xcc, 0xdd, 0x85, 0xb5, 0x25, 0x5f,
0xd5, 0x54, 0xc2, 0x0b, 0x29, 0xc3, 0x6d, 0x40, 0x49, 0x6d, 0xda, 0x86, 0x05, 0x1c, 0x5c, 0xba,
0x6c, 0xe8, 0x4e, 0xc8, 0x33, 0x1a, 0x04, 0xc4, 0x13, 0xff, 0xb9, 0x1d, 0x16, 0xdc, 0xdb, 0xd4,
0xa8, 0x6d, 0x79, 0x09, 0x07, 0x06, 0xf8, 0x9d, 0xff, 0x89, 0x94, 0xf1, 0xfc, 0x77, 0x70, 0x6f,
0x13, 0x4c, 0x87, 0x1f, 0xc1, 0x2d, 0xee, 0x7f, 0x22, 0x12, 0xa7, 0xe6, 0xc8, 0x6f, 0x3c, 0x83,
0xce, 0xf9, 0x62, 0x11, 0xac, 0x2e, 0x7d, 0xe1, 0x0a, 0xc1, 0xfc, 0xe1, 0x52, 0x90, 0x32, 0x45,
0x80, 0x6c, 0xd8, 0x65, 0xe4, 0xda, 0xe7, 0x3e, 0x0d, 0xa5, 0x17, 0x9a, 0x4e, 0xbc, 0xc6, 0x0f,
0xc0, 0xce, 0x53, 0xa6, 0xbd, 0xf0, 0x77, 0x15, 0x50, 0x8f, 0x08, 0x6f, 0xea, 0x90, 0x39, 0x15,
0x65, 0x7c, 0x10, 0x55, 0x1b, 0x93, 0x20, 0xd2, 0x84, 0x3d, 0x47, 0xaf, 0x50, 0x1b, 0xb6, 0xc7,
0x94, 0x79, 0xc4, 0xaa, 0xc9, 0xf8, 0xa8, 0x05, 0x3a, 0x84, 0x9d, 0x90, 0x0e, 0x84, 0x3b, 0xe1,
0xd6, 0x2d, 0x55, 0x9c, 0x21, 0x7d, 0xef, 0x4e, 0x38, 0xb2, 0x60, 0x47, 0xf8, 0x73, 0x42, 0x97,
0xc2, 0xda, 0x3e, 0xae, 0x9e, 0x6c, 0x3b, 0xeb, 0x65, 0x74, 0x85, 0xf3, 0xe9, 0x60, 0x46, 0x56,
0x56, 0x5d, 0x69, 0xe0, 0x7c, 0xfa, 0x92, 0xac, 0xd0, 0x11, 0x34, 0x66, 0x21, 0xfd, 0x3d, 0x1c,
0x4c, 0x69, 0x54, 0xec, 0x3b, 0x72, 0x13, 0xa4, 0xe8, 0x45, 0x24, 0xc1, 0x07, 0x70, 0x37, 0xf5,
0x48, 0xfd, 0xf8, 0xd7, 0x70, 0xf8, 0x4c, 0x26, 0x4b, 0xe2, 0x45, 0x25, 0x92, 0xc0, 0x06, 0x2b,
0x0b, 0xa7, 0x55, 0x7d, 0xae, 0xc2, 0xfe, 0x25, 0x11, 0xe7, 0xcc, 0x9b, 0xfa, 0xd7, 0xa5, 0xdc,
0x7c, 0x1f, 0xf6, 0x3c, 0x3a, 0x9f, 0xfb, 0x62, 0xe0, 0x8f, 0xb4, 0xa7, 0x77, 0x95, 0xa0, 0x3f,
0x8a, 0x62, 0xb0, 0x60, 0x64, 0xec, 0x7f, 0x94, 0xce, 0xde, 0x73, 0xf4, 0x0a, 0xfd, 0x08, 0xf5,
0x31, 0x65, 0x73, 0x57, 0x48, 0x67, 0xdf, 0xe9, 0x1e, 0xaf, 0x95, 0x64, 0x6c, 0x3a, 0xed, 0xc9,
0x73, 0x8e, 0x3e, 0x8f, 0xcf, 0xa0, 0xae, 0x24, 0x68, 0x07, 0x6a, 0x57, 0xfd, 0xb7, 0xad, 0x4a,
0xf4, 0xf1, 0xfe, 0xdc, 0x69, 0x55, 0x11, 0x40, 0xfd, 0xfd, 0xb9, 0x33, 0xb8, 0xbc, 0x6a, 0x6d,
0xa1, 0x06, 0xec, 0x44, 0xdf, 0x17, 0x57, 0xdd, 0x56, 0x0d, 0x9f, 0x00, 0x4a, 0x02, 0x9b, 0x52,
0x18, 0xb9, 0xc2, 0x95, 0xef, 0x6c, 0x3a, 0xf2, 0x3b, 0x0a, 0xc1, 0x0b, 0x97, 0xbf, 0xa2, 0x9e,
0x1b, 0x5c, 0x30, 0x37, 0xf4, 0xa6, 0xa5, 0x0a, 0x01, 0x3f, 0x01, 0x2b, 0x0b, 0xa7, 0xd5, 0xb7,
0x61, 0xfb, 0xda, 0x0d, 0x96, 0x44, 0x77, 0x61, 0xb5, 0xc0, 0x7f, 0x55, 0xc1, 0x92, 0xb9, 0xf1,
0x8e, 0x2e, 0x99, 0x47, 0xd4, 0xad, 0x32, 0xf1, 0x79, 0x0a, 0xfb, 0x5c, 0x42, 0x0d, 0x12, 0x57,
0xb7, 0x0a, 0xaf, 0xb6, 0xd4, 0x61, 0x27, 0xd5, 0xd7, 0x34, 0xc0, 0x50, 0x1a, 0x23, 0x43, 0xd9,
0x74, 0x9a, 0x3c, 0x61, 0x20, 0x7a, 0x08, 0x20, 0x5c, 0x36, 0x21, 0x62, 0xc0, 0xc8, 0x58, 0x06,
0xb5, 0xe9, 0xec, 0x29, 0x89, 0x43, 0xc6, 0xf8, 0x0c, 0x3a, 0x39, 0x8f, 0x32, 0x63, 0x91, 0x11,
0xbe, 0x0c, 0xc4, 0x7a, 0x2c, 0xaa, 0x15, 0x3e, 0x87, 0x46, 0x8f, 0x7b, 0xb3, 0x32, 0xfe, 0xff,
0x0a, 0x9a, 0x0a, 0xc2, 0xf8, 0x9c, 0x30, 0x46, 0x99, 0x8e, 0xb9, 0x5a, 0xe0, 0x3f, 0xab, 0xf0,
0xc5, 0x07, 0xe6, 0x47, 0x85, 0x32, 0x2e, 0xe3, 0xea, 0x16, 0xd4, 0xa2, 0xd7, 0xab, 0x8e, 0x17,
0x7d, 0xa6, 0x1a, 0x61, 0x2d, 0xdd, 0x08, 0xd1, 0x63, 0x68, 0xd2, 0x60, 0x34, 0x88, 0xf7, 0x95,
0xd3, 0x1a, 0x34, 0x18, 0x39, 0xeb, 0x23, 0x71, 0xab, 0xda, 0x4e, 0xb6, 0xaa, 0x36, 0x6c, 0xf3,
0x29, 0x09, 0x02, 0xd9, 0x75, 0x76, 0x1d, 0xb5, 0xc0, 0x27, 0xd0, 0x32, 0x6f, 0xb8, 0xf1, 0xb9,
0x53, 0x68, 0xf7, 0xfc, 0x70, 0xf4, 0x9a, 0xb0, 0x09, 0xb9, 0x70, 0x79, 0xa9, 0xea, 0x7f, 0x00,
0x7b, 0xeb, 0x07, 0x70, 0x6b, 0xeb, 0xb8, 0x16, 0x85, 0x3d, 0x16, 0xe0, 0x6f, 0xe1, 0x60, 0x43,
0x93, 0x29, 0xbd, 0xa1, 0xcb, 0x55, 0xea, 0xef, 0x39, 0xf2, 0x1b, 0xff, 0x51, 0x85, 0x7d, 0xd5,
0xaf, 0x7a, 0x94, 0xcd, 0xfe, 0xcf, 0x94, 0x8f, 0xd8, 0x42, 0xd2, 0x92, 0x98, 0xb1, 0x74, 0xfa,
0xdc, 0x21, 0x91, 0xb1, 0xfd, 0xf0, 0x2d, 0xa3, 0x13, 0x46, 0x38, 0x2f, 0xd9, 0x3a, 0x99, 0x84,
0x4b, 0xb4, 0x4e, 0x25, 0xe8, 0x8f, 0xf0, 0x4f, 0x60, 0xe7, 0x69, 0xd3, 0x0e, 0x3c, 0x82, 0x86,
0x1f, 0x0e, 0x16, 0x5a, 0xac, 0x0b, 0x07, 0xfc, 0xf8, 0x20, 0x1e, 0xc3, 0xa3, 0xcd, 0xe6, 0xdf,
0x63, 0x74, 0xfe, 0x8b, 0xf3, 0xaa, 0x64, 0x86, 0x2f, 0x59, 0xa0, 0x6d, 0x8d, 0x3e, 0xf1, 0x63,
0x38, 0x2a, 0xd4, 0xa3, 0x6c, 0xed, 0x7e, 0x6e, 0x48, 0xaa, 0xb7, 0x66, 0x23, 0x8a, 0x93, 0xa3,
0x0f, 0xd0, 0xda, 0x24, 0xca, 0xe8, 0x28, 0xab, 0x3e, 0xc5, 0xc8, 0xed, 0xe3, 0xe2, 0x03, 0x3a,
0x48, 0x15, 0x74, 0x95, 0xd4, 0xa6, 0xd9, 0x2f, 0xca, 0xb9, 0x98, 0x26, 0xda, 0xf6, 0xe3, 0x1b,
0x4e, 0x6c, 0x60, 0xa7, 0x19, 0x6d, 0x0a, 0x3b, 0x97, 0x3c, 0xa7, 0xb0, 0x0b, 0xe8, 0x70, 0x05,
0x3d, 0x07, 0x30, 0x14, 0x15, 0x75, 0xd2, 0x57, 0x12, 0x24, 0xd9, 0xb6, 0xf3, 0xb6, 0x62, 0x98,
0x9f, 0xe1, 0x4e, 0x9a, 0x61, 0xa2, 0x87, 0xf1, 0x70, 0xcd, 0xe3, 0xba, 0xf6, 0xa3, 0xa2, 0xed,
0x24, 0x64, 0x9a, 0x4d, 0x1a, 0xc8, 0x5c, 0xca, 0x6a, 0x20, 0xf3, 0x49, 0x28, 0xae, 0xa0, 0x5f,
0x01, 0x65, 0x59, 0x20, 0x8a, 0xfd, 0x54, 0x48, 0x47, 0x6d, 0x7c, 0xd3, 0x91, 0x18, 0xfe, 0x05,
0x34, 0x12, 0x04, 0x0b, 0xc5, 0x1e, 0xcb, 0x52, 0x4b, 0xfb, 0x7e, 0xee, 0x5e, 0x8c, 0xf4, 0x01,
0x5a, 0x9b, 0xf9, 0x6d, 0xd2, 0xb4, 0x80, 0xad, 0x99, 0x34, 0x2d, 0xe4, 0x5f, 0x15, 0x74, 0x09,
0x60, 0x38, 0x89, 0x09, 0x77, 0x86, 0x00, 0x99, 0x70, 0x67, 0x29, 0x0c, 0xae, 0x3c, 0xa9, 0x46,
0x16, 0x6e, 0x72, 0x0c, 0x63, 0x61, 0x01, 0x99, 0x31, 0x16, 0x16, 0xd1, 0x13, 0x95, 0xec, 0x99,
0xa1, 0x6d, 0x92, 0xbd, 0x88, 0xa4, 0x98, 0x64, 0x2f, 0x9c, 0xf8, 0xb8, 0x82, 0xce, 0xe0, 0x56,
0x34, 0x98, 0xd1, 0xdd, 0xf8, 0xb0, 0x99, 0xf4, 0x76, 0x3b, 0x2d, 0x8c, 0x2f, 0x3d, 0x85, 0xdd,
0xf5, 0x88, 0x43, 0x87, 0xeb, 0x33, 0x1b, 0x83, 0xdb, 0xb6, 0xb2, 0x1b, 0x31, 0xc0, 0x1b, 0xb8,
0x9d, 0x9a, 0x47, 0xe8, 0x41, 0xac, 0x29, 0x67, 0x20, 0xda, 0x0f, 0x0b, 0x76, 0x93, 0x25, 0x6b,
0xe6, 0x84, 0x89, 0x61, 0x66, 0x8a, 0x99, 0x18, 0xe6, 0x8c, 0x15, 0x59, 0x0c, 0xd9, 0x56, 0x6f,
0x8a, 0xa1, 0x70, 0xe8, 0x98, 0x62, 0x28, 0x9e, 0x14, 0xb8, 0x82, 0x82, 0xec, 0xcf, 0x0a, 0xdd,
0xa2, 0xd1, 0xd7, 0x45, 0x89, 0x9a, 0x9e, 0x15, 0xf6, 0x37, 0xff, 0x7a, 0x6e, 0xad, 0x6d, 0x58,
0x97, 0x7f, 0xab, 0x9c, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xef, 0x87, 0x20, 0x75, 0x88, 0x11,
// 1458 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5f, 0x6f, 0xdb, 0xb6,
0x16, 0xb7, 0xf3, 0xd7, 0x3e, 0x71, 0x7b, 0x1d, 0x26, 0x69, 0x14, 0x25, 0x6d, 0x12, 0xde, 0xe2,
0xde, 0xdc, 0xb6, 0x37, 0x28, 0x92, 0x97, 0xbd, 0x0c, 0x45, 0x12, 0x34, 0x7f, 0xd6, 0xa6, 0xc8,
0x94, 0x0e, 0x05, 0x02, 0x0c, 0x82, 0x22, 0xd3, 0xb6, 0x60, 0x59, 0x74, 0x49, 0x3a, 0x6d, 0xfa,
0xbc, 0x87, 0x7d, 0xae, 0x3d, 0xee, 0x75, 0x1f, 0x63, 0x5f, 0x62, 0x10, 0x29, 0x89, 0x92, 0x25,
0x79, 0x05, 0xb4, 0x61, 0x6f, 0xe2, 0x21, 0xf9, 0x3b, 0x87, 0xe7, 0xf0, 0x1c, 0xfe, 0x8e, 0xc0,
0x60, 0x64, 0x44, 0xb9, 0x27, 0x28, 0xbb, 0xff, 0x3f, 0x27, 0xec, 0xce, 0x73, 0xc9, 0xfe, 0x88,
0x51, 0x41, 0xd1, 0x42, 0xcf, 0x13, 0x8e, 0x7f, 0x6f, 0xb6, 0x78, 0xdf, 0x61, 0xa4, 0xa3, 0xa4,
0xf8, 0x12, 0xd6, 0xad, 0x64, 0xc7, 0xeb, 0xcf, 0x1e, 0x17, 0xdc, 0x22, 0x1f, 0xc7, 0x84, 0x0b,
0x74, 0x00, 0xa0, 0xc1, 0x8c, 0xfa, 0x4e, 0x7d, 0x6f, 0xe9, 0x00, 0xed, 0x2b, 0x94, 0x7d, 0xbd,
0xc9, 0x4a, 0xad, 0xc2, 0x07, 0x60, 0xe4, 0xe1, 0xf8, 0x88, 0x06, 0x9c, 0xa0, 0x47, 0xb0, 0x40,
0xa4, 0x44, 0x62, 0x35, 0xac, 0x68, 0x84, 0xdf, 0xc9, 0x3d, 0x8e, 0x3b, 0xb8, 0x08, 0x5c, 0x46,
0x86, 0x24, 0x10, 0x8e, 0x5f, 0xc5, 0x86, 0x4d, 0xd8, 0x28, 0xc0, 0x53, 0x46, 0x60, 0x1f, 0x96,
0xd5, 0xe4, 0xe9, 0xd8, 0xaf, 0xa2, 0x05, 0xfd, 0x1b, 0x1e, 0xb8, 0x8c, 0x38, 0x82, 0xd8, 0xb7,
0x9e, 0x18, 0x3a, 0x23, 0x63, 0x46, 0x1e, 0xaa, 0xa5, 0x84, 0xc7, 0x52, 0x86, 0x57, 0x01, 0xa5,
0xb5, 0x45, 0x36, 0x8c, 0x60, 0xed, 0xcc, 0x61, 0xb7, 0x4e, 0x8f, 0x9c, 0x50, 0xdf, 0x27, 0xae,
0xf8, 0xdb, 0xed, 0x30, 0xe0, 0xd1, 0xa4, 0xc6, 0xc8, 0x96, 0x37, 0xb0, 0xa6, 0x81, 0xaf, 0xbd,
0x2f, 0xa4, 0x8a, 0xe7, 0x5f, 0xc0, 0xa3, 0x49, 0xb0, 0x28, 0xf6, 0x08, 0xe6, 0xb8, 0xf7, 0x85,
0x48, 0x9c, 0x59, 0x4b, 0x7e, 0xe3, 0x01, 0x6c, 0x1c, 0x8d, 0x46, 0xfe, 0xfd, 0x99, 0x27, 0x1c,
0x21, 0x98, 0x77, 0x3b, 0x16, 0xa4, 0xca, 0xe5, 0x43, 0x26, 0x34, 0x18, 0xb9, 0xf3, 0xb8, 0x47,
0x03, 0xe9, 0x85, 0x96, 0x95, 0x8c, 0xf1, 0x16, 0x98, 0x45, 0xca, 0x22, 0x2f, 0xfc, 0x34, 0x03,
0xe8, 0x94, 0x08, 0xb7, 0x6f, 0x91, 0x21, 0x15, 0x55, 0x7c, 0x10, 0xde, 0x72, 0x26, 0x41, 0xa4,
0x09, 0x4d, 0x2b, 0x1a, 0xa1, 0x55, 0x98, 0xef, 0x52, 0xe6, 0x12, 0x63, 0x56, 0xc6, 0x47, 0x0d,
0xd0, 0x3a, 0x2c, 0x06, 0xd4, 0x16, 0x4e, 0x8f, 0x1b, 0x73, 0x2a, 0x29, 0x02, 0xfa, 0xde, 0xe9,
0x71, 0x64, 0xc0, 0xa2, 0xf0, 0x86, 0x84, 0x8e, 0x85, 0x31, 0xbf, 0x53, 0xdf, 0x9b, 0xb7, 0xe2,
0x61, 0xb8, 0x85, 0xf3, 0xbe, 0x3d, 0x20, 0xf7, 0xc6, 0x82, 0xd2, 0xc0, 0x79, 0xff, 0x0d, 0xb9,
0x47, 0xdb, 0xb0, 0x34, 0x08, 0xe8, 0xa7, 0xc0, 0xee, 0xd3, 0x30, 0xc9, 0x16, 0xe5, 0x24, 0x48,
0xd1, 0x79, 0x28, 0x41, 0x1b, 0xd0, 0x08, 0xa8, 0x3d, 0x62, 0xe3, 0x80, 0x18, 0x4d, 0xa9, 0x6d,
0x31, 0xa0, 0x57, 0xe1, 0xf0, 0xbb, 0xb9, 0x46, 0xa3, 0xdd, 0xc4, 0x6b, 0xb0, 0x92, 0xf1, 0x42,
0xe4, 0x9d, 0x4b, 0x58, 0x3f, 0x91, 0xb7, 0x29, 0x75, 0xe4, 0x0a, 0xb7, 0xc4, 0x04, 0x23, 0x0f,
0x17, 0xa9, 0xfa, 0xbd, 0x0e, 0xcb, 0x67, 0x44, 0x1c, 0x31, 0xb7, 0xef, 0xdd, 0x55, 0x8a, 0xc3,
0x26, 0x34, 0x5d, 0x3a, 0x1c, 0x7a, 0xc2, 0xf6, 0x3a, 0x51, 0x28, 0x1a, 0x4a, 0x70, 0xd1, 0x09,
0x83, 0x34, 0x62, 0xa4, 0xeb, 0x7d, 0x96, 0xd1, 0x68, 0x5a, 0xd1, 0x08, 0x7d, 0x03, 0x0b, 0x5d,
0xca, 0x86, 0x8e, 0x90, 0xd1, 0x78, 0x78, 0xb0, 0x13, 0x2b, 0xc9, 0xd9, 0xb4, 0x7f, 0x2a, 0xd7,
0x59, 0xd1, 0x7a, 0x7c, 0x08, 0x0b, 0x4a, 0x82, 0x16, 0x61, 0xf6, 0xe6, 0xe2, 0xaa, 0x5d, 0x0b,
0x3f, 0xde, 0x1f, 0x59, 0xed, 0x3a, 0x02, 0x58, 0x78, 0x7f, 0x64, 0xd9, 0x67, 0x37, 0xed, 0x19,
0xb4, 0x04, 0x8b, 0xe1, 0xf7, 0xf1, 0xcd, 0x41, 0x7b, 0x16, 0xef, 0x01, 0x4a, 0x03, 0xeb, 0x5c,
0xe9, 0x38, 0xc2, 0x91, 0xe7, 0x6c, 0x59, 0xf2, 0x3b, 0x0c, 0xc1, 0xb9, 0xc3, 0xdf, 0x52, 0xd7,
0xf1, 0x8f, 0x99, 0x13, 0xb8, 0xfd, 0x4a, 0x99, 0x82, 0x5f, 0x82, 0x91, 0x87, 0x8b, 0xd4, 0xaf,
0xc2, 0xfc, 0x9d, 0xe3, 0x8f, 0x49, 0x54, 0xa5, 0xd5, 0x00, 0xff, 0x56, 0x07, 0x43, 0xde, 0x8d,
0x6b, 0x3a, 0x66, 0x2e, 0x51, 0xbb, 0xaa, 0xc4, 0xe7, 0x15, 0x2c, 0x73, 0x09, 0x65, 0xa7, 0xb6,
0xce, 0x94, 0x6e, 0x6d, 0xab, 0xc5, 0x56, 0xa6, 0xf0, 0x45, 0x00, 0xb7, 0xd2, 0x18, 0x19, 0xca,
0x96, 0xd5, 0xe2, 0x29, 0x03, 0xd1, 0x63, 0x00, 0xe1, 0xb0, 0x1e, 0x11, 0x36, 0x23, 0x5d, 0x19,
0xd4, 0x96, 0xd5, 0x54, 0x12, 0x8b, 0x74, 0xf1, 0x21, 0x6c, 0x14, 0x1c, 0x4a, 0xbf, 0x57, 0x8c,
0xf0, 0xb1, 0x2f, 0xe2, 0xf7, 0x4a, 0x8d, 0xf0, 0x11, 0x2c, 0x9d, 0x72, 0x77, 0x50, 0xc5, 0xff,
0x4f, 0xa1, 0xa5, 0x20, 0xb4, 0xcf, 0x09, 0x63, 0x94, 0x45, 0x31, 0x57, 0x03, 0xfc, 0x4b, 0x1d,
0xfe, 0xf5, 0x81, 0x79, 0x61, 0xa2, 0x74, 0xab, 0xb8, 0xba, 0x0d, 0xb3, 0xe1, 0xe9, 0x55, 0x49,
0x0c, 0x3f, 0x33, 0x95, 0x72, 0x36, 0x5b, 0x29, 0xd1, 0x2e, 0xb4, 0xa8, 0xdf, 0xb1, 0x93, 0x79,
0xe5, 0xb4, 0x25, 0xea, 0x77, 0xac, 0x78, 0x49, 0x52, 0xcb, 0xe6, 0xd3, 0xb5, 0x6c, 0x15, 0xe6,
0x79, 0x9f, 0xf8, 0xbe, 0x2c, 0x4b, 0x0d, 0x4b, 0x0d, 0xf0, 0x1e, 0xb4, 0xf5, 0x19, 0xa6, 0x1e,
0xb7, 0x0f, 0xab, 0xa7, 0x5e, 0xd0, 0xb9, 0x24, 0xac, 0x47, 0x8e, 0x1d, 0x5e, 0x29, 0xfb, 0xb7,
0xa0, 0x19, 0x1f, 0x80, 0x1b, 0x33, 0x3b, 0xb3, 0x61, 0xd8, 0x13, 0x01, 0x7e, 0x0e, 0x6b, 0x13,
0x9a, 0x74, 0xea, 0xdd, 0x3a, 0x5c, 0x5d, 0xfd, 0xa6, 0x25, 0xbf, 0xf1, 0xcf, 0x75, 0x58, 0x56,
0xf5, 0xea, 0x94, 0xb2, 0xc1, 0x3f, 0x79, 0xe5, 0x43, 0x3a, 0x91, 0xb6, 0x24, 0xa1, 0x34, 0x1b,
0x17, 0xdc, 0x22, 0xa1, 0xb1, 0x17, 0xc1, 0x15, 0xa3, 0x3d, 0x46, 0x38, 0xaf, 0x58, 0x3a, 0x99,
0x84, 0x4b, 0x95, 0x4e, 0x25, 0xb8, 0xe8, 0xe0, 0x6f, 0xc1, 0x2c, 0xd2, 0x16, 0x39, 0x70, 0x1b,
0x96, 0xbc, 0xc0, 0x1e, 0x45, 0xe2, 0x28, 0x71, 0xc0, 0x4b, 0x16, 0x2a, 0x63, 0xaf, 0x3f, 0x8e,
0x1d, 0xde, 0xff, 0xcb, 0x8c, 0xe5, 0x12, 0x2e, 0x65, 0xac, 0x12, 0xc4, 0xc6, 0xe6, 0xb5, 0x7d,
0xad, 0xb1, 0x5d, 0x78, 0x32, 0xf9, 0x52, 0x9d, 0x32, 0x3a, 0xfc, 0xc1, 0x7a, 0x5b, 0x31, 0x1d,
0xc7, 0xcc, 0x8f, 0x6c, 0x0d, 0x3f, 0xf1, 0x2e, 0x6c, 0x97, 0xea, 0x89, 0x82, 0x7c, 0x01, 0x2b,
0x6a, 0xc9, 0xf1, 0x38, 0xe8, 0xf8, 0x95, 0x58, 0xda, 0x33, 0x58, 0xcd, 0x42, 0x4d, 0x79, 0x77,
0x08, 0x20, 0x99, 0xbd, 0x27, 0x34, 0xe8, 0x7a, 0xbd, 0x8a, 0x71, 0xea, 0x8e, 0x7d, 0xdf, 0x1e,
0x39, 0xa2, 0x1f, 0xc7, 0x29, 0x14, 0x5c, 0x39, 0xa2, 0x8f, 0x9f, 0xc3, 0x4a, 0x46, 0xcd, 0xd4,
0x3a, 0x31, 0x80, 0xdd, 0x22, 0x6f, 0x55, 0x76, 0x4c, 0xe2, 0x80, 0x99, 0x94, 0x03, 0x9e, 0x02,
0x9e, 0xa6, 0x2c, 0x8a, 0xce, 0x39, 0xa0, 0xb0, 0xa0, 0xbc, 0xf5, 0x5c, 0x12, 0x54, 0x2a, 0x5c,
0xf8, 0x04, 0x56, 0x32, 0x48, 0x91, 0x27, 0x5e, 0x00, 0xf2, 0x95, 0xc8, 0xe6, 0x7d, 0xca, 0x84,
0x1d, 0x38, 0xc3, 0xb8, 0x4c, 0xb5, 0xa3, 0x99, 0xeb, 0x70, 0xe2, 0x9d, 0x33, 0x24, 0x07, 0xbf,
0x3e, 0x94, 0x5d, 0x4e, 0x4c, 0xc4, 0x55, 0x1b, 0x88, 0x3e, 0x40, 0x7b, 0xb2, 0x37, 0x43, 0xdb,
0x79, 0x73, 0x32, 0x4d, 0xa0, 0xb9, 0x53, 0xbe, 0x20, 0x3a, 0x7b, 0x0d, 0xdd, 0xc4, 0x3d, 0x55,
0xaa, 0xe1, 0x42, 0xe9, 0x8d, 0x85, 0xbd, 0x9d, 0xb9, 0x3b, 0x65, 0x45, 0x82, 0xfd, 0x1a, 0x40,
0x77, 0x50, 0x68, 0x23, 0xbb, 0x25, 0xd5, 0xc3, 0x99, 0x66, 0xd1, 0x54, 0x02, 0xf3, 0x3d, 0x3c,
0xcc, 0x36, 0x40, 0xe8, 0x71, 0x42, 0xed, 0x8a, 0x5a, 0x31, 0xf3, 0x49, 0xd9, 0x74, 0x1a, 0x32,
0xdb, 0xec, 0x68, 0xc8, 0xc2, 0x8e, 0x4a, 0x43, 0x16, 0xf7, 0x48, 0xb8, 0x86, 0x7e, 0x04, 0x94,
0x6f, 0x52, 0x50, 0xe2, 0xa7, 0xd2, 0x6e, 0xc9, 0xc4, 0xd3, 0x96, 0x24, 0xf0, 0xe7, 0xb0, 0x94,
0xa2, 0xf7, 0x28, 0xf1, 0x58, 0xbe, 0xf3, 0x31, 0x37, 0x0b, 0xe7, 0x12, 0xa4, 0x0f, 0xd0, 0x9e,
0xcc, 0x0a, 0x7d, 0x95, 0x4a, 0x7a, 0x05, 0x7d, 0x95, 0x4a, 0xd9, 0x7f, 0x0d, 0x9d, 0x01, 0x68,
0x46, 0xac, 0xc3, 0x9d, 0xa3, 0xdf, 0x3a, 0xdc, 0x79, 0x02, 0x8d, 0x6b, 0x2f, 0xeb, 0xa1, 0x85,
0x93, 0x0c, 0x57, 0x5b, 0x58, 0x42, 0xa5, 0xb5, 0x85, 0x65, 0xe4, 0x58, 0x5d, 0xf6, 0x1c, 0x65,
0xd4, 0x97, 0xbd, 0x8c, 0x22, 0xeb, 0xcb, 0x5e, 0xca, 0x37, 0x71, 0x0d, 0x1d, 0xc2, 0x5c, 0x48,
0x0b, 0xd1, 0x4a, 0xb2, 0x58, 0xf3, 0x4c, 0x73, 0x35, 0x2b, 0x4c, 0x36, 0xbd, 0x82, 0x46, 0x4c,
0xb0, 0xd0, 0x7a, 0xbc, 0x66, 0x82, 0x36, 0x9a, 0x46, 0x7e, 0x22, 0x01, 0x78, 0x07, 0x0f, 0x32,
0x6c, 0x08, 0x6d, 0x25, 0x9a, 0x0a, 0xe8, 0x98, 0xf9, 0xb8, 0x64, 0x36, 0x9d, 0xb2, 0x9a, 0xa5,
0xe8, 0x18, 0xe6, 0x38, 0x94, 0x8e, 0x61, 0x01, 0xa9, 0x91, 0xc9, 0x90, 0x27, 0x1a, 0x3a, 0x19,
0x4a, 0x29, 0x8f, 0x4e, 0x86, 0x72, 0x9e, 0x12, 0xc3, 0x4f, 0x52, 0x83, 0x34, 0x7c, 0x09, 0x49,
0x49, 0xc3, 0x97, 0x31, 0x0b, 0x5c, 0x43, 0x7e, 0xbe, 0x67, 0x8e, 0x9e, 0x74, 0xf4, 0x9f, 0xb2,
0x3c, 0xc8, 0x72, 0x0b, 0xf3, 0xbf, 0x7f, 0xba, 0x2e, 0xd1, 0x76, 0x09, 0xad, 0xf4, 0x93, 0x8e,
0x36, 0xb3, 0x5b, 0x33, 0x4f, 0xa3, 0xb9, 0x55, 0x3c, 0x99, 0x4a, 0x9e, 0x4f, 0x60, 0x96, 0x3f,
0x7a, 0xe8, 0x7f, 0xd3, 0xec, 0xca, 0xaa, 0x7a, 0xf6, 0x35, 0x4b, 0x63, 0xc5, 0x7b, 0xf5, 0xb0,
0x42, 0xa5, 0x78, 0x80, 0xae, 0x50, 0x79, 0x0e, 0xa2, 0x2b, 0x54, 0x01, 0x71, 0x88, 0x6a, 0x9d,
0x7e, 0x47, 0x53, 0xb5, 0x2e, 0xf7, 0x4c, 0xa7, 0x6a, 0x5d, 0xfe, 0xe1, 0xc5, 0xb5, 0xdb, 0x05,
0xf9, 0xa3, 0xf4, 0xf0, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x46, 0x1f, 0xcc, 0xb0, 0x5a, 0x15,
0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/server.pb.go 0 → 100644
View file @ 27bdba30
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: server.proto
package gitaly
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ServerInfoRequest struct {
}
func (m *ServerInfoRequest) Reset() { *m = ServerInfoRequest{} }
func (m *ServerInfoRequest) String() string { return proto.CompactTextString(m) }
func (*ServerInfoRequest) ProtoMessage() {}
func (*ServerInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
type ServerInfoResponse struct {
ServerVersion string `protobuf:"bytes,1,opt,name=server_version,json=serverVersion" json:"server_version,omitempty"`
GitVersion string `protobuf:"bytes,2,opt,name=git_version,json=gitVersion" json:"git_version,omitempty"`
}
func (m *ServerInfoResponse) Reset() { *m = ServerInfoResponse{} }
func (m *ServerInfoResponse) String() string { return proto.CompactTextString(m) }
func (*ServerInfoResponse) ProtoMessage() {}
func (*ServerInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
func (m *ServerInfoResponse) GetServerVersion() string {
if m != nil {
return m.ServerVersion
}
return ""
}
func (m *ServerInfoResponse) GetGitVersion() string {
if m != nil {
return m.GitVersion
}
return ""
}
func init() {
proto.RegisterType((*ServerInfoRequest)(nil), "gitaly.ServerInfoRequest")
proto.RegisterType((*ServerInfoResponse)(nil), "gitaly.ServerInfoResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for ServerService service
type ServerServiceClient interface {
ServerInfo(ctx context.Context, in *ServerInfoRequest, opts ...grpc.CallOption) (*ServerInfoResponse, error)
}
type serverServiceClient struct {
cc *grpc.ClientConn
}
func NewServerServiceClient(cc *grpc.ClientConn) ServerServiceClient {
return &serverServiceClient{cc}
}
func (c *serverServiceClient) ServerInfo(ctx context.Context, in *ServerInfoRequest, opts ...grpc.CallOption) (*ServerInfoResponse, error) {
out := new(ServerInfoResponse)
err := grpc.Invoke(ctx, "/gitaly.ServerService/ServerInfo", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ServerService service
type ServerServiceServer interface {
ServerInfo(context.Context, *ServerInfoRequest) (*ServerInfoResponse, error)
}
func RegisterServerServiceServer(s *grpc.Server, srv ServerServiceServer) {
s.RegisterService(&_ServerService_serviceDesc, srv)
}
func _ServerService_ServerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ServerInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ServerServiceServer).ServerInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.ServerService/ServerInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ServerServiceServer).ServerInfo(ctx, req.(*ServerInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ServerService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.ServerService",
HandlerType: (*ServerServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ServerInfo",
Handler: _ServerService_ServerInfo_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "server.proto",
}
func init() { proto.RegisterFile("server.proto", fileDescriptor11) }
var fileDescriptor11 = []byte{
// 160 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4e, 0x2d, 0x2a,
0x4b, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9,
0x54, 0x12, 0xe6, 0x12, 0x0c, 0x06, 0x8b, 0x7b, 0xe6, 0xa5, 0xe5, 0x07, 0xa5, 0x16, 0x96, 0xa6,
0x16, 0x97, 0x28, 0xc5, 0x70, 0x09, 0x21, 0x0b, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0xa9,
0x72, 0xf1, 0x41, 0x8c, 0x88, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x93, 0x60, 0x54, 0x60,
0xd4, 0xe0, 0x0c, 0xe2, 0x85, 0x88, 0x86, 0x41, 0x04, 0x85, 0xe4, 0xb9, 0xb8, 0xd3, 0x33, 0x4b,
0xe0, 0x6a, 0x98, 0xc0, 0x6a, 0xb8, 0xd2, 0x33, 0x4b, 0xa0, 0x0a, 0x8c, 0xc2, 0xb8, 0x78, 0x21,
0xa6, 0x83, 0xc8, 0xcc, 0xe4, 0x54, 0x21, 0x57, 0x2e, 0x2e, 0x84, 0x75, 0x42, 0x92, 0x7a, 0x10,
0xa7, 0xe9, 0x61, 0xb8, 0x4b, 0x4a, 0x0a, 0x9b, 0x14, 0xc4, 0x75, 0x4a, 0x0c, 0x49, 0x6c, 0x60,
0x9f, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xa0, 0x30, 0xe2, 0x5e, 0xe9, 0x00, 0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go
View file @ 27bdba30
......@@ -30,7 +30,7 @@ type Repository struct {
func (m *Repository) Reset() { *m = Repository{} }
func (m *Repository) String() string { return proto.CompactTextString(m) }
func (*Repository) ProtoMessage() {}
func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{0} }
func (m *Repository) GetStorageName() string {
if m != nil {
......@@ -80,7 +80,7 @@ type GitCommit struct {
func (m *GitCommit) Reset() { *m = GitCommit{} }
func (m *GitCommit) String() string { return proto.CompactTextString(m) }
func (*GitCommit) ProtoMessage() {}
func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{1} }
func (m *GitCommit) GetId() string {
if m != nil {
......@@ -133,7 +133,7 @@ type CommitAuthor struct {
func (m *CommitAuthor) Reset() { *m = CommitAuthor{} }
func (m *CommitAuthor) String() string { return proto.CompactTextString(m) }
func (*CommitAuthor) ProtoMessage() {}
func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{2} }
func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{2} }
func (m *CommitAuthor) GetName() []byte {
if m != nil {
......@@ -163,7 +163,7 @@ type ExitStatus struct {
func (m *ExitStatus) Reset() { *m = ExitStatus{} }
func (m *ExitStatus) String() string { return proto.CompactTextString(m) }
func (*ExitStatus) ProtoMessage() {}
func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{3} }
func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{3} }
func (m *ExitStatus) GetValue() int32 {
if m != nil {
......@@ -181,7 +181,7 @@ type Branch struct {
func (m *Branch) Reset() { *m = Branch{} }
func (m *Branch) String() string { return proto.CompactTextString(m) }
func (*Branch) ProtoMessage() {}
func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{4} }
func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{4} }
func (m *Branch) GetName() []byte {
if m != nil {
......@@ -207,7 +207,7 @@ type Tag struct {
func (m *Tag) Reset() { *m = Tag{} }
func (m *Tag) String() string { return proto.CompactTextString(m) }
func (*Tag) ProtoMessage() {}
func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{5} }
func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{5} }
func (m *Tag) GetName() []byte {
if m != nil {
......@@ -247,7 +247,7 @@ type User struct {
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (*User) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{6} }
func (*User) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{6} }
func (m *User) GetGlId() string {
if m != nil {
......@@ -287,9 +287,9 @@ func init() {
proto.RegisterType((*User)(nil), "gitaly.User")
}
func init() { proto.RegisterFile("shared.proto", fileDescriptor11) }
func init() { proto.RegisterFile("shared.proto", fileDescriptor12) }
var fileDescriptor11 = []byte{
var fileDescriptor12 = []byte{
// 518 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6f, 0xd3, 0x40,
0x10, 0x55, 0x1c, 0xc7, 0x90, 0x89, 0x8b, 0x60, 0xc9, 0xc1, 0xaa, 0x54, 0x35, 0x98, 0x4b, 0x0f,
......
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go
View file @ 27bdba30
......@@ -26,7 +26,7 @@ type InfoRefsRequest struct {
func (m *InfoRefsRequest) Reset() { *m = InfoRefsRequest{} }
func (m *InfoRefsRequest) String() string { return proto.CompactTextString(m) }
func (*InfoRefsRequest) ProtoMessage() {}
func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{0} }
func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
func (m *InfoRefsRequest) GetRepository() *Repository {
if m != nil {
......@@ -49,7 +49,7 @@ type InfoRefsResponse struct {
func (m *InfoRefsResponse) Reset() { *m = InfoRefsResponse{} }
func (m *InfoRefsResponse) String() string { return proto.CompactTextString(m) }
func (*InfoRefsResponse) ProtoMessage() {}
func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{1} }
func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{1} }
func (m *InfoRefsResponse) GetData() []byte {
if m != nil {
......@@ -70,7 +70,7 @@ type PostUploadPackRequest struct {
func (m *PostUploadPackRequest) Reset() { *m = PostUploadPackRequest{} }
func (m *PostUploadPackRequest) String() string { return proto.CompactTextString(m) }
func (*PostUploadPackRequest) ProtoMessage() {}
func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{2} }
func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{2} }
func (m *PostUploadPackRequest) GetRepository() *Repository {
if m != nil {
......@@ -101,7 +101,7 @@ type PostUploadPackResponse struct {
func (m *PostUploadPackResponse) Reset() { *m = PostUploadPackResponse{} }
func (m *PostUploadPackResponse) String() string { return proto.CompactTextString(m) }
func (*PostUploadPackResponse) ProtoMessage() {}
func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{3} }
func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{3} }
func (m *PostUploadPackResponse) GetData() []byte {
if m != nil {
......@@ -125,7 +125,7 @@ type PostReceivePackRequest struct {
func (m *PostReceivePackRequest) Reset() { *m = PostReceivePackRequest{} }
func (m *PostReceivePackRequest) String() string { return proto.CompactTextString(m) }
func (*PostReceivePackRequest) ProtoMessage() {}
func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{4} }
func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{4} }
func (m *PostReceivePackRequest) GetRepository() *Repository {
if m != nil {
......@@ -170,7 +170,7 @@ type PostReceivePackResponse struct {
func (m *PostReceivePackResponse) Reset() { *m = PostReceivePackResponse{} }
func (m *PostReceivePackResponse) String() string { return proto.CompactTextString(m) }
func (*PostReceivePackResponse) ProtoMessage() {}
func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{5} }
func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{5} }
func (m *PostReceivePackResponse) GetData() []byte {
if m != nil {
......@@ -485,9 +485,9 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
Metadata: "smarthttp.proto",
}
func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor12) }
func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor13) }
var fileDescriptor12 = []byte{
var fileDescriptor13 = []byte{
// 386 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x93, 0xdd, 0xee, 0xd2, 0x40,
0x10, 0xc5, 0x5d, 0xbe, 0x12, 0x06, 0x14, 0x32, 0x44, 0x69, 0x9a, 0x28, 0xa4, 0x26, 0xa6, 0x17,
......
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go
View file @ 27bdba30
......@@ -29,7 +29,7 @@ type SSHUploadPackRequest struct {
func (m *SSHUploadPackRequest) Reset() { *m = SSHUploadPackRequest{} }
func (m *SSHUploadPackRequest) String() string { return proto.CompactTextString(m) }
func (*SSHUploadPackRequest) ProtoMessage() {}
func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
func (m *SSHUploadPackRequest) GetRepository() *Repository {
if m != nil {
......@@ -65,7 +65,7 @@ type SSHUploadPackResponse struct {
func (m *SSHUploadPackResponse) Reset() { *m = SSHUploadPackResponse{} }
func (m *SSHUploadPackResponse) String() string { return proto.CompactTextString(m) }
func (*SSHUploadPackResponse) ProtoMessage() {}
func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{1} }
func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
func (m *SSHUploadPackResponse) GetStdout() []byte {
if m != nil {
......@@ -103,7 +103,7 @@ type SSHReceivePackRequest struct {
func (m *SSHReceivePackRequest) Reset() { *m = SSHReceivePackRequest{} }
func (m *SSHReceivePackRequest) String() string { return proto.CompactTextString(m) }
func (*SSHReceivePackRequest) ProtoMessage() {}
func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{2} }
func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
func (m *SSHReceivePackRequest) GetRepository() *Repository {
if m != nil {
......@@ -153,7 +153,7 @@ type SSHReceivePackResponse struct {
func (m *SSHReceivePackResponse) Reset() { *m = SSHReceivePackResponse{} }
func (m *SSHReceivePackResponse) String() string { return proto.CompactTextString(m) }
func (*SSHReceivePackResponse) ProtoMessage() {}
func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{3} }
func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{3} }
func (m *SSHReceivePackResponse) GetStdout() []byte {
if m != nil {
......@@ -176,11 +176,74 @@ func (m *SSHReceivePackResponse) GetExitStatus() *ExitStatus {
return nil
}
type SSHUploadArchiveRequest struct {
// 'repository' must be present in the first message.
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// A chunk of raw data to be copied to 'git upload-archive' standard input
Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3" json:"stdin,omitempty"`
}
func (m *SSHUploadArchiveRequest) Reset() { *m = SSHUploadArchiveRequest{} }
func (m *SSHUploadArchiveRequest) String() string { return proto.CompactTextString(m) }
func (*SSHUploadArchiveRequest) ProtoMessage() {}
func (*SSHUploadArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
func (m *SSHUploadArchiveRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *SSHUploadArchiveRequest) GetStdin() []byte {
if m != nil {
return m.Stdin
}
return nil
}
type SSHUploadArchiveResponse struct {
// A chunk of raw data from 'git upload-archive' standard output
Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3" json:"stdout,omitempty"`
// A chunk of raw data from 'git upload-archive' standard error
Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3" json:"stderr,omitempty"`
// This value will only be set on the last message
ExitStatus *ExitStatus `protobuf:"bytes,3,opt,name=exit_status,json=exitStatus" json:"exit_status,omitempty"`
}
func (m *SSHUploadArchiveResponse) Reset() { *m = SSHUploadArchiveResponse{} }
func (m *SSHUploadArchiveResponse) String() string { return proto.CompactTextString(m) }
func (*SSHUploadArchiveResponse) ProtoMessage() {}
func (*SSHUploadArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{5} }
func (m *SSHUploadArchiveResponse) GetStdout() []byte {
if m != nil {
return m.Stdout
}
return nil
}
func (m *SSHUploadArchiveResponse) GetStderr() []byte {
if m != nil {
return m.Stderr
}
return nil
}
func (m *SSHUploadArchiveResponse) GetExitStatus() *ExitStatus {
if m != nil {
return m.ExitStatus
}
return nil
}
func init() {
proto.RegisterType((*SSHUploadPackRequest)(nil), "gitaly.SSHUploadPackRequest")
proto.RegisterType((*SSHUploadPackResponse)(nil), "gitaly.SSHUploadPackResponse")
proto.RegisterType((*SSHReceivePackRequest)(nil), "gitaly.SSHReceivePackRequest")
proto.RegisterType((*SSHReceivePackResponse)(nil), "gitaly.SSHReceivePackResponse")
proto.RegisterType((*SSHUploadArchiveRequest)(nil), "gitaly.SSHUploadArchiveRequest")
proto.RegisterType((*SSHUploadArchiveResponse)(nil), "gitaly.SSHUploadArchiveResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
......@@ -198,6 +261,8 @@ type SSHServiceClient interface {
SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error)
// To forward 'git receive-pack' to Gitaly for SSH sessions
SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error)
// To forward 'git upload-archive' to Gitaly for SSH sessions
SSHUploadArchive(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadArchiveClient, error)
}
type sSHServiceClient struct {
......@@ -270,6 +335,37 @@ func (x *sSHServiceSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error)
return m, nil
}
func (c *sSHServiceClient) SSHUploadArchive(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadArchiveClient, error) {
stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[2], c.cc, "/gitaly.SSHService/SSHUploadArchive", opts...)
if err != nil {
return nil, err
}
x := &sSHServiceSSHUploadArchiveClient{stream}
return x, nil
}
type SSHService_SSHUploadArchiveClient interface {
Send(*SSHUploadArchiveRequest) error
Recv() (*SSHUploadArchiveResponse, error)
grpc.ClientStream
}
type sSHServiceSSHUploadArchiveClient struct {
grpc.ClientStream
}
func (x *sSHServiceSSHUploadArchiveClient) Send(m *SSHUploadArchiveRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *sSHServiceSSHUploadArchiveClient) Recv() (*SSHUploadArchiveResponse, error) {
m := new(SSHUploadArchiveResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for SSHService service
type SSHServiceServer interface {
......@@ -277,6 +373,8 @@ type SSHServiceServer interface {
SSHUploadPack(SSHService_SSHUploadPackServer) error
// To forward 'git receive-pack' to Gitaly for SSH sessions
SSHReceivePack(SSHService_SSHReceivePackServer) error
// To forward 'git upload-archive' to Gitaly for SSH sessions
SSHUploadArchive(SSHService_SSHUploadArchiveServer) error
}
func RegisterSSHServiceServer(s *grpc.Server, srv SSHServiceServer) {
......@@ -335,6 +433,32 @@ func (x *sSHServiceSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error)
return m, nil
}
func _SSHService_SSHUploadArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(SSHServiceServer).SSHUploadArchive(&sSHServiceSSHUploadArchiveServer{stream})
}
type SSHService_SSHUploadArchiveServer interface {
Send(*SSHUploadArchiveResponse) error
Recv() (*SSHUploadArchiveRequest, error)
grpc.ServerStream
}
type sSHServiceSSHUploadArchiveServer struct {
grpc.ServerStream
}
func (x *sSHServiceSSHUploadArchiveServer) Send(m *SSHUploadArchiveResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *sSHServiceSSHUploadArchiveServer) Recv() (*SSHUploadArchiveRequest, error) {
m := new(SSHUploadArchiveRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _SSHService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.SSHService",
HandlerType: (*SSHServiceServer)(nil),
......@@ -352,36 +476,45 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "SSHUploadArchive",
Handler: _SSHService_SSHUploadArchive_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "ssh.proto",
}
func init() { proto.RegisterFile("ssh.proto", fileDescriptor13) }
var fileDescriptor13 = []byte{
// 377 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xcd, 0xce, 0xd2, 0x40,
0x14, 0x75, 0xa4, 0x10, 0xb9, 0xf4, 0x33, 0x64, 0x04, 0xd2, 0x10, 0x7f, 0x48, 0xdd, 0x74, 0x61,
0x88, 0x81, 0x47, 0x30, 0x26, 0xe8, 0x46, 0x33, 0x0d, 0xeb, 0x66, 0x6c, 0xaf, 0xc3, 0xc4, 0xa1,
0x53, 0x67, 0xa6, 0x04, 0x12, 0x7d, 0x22, 0x1f, 0xc0, 0x8d, 0x0f, 0x67, 0x32, 0xad, 0x58, 0x50,
0x96, 0xba, 0xeb, 0x3d, 0xe7, 0xfe, 0x9c, 0x73, 0x6f, 0x07, 0x86, 0xd6, 0xee, 0x96, 0x95, 0xd1,
0x4e, 0xd3, 0x81, 0x90, 0x8e, 0xab, 0xd3, 0x3c, 0xb4, 0x3b, 0x6e, 0xb0, 0x68, 0xd0, 0xf8, 0x1b,
0x81, 0x49, 0x9a, 0x6e, 0xb6, 0x95, 0xd2, 0xbc, 0x78, 0xcf, 0xf3, 0x4f, 0x0c, 0x3f, 0xd7, 0x68,
0x1d, 0x5d, 0x01, 0x18, 0xac, 0xb4, 0x95, 0x4e, 0x9b, 0x53, 0x44, 0x16, 0x24, 0x19, 0xad, 0xe8,
0xb2, 0xe9, 0xb1, 0x64, 0x67, 0x86, 0x75, 0xb2, 0xe8, 0x04, 0xfa, 0xd6, 0x15, 0xb2, 0x8c, 0xee,
0x2f, 0x48, 0x12, 0xb2, 0x26, 0xa0, 0x2f, 0x80, 0x0a, 0xe9, 0xb2, 0x5c, 0x97, 0x1f, 0xa5, 0xc8,
0x74, 0xe5, 0xa4, 0x2e, 0x6d, 0x14, 0x2c, 0x7a, 0xc9, 0x90, 0x8d, 0x85, 0x74, 0xaf, 0x3c, 0xf1,
0xae, 0xc1, 0xdf, 0x06, 0x0f, 0x7a, 0xe3, 0x80, 0x4d, 0x3b, 0x15, 0x15, 0x37, 0x7c, 0x8f, 0x0e,
0x8d, 0x8d, 0xbf, 0xc0, 0xf4, 0x4a, 0xac, 0xad, 0x74, 0x69, 0x91, 0xce, 0x60, 0x60, 0x5d, 0xa1,
0x6b, 0xe7, 0x95, 0x86, 0xac, 0x8d, 0x5a, 0x1c, 0x8d, 0x69, 0x25, 0xb5, 0x11, 0x5d, 0xc3, 0x08,
0x8f, 0xd2, 0x65, 0xd6, 0x71, 0x57, 0xdb, 0xa8, 0x77, 0x69, 0xef, 0xf5, 0x51, 0xba, 0xd4, 0x33,
0x0c, 0xf0, 0xfc, 0x1d, 0xff, 0x20, 0x7e, 0x3c, 0xc3, 0x1c, 0xe5, 0x01, 0xff, 0xcd, 0xb2, 0x1e,
0x41, 0x5f, 0xa8, 0x4c, 0x16, 0x5e, 0xd2, 0x90, 0x05, 0x42, 0xbd, 0x29, 0xe8, 0x73, 0xb8, 0x13,
0x2a, 0xeb, 0x4c, 0x08, 0x3c, 0x19, 0x0a, 0xf5, 0xbb, 0x37, 0x7d, 0x06, 0x23, 0xa1, 0xb2, 0xda,
0xa2, 0x29, 0xf9, 0x1e, 0xa3, 0xbe, 0x4f, 0x01, 0xa1, 0xb6, 0x2d, 0x12, 0x7f, 0x85, 0xd9, 0xb5,
0xfa, 0xff, 0xb8, 0xbd, 0xd5, 0x77, 0x02, 0x90, 0xa6, 0x9b, 0x14, 0xcd, 0x41, 0xe6, 0x48, 0x19,
0xdc, 0x5d, 0x9c, 0x92, 0x3e, 0xfe, 0x55, 0xff, 0xb7, 0xdf, 0x71, 0xfe, 0xe4, 0x06, 0xdb, 0x38,
0x88, 0xef, 0x25, 0xe4, 0x25, 0xa1, 0x5b, 0x78, 0x78, 0xe9, 0x90, 0x76, 0xcb, 0xfe, 0xbc, 0xdb,
0xfc, 0xe9, 0x2d, 0xba, 0xdb, 0xf6, 0xc3, 0xc0, 0x3f, 0x95, 0xf5, 0xcf, 0x00, 0x00, 0x00, 0xff,
0xff, 0x1b, 0x65, 0x3d, 0xab, 0x4d, 0x03, 0x00, 0x00,
func init() { proto.RegisterFile("ssh.proto", fileDescriptor14) }
var fileDescriptor14 = []byte{
// 423 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0xc6, 0x8d, 0x13, 0x91, 0x89, 0x8b, 0xa2, 0xa5, 0x2d, 0x96, 0x05, 0xd4, 0x32, 0x17, 0x1f,
0x50, 0x84, 0xd2, 0x27, 0x40, 0x08, 0xa9, 0x70, 0x01, 0xad, 0x95, 0x13, 0x07, 0x6b, 0xb1, 0x87,
0xcd, 0x8a, 0xad, 0xd7, 0xec, 0xae, 0xa3, 0x56, 0x02, 0xf1, 0x12, 0xbc, 0x05, 0xaf, 0xc0, 0xc3,
0x21, 0xad, 0x4d, 0xb0, 0x13, 0x72, 0xa3, 0xbd, 0x79, 0xe6, 0x9b, 0x9f, 0x6f, 0xbe, 0x19, 0x2f,
0x4c, 0x8d, 0x59, 0x2f, 0x6a, 0xad, 0xac, 0x22, 0x13, 0x2e, 0x2c, 0x93, 0x37, 0x51, 0x60, 0xd6,
0x4c, 0x63, 0xd9, 0x7a, 0x93, 0x9f, 0x1e, 0x9c, 0x64, 0xd9, 0xe5, 0xaa, 0x96, 0x8a, 0x95, 0xef,
0x59, 0xf1, 0x99, 0xe2, 0x97, 0x06, 0x8d, 0x25, 0x4b, 0x00, 0x8d, 0xb5, 0x32, 0xc2, 0x2a, 0x7d,
0x13, 0x7a, 0xb1, 0x97, 0xce, 0x96, 0x64, 0xd1, 0xd6, 0x58, 0xd0, 0x2d, 0x42, 0x7b, 0x51, 0xe4,
0x04, 0xc6, 0xc6, 0x96, 0xa2, 0x0a, 0x8f, 0x62, 0x2f, 0x0d, 0x68, 0x6b, 0x90, 0xe7, 0x40, 0xb8,
0xb0, 0x79, 0xa1, 0xaa, 0x4f, 0x82, 0xe7, 0xaa, 0xb6, 0x42, 0x55, 0x26, 0xf4, 0xe3, 0x51, 0x3a,
0xa5, 0x73, 0x2e, 0xec, 0x2b, 0x07, 0xbc, 0x6b, 0xfd, 0x6f, 0xfd, 0xfb, 0xa3, 0xb9, 0x4f, 0x4f,
0x7b, 0x19, 0x35, 0xd3, 0xec, 0x0a, 0x2d, 0x6a, 0x93, 0x7c, 0x85, 0xd3, 0x1d, 0xb2, 0xa6, 0x56,
0x95, 0x41, 0x72, 0x06, 0x13, 0x63, 0x4b, 0xd5, 0x58, 0xc7, 0x34, 0xa0, 0x9d, 0xd5, 0xf9, 0x51,
0xeb, 0x8e, 0x52, 0x67, 0x91, 0x0b, 0x98, 0xe1, 0xb5, 0xb0, 0xb9, 0xb1, 0xcc, 0x36, 0x26, 0x1c,
0x0d, 0xc7, 0x7b, 0x7d, 0x2d, 0x6c, 0xe6, 0x10, 0x0a, 0xb8, 0xfd, 0x4e, 0x7e, 0x79, 0xae, 0x3d,
0xc5, 0x02, 0xc5, 0x06, 0x6f, 0x47, 0xac, 0x87, 0x30, 0xe6, 0x32, 0x17, 0xa5, 0xa3, 0x34, 0xa5,
0x3e, 0x97, 0x6f, 0x4a, 0xf2, 0x0c, 0x8e, 0xb9, 0xcc, 0x7b, 0x1d, 0x7c, 0x07, 0x06, 0x5c, 0xfe,
0xad, 0x4d, 0xce, 0x61, 0xc6, 0x65, 0xde, 0x18, 0xd4, 0x15, 0xbb, 0xc2, 0x70, 0xec, 0x42, 0x80,
0xcb, 0x55, 0xe7, 0x49, 0xbe, 0xc1, 0xd9, 0x2e, 0xfb, 0xbb, 0x54, 0xaf, 0x80, 0x47, 0xdb, 0xdd,
0xbd, 0xd4, 0xc5, 0x5a, 0x6c, 0xf0, 0xbf, 0xcb, 0x97, 0x7c, 0x87, 0x70, 0xbf, 0xc9, 0x1d, 0x4e,
0xb9, 0xfc, 0x71, 0x04, 0x90, 0x65, 0x97, 0x19, 0xea, 0x8d, 0x28, 0x90, 0x50, 0x38, 0x1e, 0x1c,
0x2c, 0x79, 0xfc, 0x27, 0xff, 0x5f, 0x3f, 0x5d, 0xf4, 0xe4, 0x00, 0xda, 0x4e, 0x90, 0xdc, 0x4b,
0xbd, 0x17, 0x1e, 0x59, 0xc1, 0x83, 0xe1, 0x1e, 0x49, 0x3f, 0x6d, 0xff, 0x3a, 0xa3, 0xa7, 0x87,
0xe0, 0x41, 0xd9, 0x0f, 0x30, 0xdf, 0x95, 0x8e, 0x9c, 0xef, 0xf1, 0x19, 0x6e, 0x2e, 0x8a, 0x0f,
0x07, 0xf4, 0x8b, 0x7f, 0x9c, 0xb8, 0xd7, 0xe6, 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6,
0xa6, 0x53, 0xee, 0x90, 0x04, 0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/wiki.pb.go
View file @ 27bdba30
......@@ -26,7 +26,7 @@ type WikiCommitDetails struct {
func (m *WikiCommitDetails) Reset() { *m = WikiCommitDetails{} }
func (m *WikiCommitDetails) String() string { return proto.CompactTextString(m) }
func (*WikiCommitDetails) ProtoMessage() {}
func (*WikiCommitDetails) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
func (*WikiCommitDetails) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} }
func (m *WikiCommitDetails) GetName() []byte {
if m != nil {
......@@ -57,7 +57,7 @@ type WikiPageVersion struct {
func (m *WikiPageVersion) Reset() { *m = WikiPageVersion{} }
func (m *WikiPageVersion) String() string { return proto.CompactTextString(m) }
func (*WikiPageVersion) ProtoMessage() {}
func (*WikiPageVersion) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
func (*WikiPageVersion) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{1} }
func (m *WikiPageVersion) GetCommit() *GitCommit {
if m != nil {
......@@ -89,7 +89,7 @@ type WikiPage struct {
func (m *WikiPage) Reset() { *m = WikiPage{} }
func (m *WikiPage) String() string { return proto.CompactTextString(m) }
func (*WikiPage) ProtoMessage() {}
func (*WikiPage) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
func (*WikiPage) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{2} }
func (m *WikiPage) GetVersion() *WikiPageVersion {
if m != nil {
......@@ -157,7 +157,7 @@ type WikiGetPageVersionsRequest struct {
func (m *WikiGetPageVersionsRequest) Reset() { *m = WikiGetPageVersionsRequest{} }
func (m *WikiGetPageVersionsRequest) String() string { return proto.CompactTextString(m) }
func (*WikiGetPageVersionsRequest) ProtoMessage() {}
func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{3} }
func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{3} }
func (m *WikiGetPageVersionsRequest) GetRepository() *Repository {
if m != nil {
......@@ -194,7 +194,7 @@ type WikiGetPageVersionsResponse struct {
func (m *WikiGetPageVersionsResponse) Reset() { *m = WikiGetPageVersionsResponse{} }
func (m *WikiGetPageVersionsResponse) String() string { return proto.CompactTextString(m) }
func (*WikiGetPageVersionsResponse) ProtoMessage() {}
func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{4} }
func (m *WikiGetPageVersionsResponse) GetVersions() []*WikiPageVersion {
if m != nil {
......@@ -217,7 +217,7 @@ type WikiWritePageRequest struct {
func (m *WikiWritePageRequest) Reset() { *m = WikiWritePageRequest{} }
func (m *WikiWritePageRequest) String() string { return proto.CompactTextString(m) }
func (*WikiWritePageRequest) ProtoMessage() {}
func (*WikiWritePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{5} }
func (*WikiWritePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{5} }
func (m *WikiWritePageRequest) GetRepository() *Repository {
if m != nil {
......@@ -261,7 +261,7 @@ type WikiWritePageResponse struct {
func (m *WikiWritePageResponse) Reset() { *m = WikiWritePageResponse{} }
func (m *WikiWritePageResponse) String() string { return proto.CompactTextString(m) }
func (*WikiWritePageResponse) ProtoMessage() {}
func (*WikiWritePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{6} }
func (*WikiWritePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{6} }
func (m *WikiWritePageResponse) GetDuplicateError() []byte {
if m != nil {
......@@ -284,7 +284,7 @@ type WikiUpdatePageRequest struct {
func (m *WikiUpdatePageRequest) Reset() { *m = WikiUpdatePageRequest{} }
func (m *WikiUpdatePageRequest) String() string { return proto.CompactTextString(m) }
func (*WikiUpdatePageRequest) ProtoMessage() {}
func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{7} }
func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{7} }
func (m *WikiUpdatePageRequest) GetRepository() *Repository {
if m != nil {
......@@ -335,7 +335,7 @@ type WikiUpdatePageResponse struct {
func (m *WikiUpdatePageResponse) Reset() { *m = WikiUpdatePageResponse{} }
func (m *WikiUpdatePageResponse) String() string { return proto.CompactTextString(m) }
func (*WikiUpdatePageResponse) ProtoMessage() {}
func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{8} }
func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{8} }
func (m *WikiUpdatePageResponse) GetError() []byte {
if m != nil {
......@@ -353,7 +353,7 @@ type WikiDeletePageRequest struct {
func (m *WikiDeletePageRequest) Reset() { *m = WikiDeletePageRequest{} }
func (m *WikiDeletePageRequest) String() string { return proto.CompactTextString(m) }
func (*WikiDeletePageRequest) ProtoMessage() {}
func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{9} }
func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{9} }
func (m *WikiDeletePageRequest) GetRepository() *Repository {
if m != nil {
......@@ -382,7 +382,7 @@ type WikiDeletePageResponse struct {
func (m *WikiDeletePageResponse) Reset() { *m = WikiDeletePageResponse{} }
func (m *WikiDeletePageResponse) String() string { return proto.CompactTextString(m) }
func (*WikiDeletePageResponse) ProtoMessage() {}
func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{10} }
func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{10} }
type WikiFindPageRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
......@@ -394,7 +394,7 @@ type WikiFindPageRequest struct {
func (m *WikiFindPageRequest) Reset() { *m = WikiFindPageRequest{} }
func (m *WikiFindPageRequest) String() string { return proto.CompactTextString(m) }
func (*WikiFindPageRequest) ProtoMessage() {}
func (*WikiFindPageRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{11} }
func (*WikiFindPageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{11} }
func (m *WikiFindPageRequest) GetRepository() *Repository {
if m != nil {
......@@ -433,7 +433,7 @@ type WikiFindPageResponse struct {
func (m *WikiFindPageResponse) Reset() { *m = WikiFindPageResponse{} }
func (m *WikiFindPageResponse) String() string { return proto.CompactTextString(m) }
func (*WikiFindPageResponse) ProtoMessage() {}
func (*WikiFindPageResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{12} }
func (*WikiFindPageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{12} }
func (m *WikiFindPageResponse) GetPage() *WikiPage {
if m != nil {
......@@ -452,7 +452,7 @@ type WikiFindFileRequest struct {
func (m *WikiFindFileRequest) Reset() { *m = WikiFindFileRequest{} }
func (m *WikiFindFileRequest) String() string { return proto.CompactTextString(m) }
func (*WikiFindFileRequest) ProtoMessage() {}
func (*WikiFindFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{13} }
func (*WikiFindFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{13} }
func (m *WikiFindFileRequest) GetRepository() *Repository {
if m != nil {
......@@ -486,7 +486,7 @@ type WikiFindFileResponse struct {
func (m *WikiFindFileResponse) Reset() { *m = WikiFindFileResponse{} }
func (m *WikiFindFileResponse) String() string { return proto.CompactTextString(m) }
func (*WikiFindFileResponse) ProtoMessage() {}
func (*WikiFindFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{14} }
func (*WikiFindFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{14} }
func (m *WikiFindFileResponse) GetName() []byte {
if m != nil {
......@@ -523,7 +523,7 @@ type WikiGetAllPagesRequest struct {
func (m *WikiGetAllPagesRequest) Reset() { *m = WikiGetAllPagesRequest{} }
func (m *WikiGetAllPagesRequest) String() string { return proto.CompactTextString(m) }
func (*WikiGetAllPagesRequest) ProtoMessage() {}
func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{15} }
func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{15} }
func (m *WikiGetAllPagesRequest) GetRepository() *Repository {
if m != nil {
......@@ -542,7 +542,7 @@ type WikiGetAllPagesResponse struct {
func (m *WikiGetAllPagesResponse) Reset() { *m = WikiGetAllPagesResponse{} }
func (m *WikiGetAllPagesResponse) String() string { return proto.CompactTextString(m) }
func (*WikiGetAllPagesResponse) ProtoMessage() {}
func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{16} }
func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{16} }
func (m *WikiGetAllPagesResponse) GetPage() *WikiPage {
if m != nil {
......@@ -558,6 +558,62 @@ func (m *WikiGetAllPagesResponse) GetEndOfPage() bool {
return false
}
type WikiGetFormattedDataRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
Title []byte `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
Revision []byte `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
Directory []byte `protobuf:"bytes,4,opt,name=directory,proto3" json:"directory,omitempty"`
}
func (m *WikiGetFormattedDataRequest) Reset() { *m = WikiGetFormattedDataRequest{} }
func (m *WikiGetFormattedDataRequest) String() string { return proto.CompactTextString(m) }
func (*WikiGetFormattedDataRequest) ProtoMessage() {}
func (*WikiGetFormattedDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{17} }
func (m *WikiGetFormattedDataRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *WikiGetFormattedDataRequest) GetTitle() []byte {
if m != nil {
return m.Title
}
return nil
}
func (m *WikiGetFormattedDataRequest) GetRevision() []byte {
if m != nil {
return m.Revision
}
return nil
}
func (m *WikiGetFormattedDataRequest) GetDirectory() []byte {
if m != nil {
return m.Directory
}
return nil
}
type WikiGetFormattedDataResponse struct {
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *WikiGetFormattedDataResponse) Reset() { *m = WikiGetFormattedDataResponse{} }
func (m *WikiGetFormattedDataResponse) String() string { return proto.CompactTextString(m) }
func (*WikiGetFormattedDataResponse) ProtoMessage() {}
func (*WikiGetFormattedDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{18} }
func (m *WikiGetFormattedDataResponse) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func init() {
proto.RegisterType((*WikiCommitDetails)(nil), "gitaly.WikiCommitDetails")
proto.RegisterType((*WikiPageVersion)(nil), "gitaly.WikiPageVersion")
......@@ -576,6 +632,8 @@ func init() {
proto.RegisterType((*WikiFindFileResponse)(nil), "gitaly.WikiFindFileResponse")
proto.RegisterType((*WikiGetAllPagesRequest)(nil), "gitaly.WikiGetAllPagesRequest")
proto.RegisterType((*WikiGetAllPagesResponse)(nil), "gitaly.WikiGetAllPagesResponse")
proto.RegisterType((*WikiGetFormattedDataRequest)(nil), "gitaly.WikiGetFormattedDataRequest")
proto.RegisterType((*WikiGetFormattedDataResponse)(nil), "gitaly.WikiGetFormattedDataResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
......@@ -597,6 +655,7 @@ type WikiServiceClient interface {
WikiFindPage(ctx context.Context, in *WikiFindPageRequest, opts ...grpc.CallOption) (WikiService_WikiFindPageClient, error)
WikiFindFile(ctx context.Context, in *WikiFindFileRequest, opts ...grpc.CallOption) (WikiService_WikiFindFileClient, error)
WikiGetAllPages(ctx context.Context, in *WikiGetAllPagesRequest, opts ...grpc.CallOption) (WikiService_WikiGetAllPagesClient, error)
WikiGetFormattedData(ctx context.Context, in *WikiGetFormattedDataRequest, opts ...grpc.CallOption) (WikiService_WikiGetFormattedDataClient, error)
}
type wikiServiceClient struct {
......@@ -812,6 +871,38 @@ func (x *wikiServiceWikiGetAllPagesClient) Recv() (*WikiGetAllPagesResponse, err
return m, nil
}
func (c *wikiServiceClient) WikiGetFormattedData(ctx context.Context, in *WikiGetFormattedDataRequest, opts ...grpc.CallOption) (WikiService_WikiGetFormattedDataClient, error) {
stream, err := grpc.NewClientStream(ctx, &_WikiService_serviceDesc.Streams[6], c.cc, "/gitaly.WikiService/WikiGetFormattedData", opts...)
if err != nil {
return nil, err
}
x := &wikiServiceWikiGetFormattedDataClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type WikiService_WikiGetFormattedDataClient interface {
Recv() (*WikiGetFormattedDataResponse, error)
grpc.ClientStream
}
type wikiServiceWikiGetFormattedDataClient struct {
grpc.ClientStream
}
func (x *wikiServiceWikiGetFormattedDataClient) Recv() (*WikiGetFormattedDataResponse, error) {
m := new(WikiGetFormattedDataResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for WikiService service
type WikiServiceServer interface {
......@@ -823,6 +914,7 @@ type WikiServiceServer interface {
WikiFindPage(*WikiFindPageRequest, WikiService_WikiFindPageServer) error
WikiFindFile(*WikiFindFileRequest, WikiService_WikiFindFileServer) error
WikiGetAllPages(*WikiGetAllPagesRequest, WikiService_WikiGetAllPagesServer) error
WikiGetFormattedData(*WikiGetFormattedDataRequest, WikiService_WikiGetFormattedDataServer) error
}
func RegisterWikiServiceServer(s *grpc.Server, srv WikiServiceServer) {
......@@ -983,6 +1075,27 @@ func (x *wikiServiceWikiGetAllPagesServer) Send(m *WikiGetAllPagesResponse) erro
return x.ServerStream.SendMsg(m)
}
func _WikiService_WikiGetFormattedData_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(WikiGetFormattedDataRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(WikiServiceServer).WikiGetFormattedData(m, &wikiServiceWikiGetFormattedDataServer{stream})
}
type WikiService_WikiGetFormattedDataServer interface {
Send(*WikiGetFormattedDataResponse) error
grpc.ServerStream
}
type wikiServiceWikiGetFormattedDataServer struct {
grpc.ServerStream
}
func (x *wikiServiceWikiGetFormattedDataServer) Send(m *WikiGetFormattedDataResponse) error {
return x.ServerStream.SendMsg(m)
}
var _WikiService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.WikiService",
HandlerType: (*WikiServiceServer)(nil),
......@@ -1023,65 +1136,73 @@ var _WikiService_serviceDesc = grpc.ServiceDesc{
Handler: _WikiService_WikiGetAllPages_Handler,
ServerStreams: true,
},
{
StreamName: "WikiGetFormattedData",
Handler: _WikiService_WikiGetFormattedData_Handler,
ServerStreams: true,
},
},
Metadata: "wiki.proto",
}
func init() { proto.RegisterFile("wiki.proto", fileDescriptor14) }
var fileDescriptor14 = []byte{
// 846 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x72, 0xdc, 0x44,
0x10, 0x8e, 0xbc, 0xeb, 0x5d, 0x6d, 0xdb, 0x71, 0xc8, 0x10, 0x12, 0x45, 0x36, 0xc6, 0x35, 0x50,
0x85, 0xb9, 0xb8, 0xc0, 0xb9, 0x72, 0x08, 0x85, 0x89, 0x2f, 0x50, 0x18, 0x25, 0xc4, 0x47, 0xd5,
0x64, 0xd5, 0xf6, 0x4e, 0x45, 0x7f, 0x8c, 0x66, 0xd7, 0xb5, 0x8f, 0x42, 0x15, 0x4f, 0xc0, 0xe3,
0xf0, 0x06, 0x1c, 0xb9, 0xf2, 0x04, 0xd4, 0xfc, 0x68, 0x35, 0xd2, 0xfe, 0x50, 0x61, 0xc9, 0x4d,
0xd3, 0xdd, 0xf3, 0x4d, 0x7f, 0x5f, 0x4f, 0xf7, 0x08, 0xe0, 0x8e, 0xbf, 0xe5, 0x67, 0xa5, 0x28,
0x64, 0x41, 0x06, 0xb7, 0x5c, 0xb2, 0x74, 0x1e, 0xee, 0x57, 0x13, 0x26, 0x30, 0x31, 0x56, 0x7a,
0x0d, 0x0f, 0xaf, 0xf9, 0x5b, 0xfe, 0x6d, 0x91, 0x65, 0x5c, 0x5e, 0xa0, 0x64, 0x3c, 0xad, 0x08,
0x81, 0x7e, 0xce, 0x32, 0x0c, 0xbc, 0x13, 0xef, 0x74, 0x3f, 0xd2, 0xdf, 0xe4, 0x11, 0xec, 0x62,
0xc6, 0x78, 0x1a, 0xec, 0x68, 0xa3, 0x59, 0x90, 0x00, 0x86, 0x19, 0x56, 0x15, 0xbb, 0xc5, 0xa0,
0xa7, 0xed, 0xf5, 0x92, 0xbe, 0x82, 0x07, 0x0a, 0xf8, 0x8a, 0xdd, 0xe2, 0x6b, 0x14, 0x15, 0x2f,
0x72, 0xf2, 0x05, 0x0c, 0xc6, 0xfa, 0x1c, 0x0d, 0xbc, 0x77, 0xfe, 0xf0, 0xcc, 0xa4, 0x74, 0x76,
0xc9, 0xa5, 0x49, 0x20, 0xb2, 0x01, 0xe4, 0x31, 0x0c, 0x6e, 0x0a, 0x91, 0x31, 0xa9, 0x8f, 0x1b,
0x45, 0x76, 0x45, 0xff, 0xf2, 0xc0, 0xaf, 0x61, 0xc9, 0x57, 0x30, 0x9c, 0x19, 0x68, 0x0b, 0xf8,
0xa4, 0x06, 0xec, 0x9c, 0x1c, 0xd5, 0x71, 0xeb, 0x70, 0x15, 0x3b, 0xc9, 0x65, 0x5a, 0xb3, 0x30,
0x0b, 0xf2, 0x14, 0xfc, 0xa9, 0x48, 0xe3, 0x92, 0xc9, 0x49, 0xd0, 0xd7, 0xf1, 0xc3, 0xa9, 0x48,
0xaf, 0x98, 0x9c, 0x28, 0x89, 0xb4, 0x79, 0xd7, 0x48, 0x54, 0x5a, 0x9b, 0x96, 0x6d, 0xe0, 0xc8,
0x76, 0x0c, 0x30, 0xe1, 0x95, 0x2c, 0x04, 0x1f, 0xb3, 0x34, 0x18, 0x9e, 0x78, 0xa7, 0x7e, 0xe4,
0x58, 0xd4, 0x11, 0x82, 0xdd, 0xc5, 0x09, 0x93, 0x2c, 0xf0, 0x8d, 0x82, 0x82, 0xdd, 0x5d, 0x30,
0xc9, 0xe8, 0x6f, 0x1e, 0x84, 0x8a, 0xc8, 0x25, 0x4a, 0x87, 0x4b, 0x15, 0xe1, 0x2f, 0x53, 0xac,
0x24, 0x39, 0x07, 0x10, 0x58, 0x16, 0x15, 0x97, 0x85, 0x98, 0x5b, 0x01, 0x48, 0x2d, 0x40, 0xb4,
0xf0, 0x44, 0x4e, 0x14, 0x39, 0x84, 0x51, 0xc9, 0x6e, 0xd1, 0x30, 0x32, 0x85, 0xf4, 0x95, 0xa1,
0xa1, 0x64, 0x0b, 0xb9, 0x1b, 0xe9, 0x6f, 0x95, 0x5e, 0x89, 0x22, 0xd6, 0xf6, 0xbe, 0xb6, 0x0f,
0x4b, 0x14, 0x2a, 0x1d, 0x1a, 0xc1, 0xe1, 0xca, 0xec, 0xaa, 0xb2, 0xc8, 0x2b, 0x24, 0xcf, 0xc0,
0xb7, 0xa2, 0x57, 0x81, 0x77, 0xd2, 0xdb, 0x54, 0x9d, 0x45, 0x20, 0xfd, 0xc3, 0x83, 0x47, 0xca,
0x7b, 0x2d, 0xb8, 0x44, 0x15, 0xb2, 0x0d, 0xd9, 0xba, 0x1c, 0x3b, 0x4e, 0x39, 0x9a, 0xfa, 0xf7,
0x5a, 0xf5, 0x7f, 0x0e, 0x07, 0xe6, 0xe6, 0xc5, 0x89, 0xe9, 0x01, 0xcd, 0x76, 0xef, 0xfc, 0xa9,
0x9b, 0x73, 0xab, 0x49, 0xa2, 0xfb, 0xe3, 0x56, 0xcf, 0x04, 0x30, 0x1c, 0x17, 0xb9, 0xc4, 0x5c,
0xda, 0x3b, 0x51, 0x2f, 0xe9, 0x73, 0xf8, 0xa8, 0xc3, 0xc9, 0x4a, 0xf4, 0x39, 0x3c, 0x48, 0xa6,
0x65, 0xca, 0xc7, 0x4c, 0x62, 0x8c, 0x42, 0x14, 0xc2, 0x76, 0xdc, 0xc1, 0xc2, 0xfc, 0x9d, 0xb2,
0xd2, 0xbf, 0x3d, 0x03, 0xf1, 0x73, 0x99, 0xb0, 0xed, 0x75, 0xd9, 0x78, 0x09, 0x56, 0x37, 0x42,
0x23, 0x5b, 0xff, 0x5f, 0x64, 0xdb, 0xfd, 0xef, 0xb2, 0x0d, 0xda, 0xb2, 0x9d, 0xc1, 0xe3, 0x2e,
0x67, 0xab, 0x9b, 0x1a, 0x45, 0x8e, 0x5a, 0x66, 0x41, 0x7f, 0xb7, 0x22, 0x5d, 0x60, 0x8a, 0xef,
0x59, 0xa4, 0x65, 0xda, 0xbd, 0x77, 0xa3, 0x4d, 0x03, 0x43, 0xce, 0xcd, 0xd5, 0x90, 0xa3, 0xbf,
0x7a, 0xf0, 0xa1, 0x72, 0xbd, 0xe0, 0x79, 0xb2, 0x2d, 0x89, 0x45, 0x31, 0x77, 0xdc, 0x62, 0x86,
0xe0, 0x0b, 0x9c, 0x71, 0x3d, 0x37, 0x4d, 0x95, 0x17, 0x6b, 0x72, 0x04, 0xa3, 0x84, 0x0b, 0x1c,
0xeb, 0x43, 0xfa, 0xda, 0xd9, 0x18, 0xe8, 0xd7, 0xa6, 0x3b, 0x9b, 0xd4, 0x6c, 0x41, 0x3e, 0xb3,
0x93, 0xc3, 0x64, 0xf5, 0x41, 0xb7, 0xcf, 0xcd, 0x2c, 0xa1, 0xf3, 0x86, 0xd8, 0x0b, 0x9e, 0xfe,
0xef, 0xad, 0xbd, 0x81, 0x16, 0x9d, 0x35, 0x89, 0x9b, 0xa3, 0x6d, 0xe2, 0xab, 0x1e, 0xba, 0x43,
0x18, 0x65, 0x3c, 0xc3, 0x58, 0xce, 0x4b, 0xb4, 0xaf, 0x84, 0xaf, 0x0c, 0xaf, 0xe6, 0x25, 0xb6,
0xc6, 0x75, 0xaf, 0x35, 0xae, 0x17, 0x2f, 0x42, 0xbf, 0x79, 0x11, 0xe8, 0xf7, 0xa6, 0xcc, 0x97,
0x28, 0xbf, 0x49, 0x53, 0x25, 0xc5, 0x36, 0xd3, 0x9b, 0xc6, 0xf0, 0x64, 0x09, 0xed, 0x5d, 0x2a,
0x40, 0x8e, 0x61, 0x0f, 0xf3, 0x24, 0x2e, 0x6e, 0xcc, 0x40, 0xdf, 0xd1, 0xaf, 0xd1, 0x08, 0xf3,
0xe4, 0xc7, 0x1b, 0x15, 0x75, 0xfe, 0x67, 0x1f, 0xf6, 0xd4, 0x96, 0x97, 0x28, 0x66, 0x7c, 0x8c,
0xe4, 0x8d, 0xa9, 0x58, 0x67, 0xc4, 0x13, 0xea, 0xc2, 0xaf, 0x7e, 0x9d, 0xc2, 0x4f, 0x37, 0xc6,
0xd8, 0xbb, 0x7e, 0xef, 0x4b, 0x8f, 0x5c, 0xc1, 0xfd, 0xd6, 0x74, 0x24, 0x47, 0xee, 0xce, 0xee,
0x43, 0x10, 0x7e, 0xbc, 0xc6, 0x5b, 0x23, 0x9e, 0x7a, 0xe4, 0x25, 0x1c, 0xb4, 0x07, 0x07, 0x69,
0x6d, 0x5a, 0x1a, 0xa2, 0xe1, 0xf1, 0x3a, 0xb7, 0x03, 0xfa, 0x93, 0x01, 0x6d, 0x1a, 0xb6, 0x0d,
0xba, 0x34, 0x74, 0xda, 0xa0, 0x2b, 0xfa, 0xfc, 0x1e, 0xf9, 0x01, 0xf6, 0xdd, 0x6e, 0x22, 0x87,
0xee, 0x8e, 0x4e, 0xfb, 0x87, 0x47, 0xab, 0x9d, 0x8e, 0x90, 0x0e, 0x9c, 0xba, 0xe3, 0xcb, 0x70,
0x4e, 0xd3, 0x2d, 0xc3, 0xb9, 0x6d, 0xa1, 0xe1, 0x5e, 0x9b, 0xff, 0x37, 0xe7, 0xb2, 0x91, 0xe3,
0x4e, 0x4d, 0x3b, 0x77, 0x3a, 0xfc, 0x64, 0xad, 0xbf, 0xc1, 0x7d, 0x33, 0xd0, 0xff, 0x9d, 0xcf,
0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xbb, 0xf3, 0xde, 0x9b, 0x0a, 0x00, 0x00,
func init() { proto.RegisterFile("wiki.proto", fileDescriptor15) }
var fileDescriptor15 = []byte{
// 893 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x72, 0xdc, 0x44,
0x10, 0x8e, 0xbc, 0x7f, 0xda, 0xb6, 0xe3, 0x90, 0x21, 0x24, 0x8a, 0x6c, 0x8c, 0x6b, 0x48, 0x15,
0xe6, 0xe2, 0x82, 0xcd, 0x95, 0x43, 0x28, 0x8c, 0x7d, 0x81, 0xc2, 0x28, 0x21, 0x3e, 0xaa, 0x26,
0xab, 0xb6, 0x3d, 0x15, 0xfd, 0x31, 0x1a, 0xdb, 0xb5, 0x8f, 0x42, 0x15, 0x17, 0xae, 0x3c, 0x09,
0x67, 0xde, 0x82, 0x2b, 0x4f, 0x40, 0xcd, 0x8f, 0x56, 0x23, 0xad, 0xbc, 0x54, 0x30, 0x54, 0x71,
0xdb, 0xe9, 0x19, 0x7d, 0xd3, 0xdf, 0xd7, 0xd3, 0x5f, 0x2f, 0xc0, 0x0d, 0x7f, 0xcb, 0x0f, 0x4b,
0x51, 0xc8, 0x82, 0x8c, 0x2f, 0xb8, 0x64, 0xe9, 0x22, 0xdc, 0xaa, 0x2e, 0x99, 0xc0, 0xc4, 0x44,
0xe9, 0x19, 0x3c, 0x3c, 0xe3, 0x6f, 0xf9, 0x57, 0x45, 0x96, 0x71, 0x79, 0x84, 0x92, 0xf1, 0xb4,
0x22, 0x04, 0x86, 0x39, 0xcb, 0x30, 0xf0, 0xf6, 0xbd, 0x83, 0xad, 0x48, 0xff, 0x26, 0x8f, 0x60,
0x84, 0x19, 0xe3, 0x69, 0xb0, 0xa1, 0x83, 0x66, 0x41, 0x02, 0x98, 0x64, 0x58, 0x55, 0xec, 0x02,
0x83, 0x81, 0x8e, 0xd7, 0x4b, 0xfa, 0x0a, 0x1e, 0x28, 0xe0, 0x53, 0x76, 0x81, 0xaf, 0x51, 0x54,
0xbc, 0xc8, 0xc9, 0xa7, 0x30, 0x9e, 0xeb, 0x7b, 0x34, 0xf0, 0xe6, 0xec, 0xe1, 0xa1, 0x49, 0xe9,
0xf0, 0x84, 0x4b, 0x93, 0x40, 0x64, 0x0f, 0x90, 0xc7, 0x30, 0x3e, 0x2f, 0x44, 0xc6, 0xa4, 0xbe,
0x6e, 0x1a, 0xd9, 0x15, 0xfd, 0xc3, 0x03, 0xbf, 0x86, 0x25, 0x9f, 0xc3, 0xe4, 0xda, 0x40, 0x5b,
0xc0, 0x27, 0x35, 0x60, 0xe7, 0xe6, 0xa8, 0x3e, 0x77, 0x1b, 0xae, 0x62, 0x27, 0xb9, 0x4c, 0x6b,
0x16, 0x66, 0x41, 0x9e, 0x82, 0x7f, 0x25, 0xd2, 0xb8, 0x64, 0xf2, 0x32, 0x18, 0xea, 0xf3, 0x93,
0x2b, 0x91, 0x9e, 0x32, 0x79, 0xa9, 0x24, 0xd2, 0xe1, 0x91, 0x91, 0xa8, 0xb4, 0x31, 0x2d, 0xdb,
0xd8, 0x91, 0x6d, 0x0f, 0xe0, 0x92, 0x57, 0xb2, 0x10, 0x7c, 0xce, 0xd2, 0x60, 0xb2, 0xef, 0x1d,
0xf8, 0x91, 0x13, 0x51, 0x57, 0x08, 0x76, 0x13, 0x27, 0x4c, 0xb2, 0xc0, 0x37, 0x0a, 0x0a, 0x76,
0x73, 0xc4, 0x24, 0xa3, 0x3f, 0x7b, 0x10, 0x2a, 0x22, 0x27, 0x28, 0x1d, 0x2e, 0x55, 0x84, 0x3f,
0x5e, 0x61, 0x25, 0xc9, 0x0c, 0x40, 0x60, 0x59, 0x54, 0x5c, 0x16, 0x62, 0x61, 0x05, 0x20, 0xb5,
0x00, 0xd1, 0x72, 0x27, 0x72, 0x4e, 0x91, 0x1d, 0x98, 0x96, 0xec, 0x02, 0x0d, 0x23, 0x53, 0x48,
0x5f, 0x05, 0x1a, 0x4a, 0xb6, 0x90, 0xa3, 0x48, 0xff, 0x56, 0xe9, 0x95, 0x28, 0x62, 0x1d, 0x1f,
0xea, 0xf8, 0xa4, 0x44, 0xa1, 0xd2, 0xa1, 0x11, 0xec, 0xf4, 0x66, 0x57, 0x95, 0x45, 0x5e, 0x21,
0x79, 0x0e, 0xbe, 0x15, 0xbd, 0x0a, 0xbc, 0xfd, 0xc1, 0xba, 0xea, 0x2c, 0x0f, 0xd2, 0xdf, 0x3d,
0x78, 0xa4, 0x76, 0xcf, 0x04, 0x97, 0xa8, 0x8e, 0xdc, 0x85, 0x6c, 0x5d, 0x8e, 0x0d, 0xa7, 0x1c,
0x4d, 0xfd, 0x07, 0xad, 0xfa, 0xbf, 0x80, 0x6d, 0xf3, 0xf2, 0xe2, 0xc4, 0xf4, 0x80, 0x66, 0xbb,
0x39, 0x7b, 0xea, 0xe6, 0xdc, 0x6a, 0x92, 0xe8, 0xfe, 0xbc, 0xd5, 0x33, 0x01, 0x4c, 0xe6, 0x45,
0x2e, 0x31, 0x97, 0xf6, 0x4d, 0xd4, 0x4b, 0xfa, 0x02, 0x3e, 0xe8, 0x70, 0xb2, 0x12, 0x7d, 0x02,
0x0f, 0x92, 0xab, 0x32, 0xe5, 0x73, 0x26, 0x31, 0x46, 0x21, 0x0a, 0x61, 0x3b, 0x6e, 0x7b, 0x19,
0xfe, 0x5a, 0x45, 0xe9, 0x9f, 0x9e, 0x81, 0xf8, 0xa1, 0x4c, 0xd8, 0xdd, 0x75, 0x59, 0xfb, 0x08,
0xfa, 0x1b, 0xa1, 0x91, 0x6d, 0xf8, 0x37, 0xb2, 0x8d, 0xfe, 0xb9, 0x6c, 0xe3, 0xb6, 0x6c, 0x87,
0xf0, 0xb8, 0xcb, 0xd9, 0xea, 0xa6, 0xac, 0xc8, 0x51, 0xcb, 0x2c, 0xe8, 0xaf, 0x56, 0xa4, 0x23,
0x4c, 0xf1, 0x3f, 0x16, 0x69, 0x95, 0xf6, 0xe0, 0xdd, 0x68, 0xd3, 0xc0, 0x90, 0x73, 0x73, 0x35,
0xe4, 0xe8, 0x4f, 0x1e, 0xbc, 0xaf, 0xb6, 0x8e, 0x79, 0x9e, 0xdc, 0x95, 0xc4, 0xb2, 0x98, 0x1b,
0x6e, 0x31, 0x43, 0xf0, 0x05, 0x5e, 0x73, 0xed, 0x9b, 0xa6, 0xca, 0xcb, 0x35, 0xd9, 0x85, 0x69,
0xc2, 0x05, 0xce, 0xf5, 0x25, 0x43, 0xbd, 0xd9, 0x04, 0xe8, 0x17, 0xa6, 0x3b, 0x9b, 0xd4, 0x6c,
0x41, 0x9e, 0x59, 0xe7, 0x30, 0x59, 0xbd, 0xd7, 0xed, 0x73, 0xe3, 0x25, 0x74, 0xd1, 0x10, 0x3b,
0xe6, 0xe9, 0xbf, 0xde, 0xda, 0x6b, 0x68, 0xd1, 0xeb, 0x26, 0x71, 0x73, 0xb5, 0x4d, 0xbc, 0x6f,
0xd0, 0xed, 0xc0, 0x34, 0xe3, 0x19, 0xc6, 0x72, 0x51, 0xa2, 0x9d, 0x12, 0xbe, 0x0a, 0xbc, 0x5a,
0x94, 0xd8, 0xb2, 0xeb, 0x41, 0xcb, 0xae, 0x97, 0x13, 0x61, 0xd8, 0x4c, 0x04, 0xfa, 0x8d, 0x29,
0xf3, 0x09, 0xca, 0x2f, 0xd3, 0x54, 0x49, 0x71, 0x17, 0xf7, 0xa6, 0x31, 0x3c, 0x59, 0x41, 0x7b,
0x97, 0x0a, 0x90, 0x3d, 0xd8, 0xc4, 0x3c, 0x89, 0x8b, 0x73, 0x63, 0xe8, 0x1b, 0x7a, 0x1a, 0x4d,
0x31, 0x4f, 0xbe, 0x3b, 0xd7, 0x96, 0xfe, 0x8b, 0xb7, 0xf4, 0xf4, 0x63, 0xdd, 0xe0, 0x12, 0x13,
0xc5, 0xed, 0xff, 0xf4, 0x06, 0x67, 0xb0, 0xdb, 0x9f, 0x62, 0x53, 0x52, 0x5d, 0x1d, 0x5b, 0x52,
0xf5, 0x7b, 0xf6, 0xdb, 0x08, 0x36, 0xd5, 0x47, 0x2f, 0x51, 0x5c, 0xf3, 0x39, 0x92, 0x37, 0xe6,
0x25, 0x76, 0x46, 0x17, 0xa1, 0xae, 0x6c, 0xfd, 0x53, 0x37, 0xfc, 0x78, 0xed, 0x19, 0xdb, 0xc3,
0xf7, 0x3e, 0xf3, 0xc8, 0x29, 0xdc, 0x6f, 0xb9, 0x3e, 0xd9, 0x75, 0xbf, 0xec, 0x0e, 0xb8, 0xf0,
0xc3, 0x5b, 0x76, 0x6b, 0xc4, 0x03, 0x8f, 0xbc, 0x84, 0xed, 0xb6, 0x21, 0x92, 0xd6, 0x47, 0x2b,
0xc3, 0x21, 0xdc, 0xbb, 0x6d, 0xdb, 0x01, 0xfd, 0xde, 0x80, 0x36, 0x46, 0xd4, 0x06, 0x5d, 0x31,
0xd3, 0x36, 0x68, 0x8f, 0x7f, 0xdd, 0x23, 0xdf, 0xc2, 0x96, 0xeb, 0x12, 0x64, 0xc7, 0xfd, 0xa2,
0x63, 0x6b, 0xe1, 0x6e, 0xff, 0xa6, 0x23, 0xa4, 0x03, 0xa7, 0x7a, 0x77, 0x15, 0xce, 0x31, 0x93,
0x55, 0x38, 0xb7, 0xdd, 0x35, 0xdc, 0x6b, 0xf3, 0xbf, 0xd4, 0x69, 0x22, 0xb2, 0xd7, 0xa9, 0x69,
0xa7, 0x57, 0xc3, 0x8f, 0x6e, 0xdd, 0x77, 0x70, 0xd1, 0x58, 0x4c, 0xf7, 0x5d, 0x92, 0xee, 0x83,
0xe9, 0x6b, 0xac, 0xf0, 0xd9, 0xfa, 0x43, 0xcd, 0x35, 0x6f, 0xc6, 0xfa, 0x6f, 0xfb, 0xf3, 0xbf,
0x02, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x50, 0x3d, 0x3a, 0xda, 0x0b, 0x00, 0x00,
}
go/vendor/gitlab.com/gitlab-org/gitaly/client/upload_archive.go 0 → 100644
View file @ 27bdba30
package client
import (
"io"
"gitlab.com/gitlab-org/gitaly/streamio"
pb "gitlab.com/gitlab-org/gitaly-proto/go"
"golang.org/x/net/context"
"google.golang.org/grpc"
)
// UploadArchive proxies an SSH git-upload-archive (git archive --remote) session to Gitaly
func UploadArchive(ctx context.Context, conn *grpc.ClientConn, stdin io.Reader, stdout, stderr io.Writer, req *pb.SSHUploadArchiveRequest) (int32, error) {
ctx2, cancel := context.WithCancel(ctx)
defer cancel()
ssh := pb.NewSSHServiceClient(conn)
stream, err := ssh.SSHUploadArchive(ctx2)
if err != nil {
return 0, err
}
if err = stream.Send(req); err != nil {
return 0, err
}
inWriter := streamio.NewWriter(func(p []byte) error {
return stream.Send(&pb.SSHUploadArchiveRequest{Stdin: p})
})
return streamHandler(func() (stdoutStderrResponse, error) {
return stream.Recv()
}, func(errC chan error) {
_, errRecv := io.Copy(inWriter, stdin)
stream.CloseSend()
errC <- errRecv
}, stdout, stderr)
}
go/vendor/vendor.json
View file @ 27bdba30
......@@ -41,13 +41,13 @@
"versionExact": "v1.0.5"
},
{
"checksumSHA1": "8Gc1ZcO7WxXstNzyePjwG90SBSU=",
"checksumSHA1": "EuiW0GPDEqCG0UhnE7zYCrc6/G0=",
"path": "gitlab.com/gitlab-org/gitaly-proto/go",
"revision": "f62abc80cb25363bf51a4f89f02654ca2f722dc8",
"revisionTime": "2018-01-17T16:23:27Z",
"revision": "4d256c2c6403d420c598c1649b1d26fa4384bb1d",
"revisionTime": "2018-03-08T23:20:01Z",
"tree": true,
"version": "v0.75.0",
"versionExact": "v0.75.0"
"version": "v0.89.0",
"versionExact": "v0.89.0"
},
{
"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",
......@@ -58,12 +58,12 @@
"versionExact": "v0.71.0"
},
{
"checksumSHA1": "s53Qjro9ZHX0DV2tCYQXLO2FHqI=",
"checksumSHA1": "CsPKG7r/N8ARlHtnHKimJiOnYiY=",
"path": "gitlab.com/gitlab-org/gitaly/client",
"revision": "95a198aef54c42fd8e84c62acc63f0cd620864b3",
"revisionTime": "2018-01-18T11:33:00Z",
"version": "v0.71.0",
"versionExact": "v0.71.0"
"revision": "5e2c70a9a670f5d675cf45f880bbbb08a5169ab8",
"revisionTime": "2018-03-13T20:33:04Z",
"version": "v0.90.0",
"versionExact": "v0.90.0"
},
{
"checksumSHA1": "mifcYH0qXpoPkX5KzXoM3mterWQ=",
......
lib/gitlab_shell.rb
View file @ 27bdba30
......@@ -12,6 +12,7 @@ class GitlabShell # rubocop:disable Metrics/ClassLength
GIT_COMMANDS = %w(git-upload-pack git-receive-pack git-upload-archive git-lfs-authenticate).freeze
GITALY_MIGRATED_COMMANDS = {
'git-upload-pack' => File.join(ROOT_PATH, 'bin', 'gitaly-upload-pack'),
'git-upload-archive' => File.join(ROOT_PATH, 'bin', 'gitaly-upload-archive'),
'git-receive-pack' => File.join(ROOT_PATH, 'bin', 'gitaly-receive-pack')
}.freeze
API_COMMANDS = %w(2fa_recovery_codes).freeze
......
spec/gitlab_shell_spec.rb
View file @ 27bdba30
......@@ -252,6 +252,61 @@ describe GitlabShell do
end
end
shared_examples_for 'upload-archive' do |command|
let(:ssh_cmd) { "#{command} gitlab-ci.git" }
let(:exec_cmd_params) { ['git-upload-archive', repo_path] }
let(:exec_cmd_log_params) { exec_cmd_params }
after { subject.exec(ssh_cmd) }
it "should process the command" do
subject.should_receive(:process_cmd).with(%W(git-upload-archive gitlab-ci.git))
end
it "should execute the command" do
subject.should_receive(:exec_cmd).with(*exec_cmd_params)
end
it "should log the command execution" do
message = "executing git command"
user_string = "user with key #{key_id}"
$logger.should_receive(:info).with(message, command: exec_cmd_log_params.join(' '), user: user_string)
end
it "should use usernames if configured to do so" do
GitlabConfig.any_instance.stub(audit_usernames: true)
$logger.should_receive(:info).with("executing git command", hash_including(user: 'John Doe'))
end
end
context 'git-upload-archive' do
it_behaves_like 'upload-archive', 'git-upload-archive'
end
context 'git upload-archive' do
it_behaves_like 'upload-archive', 'git upload-archive'
end
context 'gitaly-upload-archive' do
before do
api.stub(check_access: gitaly_check_access)
end
it_behaves_like 'upload-archive', 'git-upload-archive' do
let(:gitaly_executable) { "gitaly-upload-archive" }
let(:exec_cmd_params) do
[
File.join(ROOT_PATH, "bin", gitaly_executable),
'unix:gitaly.socket',
gitaly_message
]
end
let(:exec_cmd_log_params) do
[gitaly_executable, 'unix:gitaly.socket', gitaly_message]
end
end
end
context 'arbitrary command' do
let(:ssh_cmd) { 'arbitrary command' }
after { subject.exec(ssh_cmd) }
......
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