diff --git a/commit.proto b/commit.proto index 79eb9523178a0255c283dbc1947d841459f7a35d..63edd445adddbae0a4acc068fa6446b54d1775f4 100644 --- a/commit.proto +++ b/commit.proto @@ -4,7 +4,7 @@ package gitaly; import "shared.proto"; -service Commit { +service CommitService { rpc CommitIsAncestor(CommitIsAncestorRequest) returns (CommitIsAncestorResponse) {} rpc TreeEntry(TreeEntryRequest) returns (stream TreeEntryResponse) {}; } diff --git a/deprecated-services.proto b/deprecated-services.proto new file mode 100644 index 0000000000000000000000000000000000000000..ae0325ccacf7cc557f4a1f09920cb46b4a140b1a --- /dev/null +++ b/deprecated-services.proto @@ -0,0 +1,67 @@ +syntax = "proto3"; + +package gitaly; + +import "commit.proto"; +import "diff.proto"; +import "notifications.proto"; +import "ref.proto"; +import "smarthttp.proto"; +import "ssh.proto"; + +// TODO: remove all these legacy RPC interfaces when client references to them are removed. + +// Deprecated +service Commit { + rpc CommitIsAncestor(CommitIsAncestorRequest) returns (CommitIsAncestorResponse) { } + rpc TreeEntry(TreeEntryRequest) returns (stream TreeEntryResponse) { }; +} + +// Deprecated +service Diff { + // Returns stream of CommitDiffResponse with patches chunked over messages + rpc CommitDiff(CommitDiffRequest) returns (stream CommitDiffResponse) { }; + + // Return a stream so we can divide the response in chunks of deltas + rpc CommitDelta(CommitDeltaRequest) returns (stream CommitDeltaResponse) { }; +} + +// Deprecated +service Notifications { + rpc PostReceive(PostReceiveRequest) returns (PostReceiveResponse) { } +} + +// Deprecated +service Ref { + rpc FindDefaultBranchName(FindDefaultBranchNameRequest) returns (FindDefaultBranchNameResponse) { } + rpc FindAllBranchNames(FindAllBranchNamesRequest) returns (stream FindAllBranchNamesResponse) { } + rpc FindAllTagNames(FindAllTagNamesRequest) returns (stream FindAllTagNamesResponse) { } + // Find a Ref matching the given constraints. Response may be empty. + rpc FindRefName(FindRefNameRequest) returns (FindRefNameResponse) { } + // Return a stream so we can divide the response in chunks of branches + rpc FindLocalBranches(FindLocalBranchesRequest) returns (stream FindLocalBranchesResponse) { } +} + +// DEPRECATED +service SmartHTTP { + // The response body for GET /info/refs?service=git-upload-pack + rpc InfoRefsUploadPack(InfoRefsRequest) returns (stream InfoRefsResponse) { } + + // The response body for GET /info/refs?service=git-receive-pack + rpc InfoRefsReceivePack(InfoRefsRequest) returns (stream InfoRefsResponse) { } + + // Request and response body for POST /upload-pack + rpc PostUploadPack(stream PostUploadPackRequest) returns (stream PostUploadPackResponse) { } + + // Request and response body for POST /receive-pack + rpc PostReceivePack(stream PostReceivePackRequest) returns (stream PostReceivePackResponse) { } +} + +// DEPRECATED +service SSH { + // To forward 'git upload-pack' to Gitaly for SSH sessions + rpc SSHUploadPack(stream SSHUploadPackRequest) returns (stream SSHUploadPackResponse) { } + + // To forward 'git receive-pack' to Gitaly for SSH sessions + rpc SSHReceivePack(stream SSHReceivePackRequest) returns (stream SSHReceivePackResponse) { } +} diff --git a/diff.proto b/diff.proto index 52828765f60ddc59ce8e8ac57bfeb47d687bab7b..41b21ec2bcb203fe6e1c89853dc2e779f67b41ae 100644 --- a/diff.proto +++ b/diff.proto @@ -4,7 +4,7 @@ package gitaly; import "shared.proto"; -service Diff { +service DiffService { // Returns stream of CommitDiffResponse with patches chunked over messages rpc CommitDiff(CommitDiffRequest) returns (stream CommitDiffResponse) {}; // Return a stream so we can divide the response in chunks of deltas diff --git a/go/commit.pb.go b/go/commit.pb.go index 8cdd68c06e13a4abfcde378c6e924ffb7c0c46a0..f6721a336f0d887d1439279d2a8a60087dcd0358 100644 --- a/go/commit.pb.go +++ b/go/commit.pb.go @@ -6,6 +6,7 @@ Package gitaly is a generated protocol buffer package. It is generated from these files: commit.proto + deprecated-services.proto diff.proto notifications.proto ref.proto @@ -256,36 +257,36 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for Commit service +// Client API for CommitService service -type CommitClient interface { +type CommitServiceClient interface { CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) - TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) + TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error) } -type commitClient struct { +type commitServiceClient struct { cc *grpc.ClientConn } -func NewCommitClient(cc *grpc.ClientConn) CommitClient { - return &commitClient{cc} +func NewCommitServiceClient(cc *grpc.ClientConn) CommitServiceClient { + return &commitServiceClient{cc} } -func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) { +func (c *commitServiceClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) { out := new(CommitIsAncestorResponse) - err := grpc.Invoke(ctx, "/gitaly.Commit/CommitIsAncestor", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/gitaly.CommitService/CommitIsAncestor", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } -func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Commit_serviceDesc.Streams[0], c.cc, "/gitaly.Commit/TreeEntry", opts...) +func (c *commitServiceClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error) { + stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[0], c.cc, "/gitaly.CommitService/TreeEntry", opts...) if err != nil { return nil, err } - x := &commitTreeEntryClient{stream} + x := &commitServiceTreeEntryClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -295,16 +296,16 @@ func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts return x, nil } -type Commit_TreeEntryClient interface { +type CommitService_TreeEntryClient interface { Recv() (*TreeEntryResponse, error) grpc.ClientStream } -type commitTreeEntryClient struct { +type commitServiceTreeEntryClient struct { grpc.ClientStream } -func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) { +func (x *commitServiceTreeEntryClient) Recv() (*TreeEntryResponse, error) { m := new(TreeEntryResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -312,69 +313,69 @@ func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) { return m, nil } -// Server API for Commit service +// Server API for CommitService service -type CommitServer interface { +type CommitServiceServer interface { CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error) - TreeEntry(*TreeEntryRequest, Commit_TreeEntryServer) error + TreeEntry(*TreeEntryRequest, CommitService_TreeEntryServer) error } -func RegisterCommitServer(s *grpc.Server, srv CommitServer) { - s.RegisterService(&_Commit_serviceDesc, srv) +func RegisterCommitServiceServer(s *grpc.Server, srv CommitServiceServer) { + s.RegisterService(&_CommitService_serviceDesc, srv) } -func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _CommitService_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CommitIsAncestorRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(CommitServer).CommitIsAncestor(ctx, in) + return srv.(CommitServiceServer).CommitIsAncestor(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gitaly.Commit/CommitIsAncestor", + FullMethod: "/gitaly.CommitService/CommitIsAncestor", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest)) + return srv.(CommitServiceServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest)) } return interceptor(ctx, in, info, handler) } -func _Commit_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error { +func _CommitService_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(TreeEntryRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(CommitServer).TreeEntry(m, &commitTreeEntryServer{stream}) + return srv.(CommitServiceServer).TreeEntry(m, &commitServiceTreeEntryServer{stream}) } -type Commit_TreeEntryServer interface { +type CommitService_TreeEntryServer interface { Send(*TreeEntryResponse) error grpc.ServerStream } -type commitTreeEntryServer struct { +type commitServiceTreeEntryServer struct { grpc.ServerStream } -func (x *commitTreeEntryServer) Send(m *TreeEntryResponse) error { +func (x *commitServiceTreeEntryServer) Send(m *TreeEntryResponse) error { return x.ServerStream.SendMsg(m) } -var _Commit_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gitaly.Commit", - HandlerType: (*CommitServer)(nil), +var _CommitService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.CommitService", + HandlerType: (*CommitServiceServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "CommitIsAncestor", - Handler: _Commit_CommitIsAncestor_Handler, + Handler: _CommitService_CommitIsAncestor_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "TreeEntry", - Handler: _Commit_TreeEntry_Handler, + Handler: _CommitService_TreeEntry_Handler, ServerStreams: true, }, }, @@ -384,31 +385,31 @@ var _Commit_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("commit.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 404 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xc1, 0x6a, 0xdc, 0x30, - 0x10, 0x86, 0x57, 0xb1, 0xd7, 0x71, 0x26, 0xa6, 0xb8, 0x43, 0xa1, 0xce, 0x5e, 0x62, 0x4c, 0x0f, - 0x7b, 0x32, 0xc1, 0xa5, 0xd0, 0x6b, 0x92, 0x2e, 0xc5, 0xd0, 0xb0, 0x20, 0x0c, 0x3d, 0x16, 0xc7, - 0x16, 0x5d, 0x15, 0xdb, 0x72, 0x25, 0x25, 0xe0, 0xbe, 0x41, 0xa1, 0xef, 0xd1, 0xf7, 0xe9, 0x13, - 0x15, 0x49, 0x59, 0x37, 0x34, 0xdd, 0x53, 0x6f, 0xff, 0xcc, 0xfc, 0x1e, 0x7f, 0xfa, 0x25, 0x88, - 0x1a, 0xd1, 0xf7, 0x5c, 0xe7, 0xa3, 0x14, 0x5a, 0x60, 0xf0, 0x99, 0xeb, 0xba, 0x9b, 0x56, 0x91, - 0xda, 0xd5, 0x92, 0xb5, 0xae, 0x9b, 0x7d, 0x27, 0xf0, 0xf2, 0xda, 0xda, 0x4a, 0x75, 0x39, 0x34, - 0x4c, 0x69, 0x21, 0x29, 0xfb, 0x7a, 0xc7, 0x94, 0xc6, 0x02, 0x40, 0xb2, 0x51, 0x28, 0xae, 0x85, - 0x9c, 0x12, 0x92, 0x92, 0xf5, 0x69, 0x81, 0xb9, 0x5b, 0x93, 0xd3, 0x79, 0x42, 0x1f, 0xb9, 0xf0, - 0x1c, 0x4e, 0xeb, 0x87, 0x35, 0x9f, 0x78, 0x9b, 0x1c, 0xa5, 0x64, 0x7d, 0x42, 0x61, 0xdf, 0x2a, - 0x5b, 0x3c, 0x83, 0xb0, 0xd9, 0xf1, 0xae, 0x35, 0x53, 0xcf, 0x4e, 0x8f, 0x6d, 0x5d, 0xb6, 0xd9, - 0x05, 0x24, 0x4f, 0x51, 0xd4, 0x28, 0x06, 0xc5, 0xf0, 0x05, 0x2c, 0xef, 0xeb, 0xee, 0x8e, 0x59, - 0x8c, 0x90, 0xba, 0x22, 0xfb, 0x41, 0x20, 0xae, 0x24, 0x63, 0x9b, 0x41, 0xcb, 0xe9, 0x7f, 0xb0, - 0x57, 0x10, 0x4a, 0x76, 0xcf, 0x15, 0x17, 0x83, 0x65, 0x8e, 0xe8, 0x5c, 0x23, 0x82, 0x3f, 0xd6, - 0x7a, 0x67, 0x69, 0x23, 0x6a, 0xb5, 0xc1, 0xe9, 0x78, 0xcf, 0x75, 0xe2, 0xa7, 0x64, 0xed, 0x51, - 0x57, 0x64, 0xbf, 0x08, 0x3c, 0x7f, 0x84, 0xf3, 0x80, 0xfe, 0x16, 0x7c, 0x3d, 0x8d, 0x8e, 0xfc, - 0x59, 0xf1, 0x6a, 0x4f, 0xf2, 0xc4, 0x98, 0x6f, 0x6f, 0xbf, 0xb0, 0x46, 0x57, 0xd3, 0xc8, 0xa8, - 0xfd, 0x02, 0x63, 0xf0, 0xc4, 0x1c, 0xa2, 0x91, 0x86, 0x45, 0xf1, 0x6f, 0xcc, 0xb2, 0x78, 0xd4, - 0x6a, 0xd3, 0xeb, 0x45, 0xcb, 0x2c, 0xca, 0x92, 0x5a, 0x6d, 0x7a, 0x6d, 0xad, 0xeb, 0x64, 0xe9, - 0x98, 0x8d, 0xce, 0xde, 0x00, 0xfc, 0xf9, 0x03, 0x02, 0x04, 0xd7, 0xdb, 0x9b, 0x9b, 0xb2, 0x8a, - 0x17, 0x18, 0x82, 0x7f, 0xf5, 0x61, 0x7b, 0x15, 0x13, 0xa3, 0x2a, 0xba, 0xd9, 0xc4, 0x47, 0x78, - 0x0c, 0x5e, 0x75, 0xf9, 0x3e, 0xf6, 0x8a, 0x9f, 0x04, 0x02, 0x77, 0x2d, 0xf8, 0x11, 0xe2, 0xbf, - 0x2f, 0x08, 0xcf, 0xf7, 0xe7, 0x39, 0xf0, 0x8a, 0x56, 0xe9, 0x61, 0x83, 0x3b, 0x77, 0xb6, 0xc0, - 0x77, 0x70, 0x32, 0xc7, 0x81, 0xc9, 0x3f, 0x12, 0x72, 0xab, 0xce, 0x0e, 0x66, 0x97, 0x2d, 0x2e, - 0xc8, 0x6d, 0x60, 0x9f, 0xf4, 0xeb, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa2, 0xe6, 0x0b, 0xac, - 0xf8, 0x02, 0x00, 0x00, + // 410 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xc1, 0x6a, 0xdb, 0x40, + 0x10, 0x86, 0xbd, 0x91, 0xed, 0x38, 0x13, 0xb7, 0xa8, 0x43, 0xa1, 0x8a, 0x2f, 0x31, 0xa2, 0x07, + 0x9f, 0x44, 0x50, 0x29, 0xf4, 0x9a, 0xa4, 0xa6, 0x08, 0x1a, 0x0c, 0x5b, 0x41, 0x8f, 0x45, 0x91, + 0x86, 0x7a, 0x8b, 0xa4, 0x55, 0x77, 0x37, 0x06, 0xf5, 0x0d, 0x0a, 0x7d, 0x96, 0x3e, 0x4c, 0x9f, + 0xa8, 0xec, 0x6e, 0xac, 0x86, 0xa6, 0x3e, 0xf5, 0xf6, 0xcf, 0xcc, 0xaf, 0xd1, 0xb7, 0xff, 0x2e, + 0xcc, 0x4b, 0xd9, 0x34, 0xc2, 0x24, 0x9d, 0x92, 0x46, 0xe2, 0xf4, 0xb3, 0x30, 0x45, 0xdd, 0x2f, + 0xe6, 0x7a, 0x5b, 0x28, 0xaa, 0x7c, 0x37, 0xfe, 0xce, 0xe0, 0xc5, 0xb5, 0xb3, 0x65, 0xfa, 0xb2, + 0x2d, 0x49, 0x1b, 0xa9, 0x38, 0x7d, 0xbd, 0x23, 0x6d, 0x30, 0x05, 0x50, 0xd4, 0x49, 0x2d, 0x8c, + 0x54, 0x7d, 0xc4, 0x96, 0x6c, 0x75, 0x9a, 0x62, 0xe2, 0xd7, 0x24, 0x7c, 0x98, 0xf0, 0x07, 0x2e, + 0x3c, 0x87, 0xd3, 0xe2, 0x7e, 0xcd, 0x27, 0x51, 0x45, 0x47, 0x4b, 0xb6, 0x3a, 0xe1, 0xb0, 0x6f, + 0x65, 0x15, 0x9e, 0xc1, 0xac, 0xdc, 0x8a, 0xba, 0xb2, 0xd3, 0xc0, 0x4d, 0x8f, 0x5d, 0x9d, 0x55, + 0xf1, 0x05, 0x44, 0x8f, 0x51, 0x74, 0x27, 0x5b, 0x4d, 0xf8, 0x1c, 0x26, 0xbb, 0xa2, 0xbe, 0x23, + 0x87, 0x31, 0xe3, 0xbe, 0x88, 0x7f, 0x30, 0x08, 0x73, 0x45, 0xb4, 0x6e, 0x8d, 0xea, 0xff, 0x07, + 0x7b, 0x01, 0x33, 0x45, 0x3b, 0xa1, 0x85, 0x6c, 0x1d, 0xf3, 0x9c, 0x0f, 0x35, 0x22, 0x8c, 0xbb, + 0xc2, 0x6c, 0x1d, 0xed, 0x9c, 0x3b, 0x6d, 0x71, 0x6a, 0xd1, 0x08, 0x13, 0x8d, 0x97, 0x6c, 0x15, + 0x70, 0x5f, 0xc4, 0xbf, 0x18, 0x3c, 0x7b, 0x80, 0x73, 0x8f, 0xfe, 0x06, 0xc6, 0xa6, 0xef, 0x3c, + 0xf9, 0xd3, 0xf4, 0xe5, 0x9e, 0xe4, 0x91, 0x31, 0xd9, 0xdc, 0x7e, 0xa1, 0xd2, 0xe4, 0x7d, 0x47, + 0xdc, 0x7d, 0x81, 0x21, 0x04, 0x72, 0x08, 0xd1, 0x4a, 0xcb, 0xa2, 0xc5, 0x37, 0x72, 0x2c, 0x01, + 0x77, 0xda, 0xf6, 0x1a, 0x59, 0x91, 0x43, 0x99, 0x70, 0xa7, 0x6d, 0xaf, 0x2a, 0x4c, 0x11, 0x4d, + 0x3c, 0xb3, 0xd5, 0xf1, 0x6b, 0x80, 0x3f, 0x7f, 0x40, 0x80, 0xe9, 0xf5, 0xe6, 0xe6, 0x26, 0xcb, + 0xc3, 0x11, 0xce, 0x60, 0x7c, 0xf5, 0x7e, 0x73, 0x15, 0x32, 0xab, 0x72, 0xbe, 0x5e, 0x87, 0x47, + 0x78, 0x0c, 0x41, 0x7e, 0xf9, 0x2e, 0x0c, 0xd2, 0x9f, 0x0c, 0x9e, 0xf8, 0x6b, 0xf9, 0x40, 0x6a, + 0x27, 0x4a, 0xc2, 0x8f, 0x10, 0xfe, 0x7d, 0x4f, 0x78, 0xbe, 0x3f, 0xd6, 0x81, 0xc7, 0xb4, 0x58, + 0x1e, 0x36, 0xf8, 0xe3, 0xc7, 0x23, 0x7c, 0x0b, 0x27, 0x43, 0x2a, 0x18, 0xfd, 0x23, 0x28, 0xbf, + 0xea, 0xec, 0x60, 0x84, 0xf1, 0xe8, 0x82, 0xdd, 0x4e, 0xdd, 0xcb, 0x7e, 0xf5, 0x3b, 0x00, 0x00, + 0xff, 0xff, 0x1a, 0xd6, 0xf0, 0x08, 0xff, 0x02, 0x00, 0x00, } diff --git a/go/deprecated-services.pb.go b/go/deprecated-services.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..cc4c7563f1f4f35e8bdc9019d584f7bf3f19befc --- /dev/null +++ b/go/deprecated-services.pb.go @@ -0,0 +1,1146 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: deprecated-services.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 + +// 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 Commit service + +type CommitClient interface { + CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) + TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) +} + +type commitClient struct { + cc *grpc.ClientConn +} + +func NewCommitClient(cc *grpc.ClientConn) CommitClient { + return &commitClient{cc} +} + +func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) { + out := new(CommitIsAncestorResponse) + err := grpc.Invoke(ctx, "/gitaly.Commit/CommitIsAncestor", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Commit_serviceDesc.Streams[0], c.cc, "/gitaly.Commit/TreeEntry", opts...) + if err != nil { + return nil, err + } + x := &commitTreeEntryClient{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 Commit_TreeEntryClient interface { + Recv() (*TreeEntryResponse, error) + grpc.ClientStream +} + +type commitTreeEntryClient struct { + grpc.ClientStream +} + +func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) { + m := new(TreeEntryResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for Commit service + +type CommitServer interface { + CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error) + TreeEntry(*TreeEntryRequest, Commit_TreeEntryServer) error +} + +func RegisterCommitServer(s *grpc.Server, srv CommitServer) { + s.RegisterService(&_Commit_serviceDesc, srv) +} + +func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CommitIsAncestorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CommitServer).CommitIsAncestor(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gitaly.Commit/CommitIsAncestor", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Commit_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(TreeEntryRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(CommitServer).TreeEntry(m, &commitTreeEntryServer{stream}) +} + +type Commit_TreeEntryServer interface { + Send(*TreeEntryResponse) error + grpc.ServerStream +} + +type commitTreeEntryServer struct { + grpc.ServerStream +} + +func (x *commitTreeEntryServer) Send(m *TreeEntryResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _Commit_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.Commit", + HandlerType: (*CommitServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CommitIsAncestor", + Handler: _Commit_CommitIsAncestor_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "TreeEntry", + Handler: _Commit_TreeEntry_Handler, + ServerStreams: true, + }, + }, + Metadata: "deprecated-services.proto", +} + +// Client API for Diff service + +type DiffClient interface { + // Returns stream of CommitDiffResponse with patches chunked over messages + CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) + // Return a stream so we can divide the response in chunks of deltas + CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) +} + +type diffClient struct { + cc *grpc.ClientConn +} + +func NewDiffClient(cc *grpc.ClientConn) DiffClient { + return &diffClient{cc} +} + +func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[0], c.cc, "/gitaly.Diff/CommitDiff", opts...) + if err != nil { + return nil, err + } + x := &diffCommitDiffClient{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 Diff_CommitDiffClient interface { + Recv() (*CommitDiffResponse, error) + grpc.ClientStream +} + +type diffCommitDiffClient struct { + grpc.ClientStream +} + +func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) { + m := new(CommitDiffResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[1], c.cc, "/gitaly.Diff/CommitDelta", opts...) + if err != nil { + return nil, err + } + x := &diffCommitDeltaClient{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 Diff_CommitDeltaClient interface { + Recv() (*CommitDeltaResponse, error) + grpc.ClientStream +} + +type diffCommitDeltaClient struct { + grpc.ClientStream +} + +func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) { + m := new(CommitDeltaResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for Diff service + +type DiffServer interface { + // Returns stream of CommitDiffResponse with patches chunked over messages + CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error + // Return a stream so we can divide the response in chunks of deltas + CommitDelta(*CommitDeltaRequest, Diff_CommitDeltaServer) error +} + +func RegisterDiffServer(s *grpc.Server, srv DiffServer) { + s.RegisterService(&_Diff_serviceDesc, srv) +} + +func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CommitDiffRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(DiffServer).CommitDiff(m, &diffCommitDiffServer{stream}) +} + +type Diff_CommitDiffServer interface { + Send(*CommitDiffResponse) error + grpc.ServerStream +} + +type diffCommitDiffServer struct { + grpc.ServerStream +} + +func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _Diff_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CommitDeltaRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(DiffServer).CommitDelta(m, &diffCommitDeltaServer{stream}) +} + +type Diff_CommitDeltaServer interface { + Send(*CommitDeltaResponse) error + grpc.ServerStream +} + +type diffCommitDeltaServer struct { + grpc.ServerStream +} + +func (x *diffCommitDeltaServer) Send(m *CommitDeltaResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _Diff_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.Diff", + HandlerType: (*DiffServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "CommitDiff", + Handler: _Diff_CommitDiff_Handler, + ServerStreams: true, + }, + { + StreamName: "CommitDelta", + Handler: _Diff_CommitDelta_Handler, + ServerStreams: true, + }, + }, + Metadata: "deprecated-services.proto", +} + +// Client API for Notifications service + +type NotificationsClient interface { + PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) +} + +type notificationsClient struct { + cc *grpc.ClientConn +} + +func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient { + return ¬ificationsClient{cc} +} + +func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) { + out := new(PostReceiveResponse) + err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for Notifications service + +type NotificationsServer interface { + PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error) +} + +func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) { + s.RegisterService(&_Notifications_serviceDesc, srv) +} + +func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PostReceiveRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(NotificationsServer).PostReceive(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gitaly.Notifications/PostReceive", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Notifications_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.Notifications", + HandlerType: (*NotificationsServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "PostReceive", + Handler: _Notifications_PostReceive_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "deprecated-services.proto", +} + +// Client API for Ref service + +type RefClient interface { + FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) + FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) + FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) + // Find a Ref matching the given constraints. Response may be empty. + FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) + // Return a stream so we can divide the response in chunks of branches + FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error) +} + +type refClient struct { + cc *grpc.ClientConn +} + +func NewRefClient(cc *grpc.ClientConn) RefClient { + return &refClient{cc} +} + +func (c *refClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) { + out := new(FindDefaultBranchNameResponse) + err := grpc.Invoke(ctx, "/gitaly.Ref/FindDefaultBranchName", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[0], c.cc, "/gitaly.Ref/FindAllBranchNames", opts...) + if err != nil { + return nil, err + } + x := &refFindAllBranchNamesClient{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 Ref_FindAllBranchNamesClient interface { + Recv() (*FindAllBranchNamesResponse, error) + grpc.ClientStream +} + +type refFindAllBranchNamesClient struct { + grpc.ClientStream +} + +func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) { + m := new(FindAllBranchNamesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[1], c.cc, "/gitaly.Ref/FindAllTagNames", opts...) + if err != nil { + return nil, err + } + x := &refFindAllTagNamesClient{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 Ref_FindAllTagNamesClient interface { + Recv() (*FindAllTagNamesResponse, error) + grpc.ClientStream +} + +type refFindAllTagNamesClient struct { + grpc.ClientStream +} + +func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) { + m := new(FindAllTagNamesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *refClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) { + out := new(FindRefNameResponse) + err := grpc.Invoke(ctx, "/gitaly.Ref/FindRefName", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *refClient) FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[2], c.cc, "/gitaly.Ref/FindLocalBranches", opts...) + if err != nil { + return nil, err + } + x := &refFindLocalBranchesClient{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 Ref_FindLocalBranchesClient interface { + Recv() (*FindLocalBranchesResponse, error) + grpc.ClientStream +} + +type refFindLocalBranchesClient struct { + grpc.ClientStream +} + +func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) { + m := new(FindLocalBranchesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for Ref service + +type RefServer interface { + FindDefaultBranchName(context.Context, *FindDefaultBranchNameRequest) (*FindDefaultBranchNameResponse, error) + FindAllBranchNames(*FindAllBranchNamesRequest, Ref_FindAllBranchNamesServer) error + FindAllTagNames(*FindAllTagNamesRequest, Ref_FindAllTagNamesServer) error + // Find a Ref matching the given constraints. Response may be empty. + FindRefName(context.Context, *FindRefNameRequest) (*FindRefNameResponse, error) + // Return a stream so we can divide the response in chunks of branches + FindLocalBranches(*FindLocalBranchesRequest, Ref_FindLocalBranchesServer) error +} + +func RegisterRefServer(s *grpc.Server, srv RefServer) { + s.RegisterService(&_Ref_serviceDesc, srv) +} + +func _Ref_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FindDefaultBranchNameRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RefServer).FindDefaultBranchName(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gitaly.Ref/FindDefaultBranchName", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RefServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Ref_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(FindAllBranchNamesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RefServer).FindAllBranchNames(m, &refFindAllBranchNamesServer{stream}) +} + +type Ref_FindAllBranchNamesServer interface { + Send(*FindAllBranchNamesResponse) error + grpc.ServerStream +} + +type refFindAllBranchNamesServer struct { + grpc.ServerStream +} + +func (x *refFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _Ref_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(FindAllTagNamesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RefServer).FindAllTagNames(m, &refFindAllTagNamesServer{stream}) +} + +type Ref_FindAllTagNamesServer interface { + Send(*FindAllTagNamesResponse) error + grpc.ServerStream +} + +type refFindAllTagNamesServer struct { + grpc.ServerStream +} + +func (x *refFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _Ref_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FindRefNameRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RefServer).FindRefName(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gitaly.Ref/FindRefName", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RefServer).FindRefName(ctx, req.(*FindRefNameRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Ref_FindLocalBranches_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(FindLocalBranchesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RefServer).FindLocalBranches(m, &refFindLocalBranchesServer{stream}) +} + +type Ref_FindLocalBranchesServer interface { + Send(*FindLocalBranchesResponse) error + grpc.ServerStream +} + +type refFindLocalBranchesServer struct { + grpc.ServerStream +} + +func (x *refFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _Ref_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.Ref", + HandlerType: (*RefServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "FindDefaultBranchName", + Handler: _Ref_FindDefaultBranchName_Handler, + }, + { + MethodName: "FindRefName", + Handler: _Ref_FindRefName_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "FindAllBranchNames", + Handler: _Ref_FindAllBranchNames_Handler, + ServerStreams: true, + }, + { + StreamName: "FindAllTagNames", + Handler: _Ref_FindAllTagNames_Handler, + ServerStreams: true, + }, + { + StreamName: "FindLocalBranches", + Handler: _Ref_FindLocalBranches_Handler, + ServerStreams: true, + }, + }, + Metadata: "deprecated-services.proto", +} + +// Client API for SmartHTTP service + +type SmartHTTPClient interface { + // The response body for GET /info/refs?service=git-upload-pack + InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) + // The response body for GET /info/refs?service=git-receive-pack + InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) + // Request and response body for POST /upload-pack + PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) + // Request and response body for POST /receive-pack + PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) +} + +type smartHTTPClient struct { + cc *grpc.ClientConn +} + +func NewSmartHTTPClient(cc *grpc.ClientConn) SmartHTTPClient { + return &smartHTTPClient{cc} +} + +func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTP/InfoRefsUploadPack", opts...) + if err != nil { + return nil, err + } + x := &smartHTTPInfoRefsUploadPackClient{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 SmartHTTP_InfoRefsUploadPackClient interface { + Recv() (*InfoRefsResponse, error) + grpc.ClientStream +} + +type smartHTTPInfoRefsUploadPackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) { + m := new(InfoRefsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTP/InfoRefsReceivePack", opts...) + if err != nil { + return nil, err + } + x := &smartHTTPInfoRefsReceivePackClient{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 SmartHTTP_InfoRefsReceivePackClient interface { + Recv() (*InfoRefsResponse, error) + grpc.ClientStream +} + +type smartHTTPInfoRefsReceivePackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) { + m := new(InfoRefsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *smartHTTPClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTP/PostUploadPack", opts...) + if err != nil { + return nil, err + } + x := &smartHTTPPostUploadPackClient{stream} + return x, nil +} + +type SmartHTTP_PostUploadPackClient interface { + Send(*PostUploadPackRequest) error + Recv() (*PostUploadPackResponse, error) + grpc.ClientStream +} + +type smartHTTPPostUploadPackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPPostUploadPackClient) Send(m *PostUploadPackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) { + m := new(PostUploadPackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *smartHTTPClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTP/PostReceivePack", opts...) + if err != nil { + return nil, err + } + x := &smartHTTPPostReceivePackClient{stream} + return x, nil +} + +type SmartHTTP_PostReceivePackClient interface { + Send(*PostReceivePackRequest) error + Recv() (*PostReceivePackResponse, error) + grpc.ClientStream +} + +type smartHTTPPostReceivePackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPPostReceivePackClient) Send(m *PostReceivePackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error) { + m := new(PostReceivePackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for SmartHTTP service + +type SmartHTTPServer interface { + // The response body for GET /info/refs?service=git-upload-pack + InfoRefsUploadPack(*InfoRefsRequest, SmartHTTP_InfoRefsUploadPackServer) error + // The response body for GET /info/refs?service=git-receive-pack + InfoRefsReceivePack(*InfoRefsRequest, SmartHTTP_InfoRefsReceivePackServer) error + // Request and response body for POST /upload-pack + PostUploadPack(SmartHTTP_PostUploadPackServer) error + // Request and response body for POST /receive-pack + PostReceivePack(SmartHTTP_PostReceivePackServer) error +} + +func RegisterSmartHTTPServer(s *grpc.Server, srv SmartHTTPServer) { + s.RegisterService(&_SmartHTTP_serviceDesc, srv) +} + +func _SmartHTTP_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(InfoRefsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SmartHTTPServer).InfoRefsUploadPack(m, &smartHTTPInfoRefsUploadPackServer{stream}) +} + +type SmartHTTP_InfoRefsUploadPackServer interface { + Send(*InfoRefsResponse) error + grpc.ServerStream +} + +type smartHTTPInfoRefsUploadPackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _SmartHTTP_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(InfoRefsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SmartHTTPServer).InfoRefsReceivePack(m, &smartHTTPInfoRefsReceivePackServer{stream}) +} + +type SmartHTTP_InfoRefsReceivePackServer interface { + Send(*InfoRefsResponse) error + grpc.ServerStream +} + +type smartHTTPInfoRefsReceivePackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _SmartHTTP_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SmartHTTPServer).PostUploadPack(&smartHTTPPostUploadPackServer{stream}) +} + +type SmartHTTP_PostUploadPackServer interface { + Send(*PostUploadPackResponse) error + Recv() (*PostUploadPackRequest, error) + grpc.ServerStream +} + +type smartHTTPPostUploadPackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPPostUploadPackServer) Send(m *PostUploadPackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) { + m := new(PostUploadPackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _SmartHTTP_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SmartHTTPServer).PostReceivePack(&smartHTTPPostReceivePackServer{stream}) +} + +type SmartHTTP_PostReceivePackServer interface { + Send(*PostReceivePackResponse) error + Recv() (*PostReceivePackRequest, error) + grpc.ServerStream +} + +type smartHTTPPostReceivePackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPPostReceivePackServer) Send(m *PostReceivePackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) { + m := new(PostReceivePackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _SmartHTTP_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.SmartHTTP", + HandlerType: (*SmartHTTPServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "InfoRefsUploadPack", + Handler: _SmartHTTP_InfoRefsUploadPack_Handler, + ServerStreams: true, + }, + { + StreamName: "InfoRefsReceivePack", + Handler: _SmartHTTP_InfoRefsReceivePack_Handler, + ServerStreams: true, + }, + { + StreamName: "PostUploadPack", + Handler: _SmartHTTP_PostUploadPack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "PostReceivePack", + Handler: _SmartHTTP_PostReceivePack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "deprecated-services.proto", +} + +// Client API for SSH service + +type SSHClient interface { + // To forward 'git upload-pack' to Gitaly for SSH sessions + SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) + // To forward 'git receive-pack' to Gitaly for SSH sessions + SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) +} + +type sSHClient struct { + cc *grpc.ClientConn +} + +func NewSSHClient(cc *grpc.ClientConn) SSHClient { + return &sSHClient{cc} +} + +func (c *sSHClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[0], c.cc, "/gitaly.SSH/SSHUploadPack", opts...) + if err != nil { + return nil, err + } + x := &sSHSSHUploadPackClient{stream} + return x, nil +} + +type SSH_SSHUploadPackClient interface { + Send(*SSHUploadPackRequest) error + Recv() (*SSHUploadPackResponse, error) + grpc.ClientStream +} + +type sSHSSHUploadPackClient struct { + grpc.ClientStream +} + +func (x *sSHSSHUploadPackClient) Send(m *SSHUploadPackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) { + m := new(SSHUploadPackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *sSHClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[1], c.cc, "/gitaly.SSH/SSHReceivePack", opts...) + if err != nil { + return nil, err + } + x := &sSHSSHReceivePackClient{stream} + return x, nil +} + +type SSH_SSHReceivePackClient interface { + Send(*SSHReceivePackRequest) error + Recv() (*SSHReceivePackResponse, error) + grpc.ClientStream +} + +type sSHSSHReceivePackClient struct { + grpc.ClientStream +} + +func (x *sSHSSHReceivePackClient) Send(m *SSHReceivePackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) { + m := new(SSHReceivePackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for SSH service + +type SSHServer interface { + // To forward 'git upload-pack' to Gitaly for SSH sessions + SSHUploadPack(SSH_SSHUploadPackServer) error + // To forward 'git receive-pack' to Gitaly for SSH sessions + SSHReceivePack(SSH_SSHReceivePackServer) error +} + +func RegisterSSHServer(s *grpc.Server, srv SSHServer) { + s.RegisterService(&_SSH_serviceDesc, srv) +} + +func _SSH_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SSHServer).SSHUploadPack(&sSHSSHUploadPackServer{stream}) +} + +type SSH_SSHUploadPackServer interface { + Send(*SSHUploadPackResponse) error + Recv() (*SSHUploadPackRequest, error) + grpc.ServerStream +} + +type sSHSSHUploadPackServer struct { + grpc.ServerStream +} + +func (x *sSHSSHUploadPackServer) Send(m *SSHUploadPackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) { + m := new(SSHUploadPackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _SSH_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SSHServer).SSHReceivePack(&sSHSSHReceivePackServer{stream}) +} + +type SSH_SSHReceivePackServer interface { + Send(*SSHReceivePackResponse) error + Recv() (*SSHReceivePackRequest, error) + grpc.ServerStream +} + +type sSHSSHReceivePackServer struct { + grpc.ServerStream +} + +func (x *sSHSSHReceivePackServer) Send(m *SSHReceivePackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) { + m := new(SSHReceivePackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _SSH_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.SSH", + HandlerType: (*SSHServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "SSHUploadPack", + Handler: _SSH_SSHUploadPack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "SSHReceivePack", + Handler: _SSH_SSHReceivePack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "deprecated-services.proto", +} + +func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor1) } + +var fileDescriptor1 = []byte{ + // 534 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40, + 0x10, 0x80, 0x31, 0x41, 0x91, 0x32, 0xa1, 0x0d, 0x6c, 0x85, 0x68, 0x0c, 0x4d, 0xda, 0x0a, 0x24, + 0x5e, 0x88, 0xaa, 0x70, 0x82, 0x42, 0x00, 0x17, 0xaa, 0x2a, 0xb2, 0x13, 0x7e, 0x24, 0x24, 0xb4, + 0x38, 0xb3, 0x8d, 0x85, 0xe3, 0x0d, 0xde, 0x6d, 0xa5, 0x9e, 0x85, 0x03, 0xf0, 0xca, 0x49, 0x78, + 0xe5, 0x3a, 0xc8, 0x3f, 0x13, 0xaf, 0x13, 0xbb, 0x3c, 0xf4, 0x6d, 0x33, 0xdf, 0xcc, 0xb7, 0x93, + 0xf1, 0xd8, 0xd0, 0x9d, 0xe1, 0x32, 0x46, 0x9f, 0x6b, 0x9c, 0x3d, 0x57, 0x18, 0x5f, 0x06, 0x3e, + 0xaa, 0xc1, 0x32, 0x96, 0x5a, 0xb2, 0xe6, 0x79, 0xa0, 0x79, 0x78, 0x65, 0xdf, 0xf5, 0xe5, 0x62, + 0x11, 0xe8, 0x2c, 0x6a, 0xc3, 0x2c, 0x10, 0x22, 0x3f, 0xef, 0x44, 0x52, 0x07, 0x22, 0xf0, 0xb9, + 0x0e, 0x64, 0x94, 0x97, 0xd9, 0xad, 0x18, 0x89, 0x77, 0xd4, 0x82, 0xc7, 0x7a, 0xae, 0xf5, 0x92, + 0x98, 0x52, 0xf3, 0xec, 0x38, 0xfc, 0x65, 0x41, 0xf3, 0x55, 0x2a, 0x66, 0x1f, 0xe1, 0x5e, 0x76, + 0x3a, 0x51, 0xc7, 0x91, 0x8f, 0x4a, 0xcb, 0x98, 0xf5, 0x07, 0xd9, 0xed, 0x83, 0x75, 0xe2, 0xe2, + 0x8f, 0x0b, 0x54, 0xda, 0xde, 0xaf, 0x4f, 0x50, 0x4b, 0x19, 0x29, 0x3c, 0xbc, 0xc5, 0x46, 0xd0, + 0x9a, 0xc4, 0x88, 0xaf, 0x23, 0x1d, 0x5f, 0xb1, 0x5d, 0x2a, 0x58, 0x85, 0x48, 0xd5, 0xad, 0x20, + 0xe4, 0x38, 0xb2, 0x86, 0x3f, 0x2d, 0xb8, 0x33, 0x0a, 0x84, 0x60, 0x6f, 0x01, 0xb2, 0xcb, 0xd2, + 0x5f, 0xdd, 0x72, 0x03, 0x49, 0x8c, 0x84, 0x76, 0x15, 0x2a, 0x8c, 0xec, 0x1d, 0xb4, 0x73, 0x82, + 0xa1, 0xe6, 0x6c, 0x3d, 0x3d, 0x09, 0x92, 0xea, 0x51, 0x25, 0x33, 0xba, 0xfb, 0x0c, 0x5b, 0x67, + 0xe6, 0x53, 0x60, 0x0e, 0xb4, 0xc7, 0x52, 0x69, 0x17, 0x7d, 0x0c, 0x2e, 0xb1, 0x90, 0x1b, 0xc1, + 0x0d, 0x79, 0x89, 0x91, 0x7c, 0xf8, 0xa7, 0x01, 0x0d, 0x17, 0x05, 0x13, 0xf0, 0xe0, 0x4d, 0x10, + 0xcd, 0x46, 0x28, 0xf8, 0x45, 0xa8, 0x5f, 0xc6, 0x3c, 0xf2, 0xe7, 0x67, 0x7c, 0x81, 0xec, 0x09, + 0xd5, 0x57, 0x62, 0xba, 0xe5, 0xe9, 0x7f, 0xb2, 0x56, 0x8f, 0xeb, 0x2b, 0xb0, 0x24, 0xe5, 0x38, + 0x0c, 0x0b, 0xac, 0xd8, 0x81, 0x59, 0x5e, 0x66, 0x74, 0xc3, 0xe1, 0x75, 0x29, 0xc6, 0xdc, 0x3f, + 0x40, 0x27, 0xcf, 0x98, 0xf0, 0xf3, 0xcc, 0xde, 0x5b, 0x2b, 0x25, 0x40, 0xea, 0x7e, 0x2d, 0x37, + 0xbc, 0x0e, 0xb4, 0x13, 0xec, 0xa2, 0x48, 0xc7, 0x62, 0x9b, 0x35, 0x79, 0x70, 0x63, 0xe4, 0x25, + 0xb6, 0x1a, 0xc1, 0x17, 0xb8, 0x9f, 0x80, 0x53, 0xe9, 0xf3, 0xfc, 0x5f, 0xa0, 0x62, 0xfb, 0x66, + 0x4d, 0x09, 0x91, 0xf5, 0xe0, 0x9a, 0x0c, 0x63, 0x57, 0xfe, 0xde, 0x86, 0x96, 0x97, 0xbc, 0x92, + 0xce, 0x64, 0x32, 0x66, 0xef, 0x81, 0x9d, 0x44, 0x42, 0xba, 0x28, 0xd4, 0x74, 0x19, 0x4a, 0x3e, + 0x1b, 0x73, 0xff, 0x3b, 0x7b, 0x48, 0x2a, 0x62, 0x74, 0xc7, 0xee, 0x26, 0x30, 0x46, 0x70, 0x0a, + 0x3b, 0x45, 0x3c, 0x5d, 0xa4, 0x9b, 0xd8, 0xa6, 0xb0, 0x9d, 0xac, 0xa4, 0xd1, 0xd6, 0x9e, 0xb9, + 0xaa, 0x45, 0x9c, 0x74, 0xbd, 0x3a, 0x4c, 0xd2, 0x67, 0xd6, 0x91, 0xc5, 0x3e, 0x41, 0xc7, 0xd8, + 0xf4, 0xd4, 0xdb, 0xab, 0x78, 0x05, 0x4c, 0x71, 0xbf, 0x96, 0x9b, 0xe6, 0xe1, 0x6f, 0x0b, 0x1a, + 0x9e, 0xe7, 0x30, 0x17, 0xb6, 0x3c, 0xcf, 0x31, 0xfa, 0x7e, 0x4c, 0xf5, 0xa5, 0x30, 0xd9, 0xf7, + 0x6a, 0x68, 0xa9, 0xeb, 0x29, 0x6c, 0x7b, 0x9e, 0x63, 0x36, 0x6d, 0x96, 0x55, 0xf4, 0xdc, 0xab, + 0xc3, 0xa6, 0xf6, 0x5b, 0x33, 0xfd, 0x0e, 0xbf, 0xf8, 0x17, 0x00, 0x00, 0xff, 0xff, 0x79, 0x83, + 0xb6, 0xb0, 0x02, 0x06, 0x00, 0x00, +} diff --git a/go/diff.pb.go b/go/diff.pb.go index 737e5421685d96048219fe5cc92a5c4718626744..1dcc5365cde395ddd457219d69871c67f01fc294 100644 --- a/go/diff.pb.go +++ b/go/diff.pb.go @@ -28,7 +28,7 @@ type CommitDiffRequest struct { func (m *CommitDiffRequest) Reset() { *m = CommitDiffRequest{} } func (m *CommitDiffRequest) String() string { return proto.CompactTextString(m) } func (*CommitDiffRequest) ProtoMessage() {} -func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } +func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } func (m *CommitDiffRequest) GetRepository() *Repository { if m != nil { @@ -82,7 +82,7 @@ type CommitDiffResponse struct { func (m *CommitDiffResponse) Reset() { *m = CommitDiffResponse{} } func (m *CommitDiffResponse) String() string { return proto.CompactTextString(m) } func (*CommitDiffResponse) ProtoMessage() {} -func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} } +func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } func (m *CommitDiffResponse) GetFromPath() []byte { if m != nil { @@ -157,7 +157,7 @@ type CommitDeltaRequest struct { func (m *CommitDeltaRequest) Reset() { *m = CommitDeltaRequest{} } func (m *CommitDeltaRequest) String() string { return proto.CompactTextString(m) } func (*CommitDeltaRequest) ProtoMessage() {} -func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} } +func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } func (m *CommitDeltaRequest) GetRepository() *Repository { if m != nil { @@ -200,7 +200,7 @@ type CommitDelta struct { func (m *CommitDelta) Reset() { *m = CommitDelta{} } func (m *CommitDelta) String() string { return proto.CompactTextString(m) } func (*CommitDelta) ProtoMessage() {} -func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} } +func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} } func (m *CommitDelta) GetFromPath() []byte { if m != nil { @@ -251,7 +251,7 @@ type CommitDeltaResponse struct { func (m *CommitDeltaResponse) Reset() { *m = CommitDeltaResponse{} } func (m *CommitDeltaResponse) String() string { return proto.CompactTextString(m) } func (*CommitDeltaResponse) ProtoMessage() {} -func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} } +func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} } func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta { if m != nil { @@ -276,29 +276,29 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for Diff service +// Client API for DiffService service -type DiffClient interface { +type DiffServiceClient interface { // Returns stream of CommitDiffResponse with patches chunked over messages - CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) + CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error) // Return a stream so we can divide the response in chunks of deltas - CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) + CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error) } -type diffClient struct { +type diffServiceClient struct { cc *grpc.ClientConn } -func NewDiffClient(cc *grpc.ClientConn) DiffClient { - return &diffClient{cc} +func NewDiffServiceClient(cc *grpc.ClientConn) DiffServiceClient { + return &diffServiceClient{cc} } -func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[0], c.cc, "/gitaly.Diff/CommitDiff", opts...) +func (c *diffServiceClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error) { + stream, err := grpc.NewClientStream(ctx, &_DiffService_serviceDesc.Streams[0], c.cc, "/gitaly.DiffService/CommitDiff", opts...) if err != nil { return nil, err } - x := &diffCommitDiffClient{stream} + x := &diffServiceCommitDiffClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -308,16 +308,16 @@ func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts return x, nil } -type Diff_CommitDiffClient interface { +type DiffService_CommitDiffClient interface { Recv() (*CommitDiffResponse, error) grpc.ClientStream } -type diffCommitDiffClient struct { +type diffServiceCommitDiffClient struct { grpc.ClientStream } -func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) { +func (x *diffServiceCommitDiffClient) Recv() (*CommitDiffResponse, error) { m := new(CommitDiffResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -325,12 +325,12 @@ func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) { return m, nil } -func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[1], c.cc, "/gitaly.Diff/CommitDelta", opts...) +func (c *diffServiceClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error) { + stream, err := grpc.NewClientStream(ctx, &_DiffService_serviceDesc.Streams[1], c.cc, "/gitaly.DiffService/CommitDelta", opts...) if err != nil { return nil, err } - x := &diffCommitDeltaClient{stream} + x := &diffServiceCommitDeltaClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -340,16 +340,16 @@ func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, op return x, nil } -type Diff_CommitDeltaClient interface { +type DiffService_CommitDeltaClient interface { Recv() (*CommitDeltaResponse, error) grpc.ClientStream } -type diffCommitDeltaClient struct { +type diffServiceCommitDeltaClient struct { grpc.ClientStream } -func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) { +func (x *diffServiceCommitDeltaClient) Recv() (*CommitDeltaResponse, error) { m := new(CommitDeltaResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -357,112 +357,113 @@ func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) { return m, nil } -// Server API for Diff service +// Server API for DiffService service -type DiffServer interface { +type DiffServiceServer interface { // Returns stream of CommitDiffResponse with patches chunked over messages - CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error + CommitDiff(*CommitDiffRequest, DiffService_CommitDiffServer) error // Return a stream so we can divide the response in chunks of deltas - CommitDelta(*CommitDeltaRequest, Diff_CommitDeltaServer) error + CommitDelta(*CommitDeltaRequest, DiffService_CommitDeltaServer) error } -func RegisterDiffServer(s *grpc.Server, srv DiffServer) { - s.RegisterService(&_Diff_serviceDesc, srv) +func RegisterDiffServiceServer(s *grpc.Server, srv DiffServiceServer) { + s.RegisterService(&_DiffService_serviceDesc, srv) } -func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error { +func _DiffService_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(CommitDiffRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(DiffServer).CommitDiff(m, &diffCommitDiffServer{stream}) + return srv.(DiffServiceServer).CommitDiff(m, &diffServiceCommitDiffServer{stream}) } -type Diff_CommitDiffServer interface { +type DiffService_CommitDiffServer interface { Send(*CommitDiffResponse) error grpc.ServerStream } -type diffCommitDiffServer struct { +type diffServiceCommitDiffServer struct { grpc.ServerStream } -func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error { +func (x *diffServiceCommitDiffServer) Send(m *CommitDiffResponse) error { return x.ServerStream.SendMsg(m) } -func _Diff_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error { +func _DiffService_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(CommitDeltaRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(DiffServer).CommitDelta(m, &diffCommitDeltaServer{stream}) + return srv.(DiffServiceServer).CommitDelta(m, &diffServiceCommitDeltaServer{stream}) } -type Diff_CommitDeltaServer interface { +type DiffService_CommitDeltaServer interface { Send(*CommitDeltaResponse) error grpc.ServerStream } -type diffCommitDeltaServer struct { +type diffServiceCommitDeltaServer struct { grpc.ServerStream } -func (x *diffCommitDeltaServer) Send(m *CommitDeltaResponse) error { +func (x *diffServiceCommitDeltaServer) Send(m *CommitDeltaResponse) error { return x.ServerStream.SendMsg(m) } -var _Diff_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gitaly.Diff", - HandlerType: (*DiffServer)(nil), +var _DiffService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.DiffService", + HandlerType: (*DiffServiceServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "CommitDiff", - Handler: _Diff_CommitDiff_Handler, + Handler: _DiffService_CommitDiff_Handler, ServerStreams: true, }, { StreamName: "CommitDelta", - Handler: _Diff_CommitDelta_Handler, + Handler: _DiffService_CommitDelta_Handler, ServerStreams: true, }, }, Metadata: "diff.proto", } -func init() { proto.RegisterFile("diff.proto", fileDescriptor1) } - -var fileDescriptor1 = []byte{ - // 473 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0x4d, 0x8a, 0xdb, 0x30, - 0x14, 0xc7, 0xab, 0xc4, 0x76, 0x9c, 0x17, 0xf7, 0x4b, 0x29, 0x53, 0x4d, 0x66, 0x63, 0x4c, 0x29, - 0x86, 0x42, 0x28, 0xe9, 0xa6, 0xeb, 0xce, 0x40, 0xc9, 0x40, 0xe9, 0xe0, 0x4d, 0x97, 0x46, 0x13, - 0xc9, 0xb1, 0xc0, 0xb1, 0x5c, 0x59, 0xc5, 0xe4, 0x1e, 0xdd, 0xf5, 0x00, 0xdd, 0xf4, 0x5a, 0xbd, - 0x47, 0x91, 0x94, 0x71, 0x3c, 0x25, 0x07, 0xc8, 0x52, 0xff, 0xdf, 0x5f, 0x4f, 0xef, 0xcb, 0x06, - 0x60, 0xa2, 0x28, 0x96, 0x8d, 0x92, 0x5a, 0xe2, 0x60, 0x2b, 0x34, 0xad, 0xf6, 0x8b, 0xa8, 0x2d, - 0xa9, 0xe2, 0xcc, 0xa9, 0xc9, 0x5f, 0x04, 0x2f, 0xaf, 0xe5, 0x6e, 0x27, 0xf4, 0x8d, 0x28, 0x8a, - 0x8c, 0x7f, 0xff, 0xc1, 0x5b, 0x8d, 0x57, 0x00, 0x8a, 0x37, 0xb2, 0x15, 0x5a, 0xaa, 0x3d, 0x41, - 0x31, 0x4a, 0x67, 0x2b, 0xbc, 0x74, 0x01, 0x96, 0x59, 0x4f, 0xb2, 0x81, 0x0b, 0xbf, 0x81, 0x67, - 0x15, 0x2f, 0x74, 0xbe, 0xb1, 0xd1, 0x72, 0xc1, 0xc8, 0x28, 0x46, 0xe9, 0x34, 0x8b, 0x8c, 0xea, - 0x9e, 0x58, 0x33, 0xfc, 0x16, 0x9e, 0x2b, 0xb1, 0x2d, 0x87, 0xb6, 0xb1, 0xb5, 0x3d, 0xb5, 0x72, - 0xef, 0xfb, 0x08, 0x44, 0x6c, 0x6b, 0xa9, 0x78, 0xde, 0x95, 0x42, 0xf3, 0xb6, 0xa1, 0x1b, 0x9e, - 0x6f, 0x4a, 0x5a, 0x6f, 0x39, 0xf1, 0x62, 0x94, 0x86, 0xd9, 0x85, 0xe3, 0xdf, 0x7a, 0x7c, 0x6d, - 0x29, 0x7e, 0x05, 0x7e, 0x43, 0x75, 0xd9, 0x12, 0x3f, 0x1e, 0xa7, 0x51, 0xe6, 0x0e, 0xc9, 0xcf, - 0x11, 0xe0, 0x61, 0x9d, 0x6d, 0x23, 0xeb, 0x96, 0xe3, 0x2b, 0x98, 0x16, 0x4a, 0xee, 0x72, 0x63, - 0xb2, 0x75, 0x46, 0x59, 0x68, 0x84, 0x3b, 0xaa, 0x4b, 0xfc, 0x1a, 0x26, 0x5a, 0x3a, 0x34, 0xb2, - 0x28, 0xd0, 0xf2, 0x01, 0xd8, 0x5b, 0x7d, 0xf2, 0x81, 0x39, 0xae, 0x19, 0x9e, 0x83, 0xaf, 0xa5, - 0x91, 0x3d, 0x2b, 0x7b, 0x5a, 0xae, 0x19, 0xbe, 0x84, 0x50, 0x56, 0x2c, 0xdf, 0x49, 0xc6, 0x89, - 0x1f, 0xa3, 0xd4, 0xcf, 0x26, 0xb2, 0x62, 0x5f, 0x24, 0xe3, 0x06, 0xd5, 0xbc, 0x73, 0x28, 0x70, - 0xa8, 0xe6, 0x9d, 0x45, 0x17, 0x10, 0xdc, 0x8b, 0x9a, 0xaa, 0x3d, 0x99, 0xd8, 0x72, 0x0f, 0x27, - 0xd3, 0x66, 0x45, 0x3b, 0x93, 0xd5, 0xa6, 0xcc, 0x19, 0xd5, 0x94, 0x4c, 0x6d, 0x6e, 0x91, 0xa2, - 0xdd, 0x9d, 0x11, 0x6f, 0xa8, 0xa6, 0x38, 0x86, 0x88, 0xd7, 0x2c, 0x97, 0x85, 0x33, 0x12, 0xb0, - 0x31, 0x80, 0xd7, 0xec, 0x6b, 0x61, 0x5d, 0xb7, 0x5e, 0x18, 0xbe, 0x98, 0x26, 0x7f, 0x50, 0xdf, - 0x16, 0x5e, 0x69, 0x7a, 0x3e, 0xf3, 0xef, 0xa7, 0xe8, 0x0d, 0xa7, 0xf8, 0x1b, 0xc1, 0x6c, 0x90, - 0xee, 0xf9, 0x8e, 0x2f, 0xf9, 0x04, 0xf3, 0x47, 0x7d, 0x3d, 0xec, 0xdb, 0x3b, 0x08, 0x98, 0x11, - 0x5a, 0x82, 0xe2, 0x71, 0x3a, 0x5b, 0xcd, 0x1f, 0x9a, 0x3a, 0x34, 0x1f, 0x2c, 0xab, 0x5f, 0x08, - 0x3c, 0xb3, 0xad, 0xf8, 0x33, 0xc0, 0x71, 0x77, 0xf1, 0xe5, 0x7f, 0x77, 0x8e, 0xdf, 0xed, 0x62, - 0x71, 0x0a, 0xb9, 0xa7, 0x93, 0x27, 0xef, 0x11, 0xbe, 0x7d, 0xdc, 0xbe, 0xc5, 0xa9, 0xd7, 0x0f, - 0xa1, 0xae, 0x4e, 0xb2, 0x63, 0xac, 0xfb, 0xc0, 0xfe, 0x40, 0x3e, 0xfc, 0x0b, 0x00, 0x00, 0xff, - 0xff, 0x0c, 0x62, 0x85, 0xba, 0x64, 0x04, 0x00, 0x00, +func init() { proto.RegisterFile("diff.proto", fileDescriptor2) } + +var fileDescriptor2 = []byte{ + // 481 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0x4f, 0x8e, 0xd3, 0x30, + 0x14, 0xc6, 0x71, 0xdb, 0xa4, 0xe9, 0x6b, 0xf8, 0xe7, 0xa2, 0xc1, 0xd3, 0xd9, 0x44, 0x11, 0x42, + 0x91, 0x90, 0x2a, 0x54, 0x36, 0xac, 0x99, 0x91, 0x50, 0x47, 0x42, 0x8c, 0xc2, 0x82, 0x65, 0xe4, + 0x89, 0x9d, 0xc6, 0x52, 0x1a, 0x07, 0xc7, 0x10, 0xf5, 0x1e, 0x9c, 0x80, 0x0d, 0x1b, 0xae, 0xc5, + 0x3d, 0x90, 0xed, 0x4e, 0x9a, 0x41, 0x3d, 0xc0, 0x2c, 0xfd, 0xfd, 0x3e, 0xbf, 0x7e, 0x7e, 0xef, + 0x35, 0x00, 0x4c, 0x14, 0xc5, 0xaa, 0x51, 0x52, 0x4b, 0xec, 0x6f, 0x85, 0xa6, 0xd5, 0x7e, 0x19, + 0xb6, 0x25, 0x55, 0x9c, 0x39, 0x35, 0xfe, 0x8b, 0xe0, 0xf9, 0xa5, 0xdc, 0xed, 0x84, 0xbe, 0x12, + 0x45, 0x91, 0xf2, 0x6f, 0xdf, 0x79, 0xab, 0xf1, 0x1a, 0x40, 0xf1, 0x46, 0xb6, 0x42, 0x4b, 0xb5, + 0x27, 0x28, 0x42, 0xc9, 0x7c, 0x8d, 0x57, 0xae, 0xc0, 0x2a, 0xed, 0x49, 0x3a, 0x70, 0xe1, 0x57, + 0xf0, 0xa4, 0xe2, 0x85, 0xce, 0x72, 0x5b, 0x2d, 0x13, 0x8c, 0x8c, 0x22, 0x94, 0xcc, 0xd2, 0xd0, + 0xa8, 0xee, 0x27, 0x36, 0x0c, 0xbf, 0x86, 0xa7, 0x4a, 0x6c, 0xcb, 0xa1, 0x6d, 0x6c, 0x6d, 0x8f, + 0xad, 0xdc, 0xfb, 0xde, 0x03, 0x11, 0xdb, 0x5a, 0x2a, 0x9e, 0x75, 0xa5, 0xd0, 0xbc, 0x6d, 0x68, + 0xce, 0xb3, 0xbc, 0xa4, 0xf5, 0x96, 0x93, 0x49, 0x84, 0x92, 0x20, 0x3d, 0x73, 0xfc, 0x6b, 0x8f, + 0x2f, 0x2d, 0xc5, 0x2f, 0xc0, 0x6b, 0xa8, 0x2e, 0x5b, 0xe2, 0x45, 0xe3, 0x24, 0x4c, 0xdd, 0x21, + 0xfe, 0x39, 0x02, 0x3c, 0x7c, 0x67, 0xdb, 0xc8, 0xba, 0xe5, 0xf8, 0x02, 0x66, 0x85, 0x92, 0xbb, + 0xcc, 0x98, 0xec, 0x3b, 0xc3, 0x34, 0x30, 0xc2, 0x0d, 0xd5, 0x25, 0x7e, 0x09, 0x53, 0x2d, 0x1d, + 0x1a, 0x59, 0xe4, 0x6b, 0x79, 0x07, 0xec, 0xad, 0x3e, 0xbc, 0x6f, 0x8e, 0x1b, 0x86, 0x17, 0xe0, + 0x69, 0x69, 0xe4, 0x89, 0x95, 0x27, 0x5a, 0x6e, 0x18, 0x3e, 0x87, 0x40, 0x56, 0x2c, 0xdb, 0x49, + 0xc6, 0x89, 0x17, 0xa1, 0xc4, 0x4b, 0xa7, 0xb2, 0x62, 0x9f, 0x24, 0xe3, 0x06, 0xd5, 0xbc, 0x73, + 0xc8, 0x77, 0xa8, 0xe6, 0x9d, 0x45, 0x67, 0xe0, 0xdf, 0x8a, 0x9a, 0xaa, 0x3d, 0x99, 0xda, 0xe7, + 0x1e, 0x4e, 0xa6, 0xcd, 0x8a, 0x76, 0x26, 0x55, 0x5e, 0x66, 0x8c, 0x6a, 0x4a, 0x66, 0x36, 0x5b, + 0xa8, 0x68, 0x77, 0x63, 0xc4, 0x2b, 0xaa, 0x29, 0x8e, 0x20, 0xe4, 0x35, 0xcb, 0x64, 0xe1, 0x8c, + 0x04, 0x6c, 0x0d, 0xe0, 0x35, 0xfb, 0x5c, 0x58, 0xd7, 0xf5, 0x24, 0x08, 0x9e, 0xcd, 0xe2, 0x3f, + 0xa8, 0x6f, 0x0b, 0xaf, 0x34, 0x7d, 0x38, 0xf3, 0xef, 0xa7, 0x38, 0x19, 0x4e, 0xf1, 0x37, 0x82, + 0xf9, 0x20, 0xee, 0xc3, 0x1d, 0x5f, 0xfc, 0x01, 0x16, 0xf7, 0xfa, 0x7a, 0xd8, 0xb7, 0x37, 0xe0, + 0x33, 0x23, 0xb4, 0x04, 0x45, 0xe3, 0x64, 0xbe, 0x5e, 0xdc, 0x35, 0x75, 0x68, 0x3e, 0x58, 0xd6, + 0xbf, 0x10, 0xcc, 0xcd, 0xb6, 0x7e, 0xe1, 0xea, 0x87, 0xc8, 0x39, 0xfe, 0x08, 0x70, 0x5c, 0x61, + 0x7c, 0xfe, 0xdf, 0xd5, 0xe3, 0xdf, 0x77, 0xb9, 0x3c, 0x85, 0x5c, 0x82, 0xf8, 0xd1, 0x5b, 0x84, + 0xaf, 0xef, 0x77, 0x71, 0x79, 0x2a, 0xc4, 0xa1, 0xd4, 0xc5, 0x49, 0x76, 0xac, 0x75, 0xeb, 0xdb, + 0xef, 0xc8, 0xbb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4b, 0xf5, 0xb7, 0x6e, 0x6b, 0x04, 0x00, + 0x00, } diff --git a/go/notifications.pb.go b/go/notifications.pb.go index 49891c3a0978455f95c72fb87df06053f9c6d533..e0948dc59211c946d1193c101ca69cacf42b928b 100644 --- a/go/notifications.pb.go +++ b/go/notifications.pb.go @@ -24,7 +24,7 @@ type PostReceiveRequest struct { func (m *PostReceiveRequest) Reset() { *m = PostReceiveRequest{} } func (m *PostReceiveRequest) String() string { return proto.CompactTextString(m) } func (*PostReceiveRequest) ProtoMessage() {} -func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } +func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } func (m *PostReceiveRequest) GetRepository() *Repository { if m != nil { @@ -39,7 +39,7 @@ type PostReceiveResponse struct { func (m *PostReceiveResponse) Reset() { *m = PostReceiveResponse{} } func (m *PostReceiveResponse) String() string { return proto.CompactTextString(m) } func (*PostReceiveResponse) ProtoMessage() {} -func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } +func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} } func init() { proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest") @@ -54,74 +54,74 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for Notifications service +// Client API for NotificationService service -type NotificationsClient interface { +type NotificationServiceClient interface { PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) } -type notificationsClient struct { +type notificationServiceClient struct { cc *grpc.ClientConn } -func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient { - return ¬ificationsClient{cc} +func NewNotificationServiceClient(cc *grpc.ClientConn) NotificationServiceClient { + return ¬ificationServiceClient{cc} } -func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) { +func (c *notificationServiceClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) { out := new(PostReceiveResponse) - err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/gitaly.NotificationService/PostReceive", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } -// Server API for Notifications service +// Server API for NotificationService service -type NotificationsServer interface { +type NotificationServiceServer interface { PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error) } -func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) { - s.RegisterService(&_Notifications_serviceDesc, srv) +func RegisterNotificationServiceServer(s *grpc.Server, srv NotificationServiceServer) { + s.RegisterService(&_NotificationService_serviceDesc, srv) } -func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _NotificationService_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PostReceiveRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(NotificationsServer).PostReceive(ctx, in) + return srv.(NotificationServiceServer).PostReceive(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gitaly.Notifications/PostReceive", + FullMethod: "/gitaly.NotificationService/PostReceive", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest)) + return srv.(NotificationServiceServer).PostReceive(ctx, req.(*PostReceiveRequest)) } return interceptor(ctx, in, info, handler) } -var _Notifications_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gitaly.Notifications", - HandlerType: (*NotificationsServer)(nil), +var _NotificationService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.NotificationService", + HandlerType: (*NotificationServiceServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "PostReceive", - Handler: _Notifications_PostReceive_Handler, + Handler: _NotificationService_PostReceive_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "notifications.proto", } -func init() { proto.RegisterFile("notifications.proto", fileDescriptor2) } +func init() { proto.RegisterFile("notifications.proto", fileDescriptor3) } -var fileDescriptor2 = []byte{ - // 163 bytes of a gzipped FileDescriptorProto +var fileDescriptor3 = []byte{ + // 170 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9, 0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, @@ -129,8 +129,8 @@ var fileDescriptor2 = []byte{ 0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17, 0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x0c, 0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x52, 0x12, 0xe5, 0x12, 0x46, 0x31, 0xa9, 0xb8, 0x20, - 0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x92, 0x8b, 0xd7, 0x0f, 0xd9, 0x35, 0x42, 0x1e, 0x5c, 0xdc, 0x48, - 0xea, 0x84, 0xa4, 0x60, 0xc6, 0x62, 0x3a, 0x43, 0x4a, 0x1a, 0xab, 0x1c, 0xc4, 0x60, 0x25, 0x86, - 0x24, 0x36, 0xb0, 0x17, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x5e, 0x1f, 0x64, 0xef, - 0x00, 0x00, 0x00, + 0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x9e, 0x4b, 0xd8, 0x0f, 0xc9, 0x35, 0xc1, 0xa9, 0x45, 0x65, 0x99, + 0xc9, 0xa9, 0x42, 0x1e, 0x5c, 0xdc, 0x48, 0xaa, 0x85, 0xa4, 0x60, 0x86, 0x63, 0x3a, 0x46, 0x4a, + 0x1a, 0xab, 0x1c, 0xc4, 0x78, 0x25, 0x86, 0x24, 0x36, 0xb0, 0x47, 0x8c, 0x01, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x98, 0xea, 0xcc, 0xff, 0xf5, 0x00, 0x00, 0x00, } diff --git a/go/ref.pb.go b/go/ref.pb.go index fe3178e9f12acb6e9242cdfac309abd6d6349435..bd8ed75a8a454be259242b7335f9968e1e089b8b 100644 --- a/go/ref.pb.go +++ b/go/ref.pb.go @@ -41,7 +41,7 @@ func (x FindLocalBranchesRequest_SortBy) String() string { return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x)) } func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) { - return fileDescriptor3, []int{8, 0} + return fileDescriptor4, []int{8, 0} } type FindDefaultBranchNameRequest struct { @@ -51,7 +51,7 @@ type FindDefaultBranchNameRequest struct { func (m *FindDefaultBranchNameRequest) Reset() { *m = FindDefaultBranchNameRequest{} } func (m *FindDefaultBranchNameRequest) String() string { return proto.CompactTextString(m) } func (*FindDefaultBranchNameRequest) ProtoMessage() {} -func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} } +func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } func (m *FindDefaultBranchNameRequest) GetRepository() *Repository { if m != nil { @@ -67,7 +67,7 @@ type FindDefaultBranchNameResponse struct { func (m *FindDefaultBranchNameResponse) Reset() { *m = FindDefaultBranchNameResponse{} } func (m *FindDefaultBranchNameResponse) String() string { return proto.CompactTextString(m) } func (*FindDefaultBranchNameResponse) ProtoMessage() {} -func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} } +func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} } func (m *FindDefaultBranchNameResponse) GetName() []byte { if m != nil { @@ -83,7 +83,7 @@ type FindAllBranchNamesRequest struct { func (m *FindAllBranchNamesRequest) Reset() { *m = FindAllBranchNamesRequest{} } func (m *FindAllBranchNamesRequest) String() string { return proto.CompactTextString(m) } func (*FindAllBranchNamesRequest) ProtoMessage() {} -func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} } +func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} } func (m *FindAllBranchNamesRequest) GetRepository() *Repository { if m != nil { @@ -99,7 +99,7 @@ type FindAllBranchNamesResponse struct { func (m *FindAllBranchNamesResponse) Reset() { *m = FindAllBranchNamesResponse{} } func (m *FindAllBranchNamesResponse) String() string { return proto.CompactTextString(m) } func (*FindAllBranchNamesResponse) ProtoMessage() {} -func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} } +func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{3} } func (m *FindAllBranchNamesResponse) GetNames() [][]byte { if m != nil { @@ -115,7 +115,7 @@ type FindAllTagNamesRequest struct { func (m *FindAllTagNamesRequest) Reset() { *m = FindAllTagNamesRequest{} } func (m *FindAllTagNamesRequest) String() string { return proto.CompactTextString(m) } func (*FindAllTagNamesRequest) ProtoMessage() {} -func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{4} } +func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{4} } func (m *FindAllTagNamesRequest) GetRepository() *Repository { if m != nil { @@ -131,7 +131,7 @@ type FindAllTagNamesResponse struct { func (m *FindAllTagNamesResponse) Reset() { *m = FindAllTagNamesResponse{} } func (m *FindAllTagNamesResponse) String() string { return proto.CompactTextString(m) } func (*FindAllTagNamesResponse) ProtoMessage() {} -func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{5} } +func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{5} } func (m *FindAllTagNamesResponse) GetNames() [][]byte { if m != nil { @@ -151,7 +151,7 @@ type FindRefNameRequest struct { func (m *FindRefNameRequest) Reset() { *m = FindRefNameRequest{} } func (m *FindRefNameRequest) String() string { return proto.CompactTextString(m) } func (*FindRefNameRequest) ProtoMessage() {} -func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{6} } +func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{6} } func (m *FindRefNameRequest) GetRepository() *Repository { if m != nil { @@ -182,7 +182,7 @@ type FindRefNameResponse struct { func (m *FindRefNameResponse) Reset() { *m = FindRefNameResponse{} } func (m *FindRefNameResponse) String() string { return proto.CompactTextString(m) } func (*FindRefNameResponse) ProtoMessage() {} -func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{7} } +func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{7} } func (m *FindRefNameResponse) GetName() []byte { if m != nil { @@ -199,7 +199,7 @@ type FindLocalBranchesRequest struct { func (m *FindLocalBranchesRequest) Reset() { *m = FindLocalBranchesRequest{} } func (m *FindLocalBranchesRequest) String() string { return proto.CompactTextString(m) } func (*FindLocalBranchesRequest) ProtoMessage() {} -func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{8} } +func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{8} } func (m *FindLocalBranchesRequest) GetRepository() *Repository { if m != nil { @@ -222,7 +222,7 @@ type FindLocalBranchesResponse struct { func (m *FindLocalBranchesResponse) Reset() { *m = FindLocalBranchesResponse{} } func (m *FindLocalBranchesResponse) String() string { return proto.CompactTextString(m) } func (*FindLocalBranchesResponse) ProtoMessage() {} -func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{9} } +func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{9} } func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse { if m != nil { @@ -242,7 +242,7 @@ type FindLocalBranchResponse struct { func (m *FindLocalBranchResponse) Reset() { *m = FindLocalBranchResponse{} } func (m *FindLocalBranchResponse) String() string { return proto.CompactTextString(m) } func (*FindLocalBranchResponse) ProtoMessage() {} -func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{10} } +func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{10} } func (m *FindLocalBranchResponse) GetName() []byte { if m != nil { @@ -288,7 +288,7 @@ type FindLocalBranchCommitAuthor struct { func (m *FindLocalBranchCommitAuthor) Reset() { *m = FindLocalBranchCommitAuthor{} } func (m *FindLocalBranchCommitAuthor) String() string { return proto.CompactTextString(m) } func (*FindLocalBranchCommitAuthor) ProtoMessage() {} -func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{11} } +func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{11} } func (m *FindLocalBranchCommitAuthor) GetName() []byte { if m != nil { @@ -335,41 +335,41 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for Ref service +// Client API for RefService service -type RefClient interface { +type RefServiceClient interface { FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) - FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) - FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) + FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (RefService_FindAllBranchNamesClient, error) + FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (RefService_FindAllTagNamesClient, error) // Find a Ref matching the given constraints. Response may be empty. FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) // Return a stream so we can divide the response in chunks of branches - FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error) + FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (RefService_FindLocalBranchesClient, error) } -type refClient struct { +type refServiceClient struct { cc *grpc.ClientConn } -func NewRefClient(cc *grpc.ClientConn) RefClient { - return &refClient{cc} +func NewRefServiceClient(cc *grpc.ClientConn) RefServiceClient { + return &refServiceClient{cc} } -func (c *refClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) { +func (c *refServiceClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) { out := new(FindDefaultBranchNameResponse) - err := grpc.Invoke(ctx, "/gitaly.Ref/FindDefaultBranchName", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/gitaly.RefService/FindDefaultBranchName", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } -func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[0], c.cc, "/gitaly.Ref/FindAllBranchNames", opts...) +func (c *refServiceClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (RefService_FindAllBranchNamesClient, error) { + stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[0], c.cc, "/gitaly.RefService/FindAllBranchNames", opts...) if err != nil { return nil, err } - x := &refFindAllBranchNamesClient{stream} + x := &refServiceFindAllBranchNamesClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -379,16 +379,16 @@ func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNam return x, nil } -type Ref_FindAllBranchNamesClient interface { +type RefService_FindAllBranchNamesClient interface { Recv() (*FindAllBranchNamesResponse, error) grpc.ClientStream } -type refFindAllBranchNamesClient struct { +type refServiceFindAllBranchNamesClient struct { grpc.ClientStream } -func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) { +func (x *refServiceFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) { m := new(FindAllBranchNamesResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -396,12 +396,12 @@ func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error return m, nil } -func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[1], c.cc, "/gitaly.Ref/FindAllTagNames", opts...) +func (c *refServiceClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (RefService_FindAllTagNamesClient, error) { + stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[1], c.cc, "/gitaly.RefService/FindAllTagNames", opts...) if err != nil { return nil, err } - x := &refFindAllTagNamesClient{stream} + x := &refServiceFindAllTagNamesClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -411,16 +411,16 @@ func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequ return x, nil } -type Ref_FindAllTagNamesClient interface { +type RefService_FindAllTagNamesClient interface { Recv() (*FindAllTagNamesResponse, error) grpc.ClientStream } -type refFindAllTagNamesClient struct { +type refServiceFindAllTagNamesClient struct { grpc.ClientStream } -func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) { +func (x *refServiceFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) { m := new(FindAllTagNamesResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -428,21 +428,21 @@ func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) { return m, nil } -func (c *refClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) { +func (c *refServiceClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) { out := new(FindRefNameResponse) - err := grpc.Invoke(ctx, "/gitaly.Ref/FindRefName", in, out, c.cc, opts...) + err := grpc.Invoke(ctx, "/gitaly.RefService/FindRefName", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } -func (c *refClient) FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[2], c.cc, "/gitaly.Ref/FindLocalBranches", opts...) +func (c *refServiceClient) FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (RefService_FindLocalBranchesClient, error) { + stream, err := grpc.NewClientStream(ctx, &_RefService_serviceDesc.Streams[2], c.cc, "/gitaly.RefService/FindLocalBranches", opts...) if err != nil { return nil, err } - x := &refFindLocalBranchesClient{stream} + x := &refServiceFindLocalBranchesClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -452,16 +452,16 @@ func (c *refClient) FindLocalBranches(ctx context.Context, in *FindLocalBranches return x, nil } -type Ref_FindLocalBranchesClient interface { +type RefService_FindLocalBranchesClient interface { Recv() (*FindLocalBranchesResponse, error) grpc.ClientStream } -type refFindLocalBranchesClient struct { +type refServiceFindLocalBranchesClient struct { grpc.ClientStream } -func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) { +func (x *refServiceFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) { m := new(FindLocalBranchesResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -469,195 +469,195 @@ func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) return m, nil } -// Server API for Ref service +// Server API for RefService service -type RefServer interface { +type RefServiceServer interface { FindDefaultBranchName(context.Context, *FindDefaultBranchNameRequest) (*FindDefaultBranchNameResponse, error) - FindAllBranchNames(*FindAllBranchNamesRequest, Ref_FindAllBranchNamesServer) error - FindAllTagNames(*FindAllTagNamesRequest, Ref_FindAllTagNamesServer) error + FindAllBranchNames(*FindAllBranchNamesRequest, RefService_FindAllBranchNamesServer) error + FindAllTagNames(*FindAllTagNamesRequest, RefService_FindAllTagNamesServer) error // Find a Ref matching the given constraints. Response may be empty. FindRefName(context.Context, *FindRefNameRequest) (*FindRefNameResponse, error) // Return a stream so we can divide the response in chunks of branches - FindLocalBranches(*FindLocalBranchesRequest, Ref_FindLocalBranchesServer) error + FindLocalBranches(*FindLocalBranchesRequest, RefService_FindLocalBranchesServer) error } -func RegisterRefServer(s *grpc.Server, srv RefServer) { - s.RegisterService(&_Ref_serviceDesc, srv) +func RegisterRefServiceServer(s *grpc.Server, srv RefServiceServer) { + s.RegisterService(&_RefService_serviceDesc, srv) } -func _Ref_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _RefService_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(FindDefaultBranchNameRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(RefServer).FindDefaultBranchName(ctx, in) + return srv.(RefServiceServer).FindDefaultBranchName(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gitaly.Ref/FindDefaultBranchName", + FullMethod: "/gitaly.RefService/FindDefaultBranchName", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(RefServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest)) + return srv.(RefServiceServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest)) } return interceptor(ctx, in, info, handler) } -func _Ref_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error { +func _RefService_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(FindAllBranchNamesRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(RefServer).FindAllBranchNames(m, &refFindAllBranchNamesServer{stream}) + return srv.(RefServiceServer).FindAllBranchNames(m, &refServiceFindAllBranchNamesServer{stream}) } -type Ref_FindAllBranchNamesServer interface { +type RefService_FindAllBranchNamesServer interface { Send(*FindAllBranchNamesResponse) error grpc.ServerStream } -type refFindAllBranchNamesServer struct { +type refServiceFindAllBranchNamesServer struct { grpc.ServerStream } -func (x *refFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error { +func (x *refServiceFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error { return x.ServerStream.SendMsg(m) } -func _Ref_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error { +func _RefService_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(FindAllTagNamesRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(RefServer).FindAllTagNames(m, &refFindAllTagNamesServer{stream}) + return srv.(RefServiceServer).FindAllTagNames(m, &refServiceFindAllTagNamesServer{stream}) } -type Ref_FindAllTagNamesServer interface { +type RefService_FindAllTagNamesServer interface { Send(*FindAllTagNamesResponse) error grpc.ServerStream } -type refFindAllTagNamesServer struct { +type refServiceFindAllTagNamesServer struct { grpc.ServerStream } -func (x *refFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error { +func (x *refServiceFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error { return x.ServerStream.SendMsg(m) } -func _Ref_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _RefService_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(FindRefNameRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(RefServer).FindRefName(ctx, in) + return srv.(RefServiceServer).FindRefName(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gitaly.Ref/FindRefName", + FullMethod: "/gitaly.RefService/FindRefName", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(RefServer).FindRefName(ctx, req.(*FindRefNameRequest)) + return srv.(RefServiceServer).FindRefName(ctx, req.(*FindRefNameRequest)) } return interceptor(ctx, in, info, handler) } -func _Ref_FindLocalBranches_Handler(srv interface{}, stream grpc.ServerStream) error { +func _RefService_FindLocalBranches_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(FindLocalBranchesRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(RefServer).FindLocalBranches(m, &refFindLocalBranchesServer{stream}) + return srv.(RefServiceServer).FindLocalBranches(m, &refServiceFindLocalBranchesServer{stream}) } -type Ref_FindLocalBranchesServer interface { +type RefService_FindLocalBranchesServer interface { Send(*FindLocalBranchesResponse) error grpc.ServerStream } -type refFindLocalBranchesServer struct { +type refServiceFindLocalBranchesServer struct { grpc.ServerStream } -func (x *refFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error { +func (x *refServiceFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error { return x.ServerStream.SendMsg(m) } -var _Ref_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gitaly.Ref", - HandlerType: (*RefServer)(nil), +var _RefService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.RefService", + HandlerType: (*RefServiceServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "FindDefaultBranchName", - Handler: _Ref_FindDefaultBranchName_Handler, + Handler: _RefService_FindDefaultBranchName_Handler, }, { MethodName: "FindRefName", - Handler: _Ref_FindRefName_Handler, + Handler: _RefService_FindRefName_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "FindAllBranchNames", - Handler: _Ref_FindAllBranchNames_Handler, + Handler: _RefService_FindAllBranchNames_Handler, ServerStreams: true, }, { StreamName: "FindAllTagNames", - Handler: _Ref_FindAllTagNames_Handler, + Handler: _RefService_FindAllTagNames_Handler, ServerStreams: true, }, { StreamName: "FindLocalBranches", - Handler: _Ref_FindLocalBranches_Handler, + Handler: _RefService_FindLocalBranches_Handler, ServerStreams: true, }, }, Metadata: "ref.proto", } -func init() { proto.RegisterFile("ref.proto", fileDescriptor3) } - -var fileDescriptor3 = []byte{ - // 615 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x51, 0x73, 0xd2, 0x4c, - 0x14, 0x6d, 0x0a, 0xe5, 0x6b, 0x2f, 0xf9, 0x5a, 0x5c, 0x6b, 0x8d, 0x41, 0x85, 0x46, 0x3b, 0xe2, - 0x4b, 0x70, 0xd2, 0xf1, 0xc9, 0x17, 0x29, 0xe0, 0xd4, 0x99, 0x8a, 0xce, 0x82, 0x8e, 0x0f, 0xce, - 0x30, 0x0b, 0x6c, 0x20, 0x4e, 0xc2, 0x62, 0xb2, 0x8c, 0xf2, 0xe0, 0x2f, 0xf0, 0x87, 0xf9, 0xe6, - 0x6f, 0x72, 0xd8, 0x4d, 0x68, 0xa0, 0x49, 0xea, 0x0c, 0x4f, 0xe1, 0xde, 0x3d, 0xe7, 0xde, 0xbb, - 0xf7, 0xb0, 0x07, 0x0e, 0x7c, 0x6a, 0x9b, 0x33, 0x9f, 0x71, 0x86, 0x0a, 0x63, 0x87, 0x13, 0x77, - 0xa1, 0xab, 0xc1, 0x84, 0xf8, 0x74, 0x24, 0xb3, 0x7a, 0x65, 0xcc, 0xd8, 0xd8, 0xa5, 0x75, 0x11, - 0x0d, 0xe6, 0x76, 0x9d, 0x3b, 0x1e, 0x0d, 0x38, 0xf1, 0x66, 0x12, 0x60, 0x60, 0x78, 0xf8, 0xc6, - 0x99, 0x8e, 0x5a, 0xd4, 0x26, 0x73, 0x97, 0x5f, 0xf8, 0x64, 0x3a, 0x9c, 0x74, 0x88, 0x47, 0x31, - 0xfd, 0x36, 0xa7, 0x01, 0x47, 0x16, 0x80, 0x4f, 0x67, 0x2c, 0x70, 0x38, 0xf3, 0x17, 0x9a, 0x52, - 0x55, 0x6a, 0x45, 0x0b, 0x99, 0xb2, 0x97, 0x89, 0x57, 0x27, 0x38, 0x86, 0x32, 0xce, 0xe1, 0x51, - 0x4a, 0xcd, 0x60, 0xc6, 0xa6, 0x01, 0x45, 0x08, 0xf2, 0x53, 0xe2, 0x51, 0x51, 0x4e, 0xc5, 0xe2, - 0xb7, 0xf1, 0x1e, 0x1e, 0x2c, 0x49, 0x0d, 0xd7, 0xbd, 0x26, 0x04, 0xdb, 0x4c, 0x61, 0x81, 0x9e, - 0x54, 0x30, 0x1c, 0xe1, 0x18, 0xf6, 0x96, 0x6d, 0x03, 0x4d, 0xa9, 0xe6, 0x6a, 0x2a, 0x96, 0x81, - 0x71, 0x05, 0x27, 0x21, 0xa7, 0x47, 0xc6, 0x5b, 0x4f, 0x50, 0x87, 0xfb, 0x37, 0xaa, 0x65, 0xb6, - 0xff, 0x09, 0x68, 0x49, 0xc0, 0xd4, 0xde, 0x52, 0x02, 0x54, 0x86, 0x83, 0x21, 0xf3, 0x3c, 0x87, - 0xf7, 0x9d, 0x91, 0xb6, 0x5b, 0x55, 0x6a, 0x07, 0x78, 0x5f, 0x26, 0xde, 0x8e, 0xd0, 0x09, 0x14, - 0x66, 0x3e, 0xb5, 0x9d, 0x1f, 0x5a, 0x4e, 0x08, 0x10, 0x46, 0xc6, 0x73, 0xb8, 0xbb, 0xd6, 0x3e, - 0x43, 0xad, 0xdf, 0x0a, 0x68, 0x4b, 0xec, 0x15, 0x1b, 0x92, 0x70, 0xbf, 0x5b, 0xed, 0x0a, 0xbd, - 0x86, 0xff, 0x02, 0xe6, 0xf3, 0xfe, 0x60, 0x21, 0xc6, 0x3d, 0xb4, 0x9e, 0x45, 0x84, 0xb4, 0x36, - 0x66, 0x97, 0xf9, 0xfc, 0x62, 0x81, 0x0b, 0x81, 0xf8, 0x1a, 0x2f, 0xa1, 0x20, 0x33, 0x68, 0x1f, - 0xf2, 0x9d, 0xc6, 0xbb, 0x76, 0x69, 0x07, 0x1d, 0x41, 0xf1, 0xe3, 0x87, 0x56, 0xa3, 0xd7, 0x6e, - 0xf5, 0x1b, 0xdd, 0x66, 0x49, 0x41, 0x25, 0x50, 0xa3, 0x44, 0xab, 0xdd, 0x6d, 0x96, 0x76, 0x8d, - 0xcf, 0xf2, 0x7f, 0xb7, 0xd1, 0x21, 0xbc, 0xfa, 0x2b, 0xd8, 0x1f, 0x84, 0x39, 0xa1, 0x54, 0xd1, - 0xaa, 0xa4, 0x8c, 0x15, 0x51, 0xf0, 0x8a, 0x60, 0xfc, 0xda, 0x95, 0xfa, 0x27, 0xa0, 0x92, 0x76, - 0x9a, 0xad, 0xd9, 0x19, 0x1c, 0x86, 0x87, 0xc1, 0x7c, 0xf0, 0x95, 0x0e, 0x79, 0xa8, 0xdd, 0xff, - 0x32, 0xdb, 0x95, 0x49, 0x74, 0x09, 0x61, 0xa2, 0x4f, 0xe6, 0x7c, 0xc2, 0x7c, 0x2d, 0x2f, 0xb6, - 0xff, 0x24, 0x65, 0xea, 0xa6, 0xc0, 0x36, 0x04, 0x14, 0xab, 0xc3, 0x58, 0x84, 0x3a, 0x50, 0x0a, - 0x2b, 0xc9, 0x0f, 0xa7, 0xbe, 0xb6, 0xf7, 0xef, 0xc5, 0x8e, 0x24, 0xab, 0x19, 0x71, 0x8d, 0xef, - 0x50, 0xce, 0xc0, 0x27, 0x2e, 0xe4, 0x18, 0xf6, 0xa8, 0x47, 0x1c, 0x57, 0x2c, 0x43, 0xc5, 0x32, - 0x40, 0x26, 0xe4, 0x47, 0x84, 0x53, 0x71, 0xff, 0xa2, 0xa5, 0x9b, 0xd2, 0xe1, 0xcc, 0xc8, 0xe1, - 0xcc, 0x5e, 0xe4, 0x70, 0x58, 0xe0, 0xac, 0x3f, 0x39, 0xc8, 0x61, 0x6a, 0x23, 0x1b, 0xee, 0x25, - 0xba, 0x12, 0x7a, 0x1a, 0xbf, 0x4f, 0x9a, 0x11, 0xea, 0x67, 0xb7, 0xa0, 0xa4, 0xb0, 0xc6, 0x0e, - 0xea, 0xcb, 0x47, 0xbc, 0xee, 0x3b, 0xe8, 0x34, 0x4e, 0x4f, 0x34, 0x39, 0xdd, 0xc8, 0x82, 0x44, - 0xe5, 0x5f, 0x28, 0xe8, 0x13, 0x1c, 0x6d, 0xd8, 0x0a, 0x7a, 0xbc, 0x41, 0xdd, 0x70, 0x2f, 0xbd, - 0x92, 0x7a, 0x1e, 0xab, 0x7b, 0x09, 0xc5, 0xd8, 0xf3, 0x47, 0x7a, 0x9c, 0xb3, 0x6e, 0x49, 0x7a, - 0x39, 0xf1, 0x6c, 0xb5, 0x82, 0x2f, 0x70, 0xe7, 0xc6, 0x9b, 0x42, 0xd5, 0xdb, 0x1e, 0xb4, 0x7e, - 0x9a, 0x81, 0xb8, 0x9e, 0x73, 0x50, 0x10, 0x52, 0x9f, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x2c, - 0xc7, 0x33, 0x9b, 0xfd, 0x06, 0x00, 0x00, +func init() { proto.RegisterFile("ref.proto", fileDescriptor4) } + +var fileDescriptor4 = []byte{ + // 620 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xc1, 0x6e, 0xd3, 0x40, + 0x10, 0xad, 0xdb, 0x34, 0xb4, 0x13, 0xd3, 0x86, 0xa5, 0x14, 0xe3, 0x02, 0x4d, 0x0d, 0x15, 0xe5, + 0xe2, 0x22, 0x57, 0x9c, 0xb8, 0x90, 0x26, 0x45, 0x45, 0x2a, 0x05, 0x6d, 0x02, 0xe2, 0x80, 0x14, + 0x6d, 0x9c, 0x75, 0x62, 0x64, 0x67, 0xc3, 0x7a, 0x03, 0xe4, 0xc0, 0x17, 0xf0, 0x61, 0x7c, 0x01, + 0xff, 0x83, 0xb2, 0x6b, 0xa7, 0x4e, 0x6a, 0xbb, 0x48, 0x39, 0x39, 0x33, 0xfb, 0xde, 0xcc, 0xec, + 0xbc, 0xec, 0x83, 0x4d, 0x4e, 0x3d, 0x7b, 0xc4, 0x99, 0x60, 0xa8, 0xdc, 0xf7, 0x05, 0x09, 0x26, + 0xa6, 0x1e, 0x0d, 0x08, 0xa7, 0x3d, 0x95, 0x35, 0xf7, 0xfb, 0x8c, 0xf5, 0x03, 0x7a, 0x2c, 0xa3, + 0xee, 0xd8, 0x3b, 0x16, 0x7e, 0x48, 0x23, 0x41, 0xc2, 0x91, 0x02, 0x58, 0x18, 0x1e, 0xbe, 0xf1, + 0x87, 0xbd, 0x26, 0xf5, 0xc8, 0x38, 0x10, 0xa7, 0x9c, 0x0c, 0xdd, 0xc1, 0x25, 0x09, 0x29, 0xa6, + 0xdf, 0xc6, 0x34, 0x12, 0xc8, 0x01, 0xe0, 0x74, 0xc4, 0x22, 0x5f, 0x30, 0x3e, 0x31, 0xb4, 0x9a, + 0x76, 0x54, 0x71, 0x90, 0xad, 0x7a, 0xd9, 0x78, 0x76, 0x82, 0x53, 0x28, 0xeb, 0x04, 0x1e, 0xe5, + 0xd4, 0x8c, 0x46, 0x6c, 0x18, 0x51, 0x84, 0xa0, 0x34, 0x24, 0x21, 0x95, 0xe5, 0x74, 0x2c, 0x7f, + 0x5b, 0xef, 0xe1, 0xc1, 0x94, 0x54, 0x0f, 0x82, 0x2b, 0x42, 0xb4, 0xcc, 0x14, 0x0e, 0x98, 0x59, + 0x05, 0xe3, 0x11, 0x76, 0x60, 0x7d, 0xda, 0x36, 0x32, 0xb4, 0xda, 0xda, 0x91, 0x8e, 0x55, 0x60, + 0x5d, 0xc0, 0x6e, 0xcc, 0x69, 0x93, 0xfe, 0xd2, 0x13, 0x1c, 0xc3, 0xfd, 0x6b, 0xd5, 0x0a, 0xdb, + 0xff, 0x02, 0x34, 0x25, 0x60, 0xea, 0x2d, 0x29, 0x01, 0xda, 0x83, 0x4d, 0x97, 0x85, 0xa1, 0x2f, + 0x3a, 0x7e, 0xcf, 0x58, 0xad, 0x69, 0x47, 0x9b, 0x78, 0x43, 0x25, 0xde, 0xf6, 0xd0, 0x2e, 0x94, + 0x47, 0x9c, 0x7a, 0xfe, 0x4f, 0x63, 0x4d, 0x0a, 0x10, 0x47, 0xd6, 0x73, 0xb8, 0x3b, 0xd7, 0xbe, + 0x40, 0xad, 0x3f, 0x1a, 0x18, 0x53, 0xec, 0x05, 0x73, 0x49, 0xbc, 0xdf, 0xa5, 0x76, 0x85, 0x5e, + 0xc3, 0xad, 0x88, 0x71, 0xd1, 0xe9, 0x4e, 0xe4, 0xb8, 0x5b, 0xce, 0xb3, 0x84, 0x90, 0xd7, 0xc6, + 0x6e, 0x31, 0x2e, 0x4e, 0x27, 0xb8, 0x1c, 0xc9, 0xaf, 0xf5, 0x12, 0xca, 0x2a, 0x83, 0x36, 0xa0, + 0x74, 0x59, 0x7f, 0x77, 0x56, 0x5d, 0x41, 0xdb, 0x50, 0xf9, 0xf8, 0xa1, 0x59, 0x6f, 0x9f, 0x35, + 0x3b, 0xf5, 0x56, 0xa3, 0xaa, 0xa1, 0x2a, 0xe8, 0x49, 0xa2, 0x79, 0xd6, 0x6a, 0x54, 0x57, 0xad, + 0xcf, 0xea, 0x7f, 0xb7, 0xd0, 0x21, 0xbe, 0xfa, 0x2b, 0xd8, 0xe8, 0xc6, 0x39, 0xa9, 0x54, 0xc5, + 0xd9, 0xcf, 0x19, 0x2b, 0xa1, 0xe0, 0x19, 0xc1, 0xfa, 0xbd, 0xaa, 0xf4, 0xcf, 0x40, 0x65, 0xed, + 0xb4, 0x58, 0xb3, 0x43, 0xd8, 0x8a, 0x0f, 0xa3, 0x71, 0xf7, 0x2b, 0x75, 0x45, 0xac, 0xdd, 0x6d, + 0x95, 0x6d, 0xa9, 0x24, 0x3a, 0x87, 0x38, 0xd1, 0x21, 0x63, 0x31, 0x60, 0xdc, 0x28, 0xc9, 0xed, + 0x3f, 0xc9, 0x99, 0xba, 0x21, 0xb1, 0x75, 0x09, 0xc5, 0xba, 0x9b, 0x8a, 0xd0, 0x25, 0x54, 0xe3, + 0x4a, 0xea, 0x23, 0x28, 0x37, 0xd6, 0xff, 0xbf, 0xd8, 0xb6, 0x62, 0x35, 0x12, 0xae, 0xf5, 0x03, + 0xf6, 0x0a, 0xf0, 0x99, 0x0b, 0xd9, 0x81, 0x75, 0x1a, 0x12, 0x3f, 0x90, 0xcb, 0xd0, 0xb1, 0x0a, + 0x90, 0x0d, 0xa5, 0x1e, 0x11, 0x54, 0xde, 0xbf, 0xe2, 0x98, 0xb6, 0x72, 0x38, 0x3b, 0x71, 0x38, + 0xbb, 0x9d, 0x38, 0x1c, 0x96, 0x38, 0xe7, 0xef, 0x1a, 0x00, 0xa6, 0x5e, 0x8b, 0xf2, 0xef, 0xbe, + 0x4b, 0x91, 0x07, 0xf7, 0x32, 0xcd, 0x09, 0x3d, 0x4d, 0x5f, 0x2b, 0xcf, 0x0f, 0xcd, 0xc3, 0x1b, + 0x50, 0x4a, 0x5f, 0x6b, 0x05, 0x75, 0xd4, 0x5b, 0x9e, 0xb7, 0x1f, 0x74, 0x90, 0xa6, 0x67, 0x7a, + 0x9d, 0x69, 0x15, 0x41, 0x92, 0xf2, 0x2f, 0x34, 0xf4, 0x09, 0xb6, 0x17, 0xdc, 0x05, 0x3d, 0x5e, + 0xa0, 0x2e, 0x98, 0x98, 0xb9, 0x9f, 0x7b, 0x9e, 0xaa, 0x7b, 0x0e, 0x95, 0x94, 0x0b, 0x20, 0x33, + 0xcd, 0x99, 0x77, 0x26, 0x73, 0x2f, 0xf3, 0x6c, 0xb6, 0x82, 0x2f, 0x70, 0xe7, 0xda, 0xd3, 0x42, + 0xb5, 0x9b, 0xde, 0xb5, 0x79, 0x50, 0x80, 0xb8, 0x9a, 0xb3, 0x5b, 0x96, 0x8a, 0x9f, 0xfc, 0x0b, + 0x00, 0x00, 0xff, 0xff, 0xaa, 0x36, 0x2a, 0x93, 0x04, 0x07, 0x00, 0x00, } diff --git a/go/repository-service.pb.go b/go/repository-service.pb.go index 6b72a9fee0ca0d4da0e4c6073dffc16f7b27d474..9a213f26cc330c96bdb66d005687cb03fc9467ab 100644 --- a/go/repository-service.pb.go +++ b/go/repository-service.pb.go @@ -24,7 +24,7 @@ type RepositoryExistsRequest struct { func (m *RepositoryExistsRequest) Reset() { *m = RepositoryExistsRequest{} } func (m *RepositoryExistsRequest) String() string { return proto.CompactTextString(m) } func (*RepositoryExistsRequest) ProtoMessage() {} -func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} } +func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } func (m *RepositoryExistsRequest) GetRepository() *Repository { if m != nil { @@ -40,7 +40,7 @@ type RepositoryExistsResponse struct { func (m *RepositoryExistsResponse) Reset() { *m = RepositoryExistsResponse{} } func (m *RepositoryExistsResponse) String() string { return proto.CompactTextString(m) } func (*RepositoryExistsResponse) ProtoMessage() {} -func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} } +func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} } func (m *RepositoryExistsResponse) GetExists() bool { if m != nil { @@ -126,9 +126,9 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{ Metadata: "repository-service.proto", } -func init() { proto.RegisterFile("repository-service.proto", fileDescriptor4) } +func init() { proto.RegisterFile("repository-service.proto", fileDescriptor5) } -var fileDescriptor4 = []byte{ +var fileDescriptor5 = []byte{ // 172 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x4a, 0x2d, 0xc8, 0x2f, 0xce, 0x2c, 0xc9, 0x2f, 0xaa, 0xd4, 0x2d, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, diff --git a/go/shared.pb.go b/go/shared.pb.go index fa678228061785d547671bee09b32212dbf9c152..71598846d1f8c2450d98cee98e54f6b7f88d598e 100644 --- a/go/shared.pb.go +++ b/go/shared.pb.go @@ -20,7 +20,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 fileDescriptor5, []int{0} } +func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } func (m *Repository) GetStorageName() string { if m != nil { @@ -43,7 +43,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 fileDescriptor5, []int{1} } +func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} } func (m *ExitStatus) GetValue() int32 { if m != nil { @@ -57,9 +57,9 @@ func init() { proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus") } -func init() { proto.RegisterFile("shared.proto", fileDescriptor5) } +func init() { proto.RegisterFile("shared.proto", fileDescriptor6) } -var fileDescriptor5 = []byte{ +var fileDescriptor6 = []byte{ // 164 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0xce, 0x31, 0x0f, 0x82, 0x30, 0x10, 0x05, 0xe0, 0x14, 0x81, 0xe8, 0x89, 0x89, 0x69, 0x1c, 0x18, 0x11, 0x17, 0x26, 0x17, 0x7f, diff --git a/go/smarthttp.pb.go b/go/smarthttp.pb.go index c6017fc287de135dedb4fe616a1a57fa310723f5..46802c2c4ddb93167d574beec78daa55152e5c5f 100644 --- a/go/smarthttp.pb.go +++ b/go/smarthttp.pb.go @@ -24,7 +24,7 @@ type InfoRefsRequest struct { func (m *InfoRefsRequest) Reset() { *m = InfoRefsRequest{} } func (m *InfoRefsRequest) String() string { return proto.CompactTextString(m) } func (*InfoRefsRequest) ProtoMessage() {} -func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } +func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} } func (m *InfoRefsRequest) GetRepository() *Repository { if m != nil { @@ -40,7 +40,7 @@ type InfoRefsResponse struct { func (m *InfoRefsResponse) Reset() { *m = InfoRefsResponse{} } func (m *InfoRefsResponse) String() string { return proto.CompactTextString(m) } func (*InfoRefsResponse) ProtoMessage() {} -func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} } +func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} } func (m *InfoRefsResponse) GetData() []byte { if m != nil { @@ -59,7 +59,7 @@ type PostUploadPackRequest struct { func (m *PostUploadPackRequest) Reset() { *m = PostUploadPackRequest{} } func (m *PostUploadPackRequest) String() string { return proto.CompactTextString(m) } func (*PostUploadPackRequest) ProtoMessage() {} -func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} } +func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} } func (m *PostUploadPackRequest) GetRepository() *Repository { if m != nil { @@ -83,7 +83,7 @@ type PostUploadPackResponse struct { func (m *PostUploadPackResponse) Reset() { *m = PostUploadPackResponse{} } func (m *PostUploadPackResponse) String() string { return proto.CompactTextString(m) } func (*PostUploadPackResponse) ProtoMessage() {} -func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} } +func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} } func (m *PostUploadPackResponse) GetData() []byte { if m != nil { @@ -106,7 +106,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 fileDescriptor6, []int{4} } +func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{4} } func (m *PostReceivePackRequest) GetRepository() *Repository { if m != nil { @@ -144,7 +144,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 fileDescriptor6, []int{5} } +func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{5} } func (m *PostReceivePackResponse) GetData() []byte { if m != nil { @@ -170,33 +170,33 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for SmartHTTP service +// Client API for SmartHTTPService service -type SmartHTTPClient interface { +type SmartHTTPServiceClient interface { // The response body for GET /info/refs?service=git-upload-pack - InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) + InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsUploadPackClient, error) // The response body for GET /info/refs?service=git-receive-pack - InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) + InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsReceivePackClient, error) // Request and response body for POST /upload-pack - PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) + PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostUploadPackClient, error) // Request and response body for POST /receive-pack - PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) + PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostReceivePackClient, error) } -type smartHTTPClient struct { +type smartHTTPServiceClient struct { cc *grpc.ClientConn } -func NewSmartHTTPClient(cc *grpc.ClientConn) SmartHTTPClient { - return &smartHTTPClient{cc} +func NewSmartHTTPServiceClient(cc *grpc.ClientConn) SmartHTTPServiceClient { + return &smartHTTPServiceClient{cc} } -func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) { - stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTP/InfoRefsUploadPack", opts...) +func (c *smartHTTPServiceClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsUploadPackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTPService/InfoRefsUploadPack", opts...) if err != nil { return nil, err } - x := &smartHTTPInfoRefsUploadPackClient{stream} + x := &smartHTTPServiceInfoRefsUploadPackClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -206,16 +206,16 @@ func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRe return x, nil } -type SmartHTTP_InfoRefsUploadPackClient interface { +type SmartHTTPService_InfoRefsUploadPackClient interface { Recv() (*InfoRefsResponse, error) grpc.ClientStream } -type smartHTTPInfoRefsUploadPackClient struct { +type smartHTTPServiceInfoRefsUploadPackClient struct { grpc.ClientStream } -func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) { +func (x *smartHTTPServiceInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) { m := new(InfoRefsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -223,12 +223,12 @@ func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) { return m, nil } -func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) { - stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTP/InfoRefsReceivePack", opts...) +func (c *smartHTTPServiceClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTPService_InfoRefsReceivePackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTPService/InfoRefsReceivePack", opts...) if err != nil { return nil, err } - x := &smartHTTPInfoRefsReceivePackClient{stream} + x := &smartHTTPServiceInfoRefsReceivePackClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -238,16 +238,16 @@ func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsR return x, nil } -type SmartHTTP_InfoRefsReceivePackClient interface { +type SmartHTTPService_InfoRefsReceivePackClient interface { Recv() (*InfoRefsResponse, error) grpc.ClientStream } -type smartHTTPInfoRefsReceivePackClient struct { +type smartHTTPServiceInfoRefsReceivePackClient struct { grpc.ClientStream } -func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) { +func (x *smartHTTPServiceInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) { m := new(InfoRefsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -255,30 +255,30 @@ func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) { return m, nil } -func (c *smartHTTPClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) { - stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTP/PostUploadPack", opts...) +func (c *smartHTTPServiceClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostUploadPackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTPService/PostUploadPack", opts...) if err != nil { return nil, err } - x := &smartHTTPPostUploadPackClient{stream} + x := &smartHTTPServicePostUploadPackClient{stream} return x, nil } -type SmartHTTP_PostUploadPackClient interface { +type SmartHTTPService_PostUploadPackClient interface { Send(*PostUploadPackRequest) error Recv() (*PostUploadPackResponse, error) grpc.ClientStream } -type smartHTTPPostUploadPackClient struct { +type smartHTTPServicePostUploadPackClient struct { grpc.ClientStream } -func (x *smartHTTPPostUploadPackClient) Send(m *PostUploadPackRequest) error { +func (x *smartHTTPServicePostUploadPackClient) Send(m *PostUploadPackRequest) error { return x.ClientStream.SendMsg(m) } -func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) { +func (x *smartHTTPServicePostUploadPackClient) Recv() (*PostUploadPackResponse, error) { m := new(PostUploadPackResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -286,30 +286,30 @@ func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) return m, nil } -func (c *smartHTTPClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) { - stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTP/PostReceivePack", opts...) +func (c *smartHTTPServiceClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTPService_PostReceivePackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SmartHTTPService_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTPService/PostReceivePack", opts...) if err != nil { return nil, err } - x := &smartHTTPPostReceivePackClient{stream} + x := &smartHTTPServicePostReceivePackClient{stream} return x, nil } -type SmartHTTP_PostReceivePackClient interface { +type SmartHTTPService_PostReceivePackClient interface { Send(*PostReceivePackRequest) error Recv() (*PostReceivePackResponse, error) grpc.ClientStream } -type smartHTTPPostReceivePackClient struct { +type smartHTTPServicePostReceivePackClient struct { grpc.ClientStream } -func (x *smartHTTPPostReceivePackClient) Send(m *PostReceivePackRequest) error { +func (x *smartHTTPServicePostReceivePackClient) Send(m *PostReceivePackRequest) error { return x.ClientStream.SendMsg(m) } -func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error) { +func (x *smartHTTPServicePostReceivePackClient) Recv() (*PostReceivePackResponse, error) { m := new(PostReceivePackResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -317,84 +317,84 @@ func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error return m, nil } -// Server API for SmartHTTP service +// Server API for SmartHTTPService service -type SmartHTTPServer interface { +type SmartHTTPServiceServer interface { // The response body for GET /info/refs?service=git-upload-pack - InfoRefsUploadPack(*InfoRefsRequest, SmartHTTP_InfoRefsUploadPackServer) error + InfoRefsUploadPack(*InfoRefsRequest, SmartHTTPService_InfoRefsUploadPackServer) error // The response body for GET /info/refs?service=git-receive-pack - InfoRefsReceivePack(*InfoRefsRequest, SmartHTTP_InfoRefsReceivePackServer) error + InfoRefsReceivePack(*InfoRefsRequest, SmartHTTPService_InfoRefsReceivePackServer) error // Request and response body for POST /upload-pack - PostUploadPack(SmartHTTP_PostUploadPackServer) error + PostUploadPack(SmartHTTPService_PostUploadPackServer) error // Request and response body for POST /receive-pack - PostReceivePack(SmartHTTP_PostReceivePackServer) error + PostReceivePack(SmartHTTPService_PostReceivePackServer) error } -func RegisterSmartHTTPServer(s *grpc.Server, srv SmartHTTPServer) { - s.RegisterService(&_SmartHTTP_serviceDesc, srv) +func RegisterSmartHTTPServiceServer(s *grpc.Server, srv SmartHTTPServiceServer) { + s.RegisterService(&_SmartHTTPService_serviceDesc, srv) } -func _SmartHTTP_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { +func _SmartHTTPService_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(InfoRefsRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(SmartHTTPServer).InfoRefsUploadPack(m, &smartHTTPInfoRefsUploadPackServer{stream}) + return srv.(SmartHTTPServiceServer).InfoRefsUploadPack(m, &smartHTTPServiceInfoRefsUploadPackServer{stream}) } -type SmartHTTP_InfoRefsUploadPackServer interface { +type SmartHTTPService_InfoRefsUploadPackServer interface { Send(*InfoRefsResponse) error grpc.ServerStream } -type smartHTTPInfoRefsUploadPackServer struct { +type smartHTTPServiceInfoRefsUploadPackServer struct { grpc.ServerStream } -func (x *smartHTTPInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error { +func (x *smartHTTPServiceInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error { return x.ServerStream.SendMsg(m) } -func _SmartHTTP_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { +func _SmartHTTPService_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(InfoRefsRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(SmartHTTPServer).InfoRefsReceivePack(m, &smartHTTPInfoRefsReceivePackServer{stream}) + return srv.(SmartHTTPServiceServer).InfoRefsReceivePack(m, &smartHTTPServiceInfoRefsReceivePackServer{stream}) } -type SmartHTTP_InfoRefsReceivePackServer interface { +type SmartHTTPService_InfoRefsReceivePackServer interface { Send(*InfoRefsResponse) error grpc.ServerStream } -type smartHTTPInfoRefsReceivePackServer struct { +type smartHTTPServiceInfoRefsReceivePackServer struct { grpc.ServerStream } -func (x *smartHTTPInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error { +func (x *smartHTTPServiceInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error { return x.ServerStream.SendMsg(m) } -func _SmartHTTP_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(SmartHTTPServer).PostUploadPack(&smartHTTPPostUploadPackServer{stream}) +func _SmartHTTPService_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SmartHTTPServiceServer).PostUploadPack(&smartHTTPServicePostUploadPackServer{stream}) } -type SmartHTTP_PostUploadPackServer interface { +type SmartHTTPService_PostUploadPackServer interface { Send(*PostUploadPackResponse) error Recv() (*PostUploadPackRequest, error) grpc.ServerStream } -type smartHTTPPostUploadPackServer struct { +type smartHTTPServicePostUploadPackServer struct { grpc.ServerStream } -func (x *smartHTTPPostUploadPackServer) Send(m *PostUploadPackResponse) error { +func (x *smartHTTPServicePostUploadPackServer) Send(m *PostUploadPackResponse) error { return x.ServerStream.SendMsg(m) } -func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) { +func (x *smartHTTPServicePostUploadPackServer) Recv() (*PostUploadPackRequest, error) { m := new(PostUploadPackRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err @@ -402,25 +402,25 @@ func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) { return m, nil } -func _SmartHTTP_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(SmartHTTPServer).PostReceivePack(&smartHTTPPostReceivePackServer{stream}) +func _SmartHTTPService_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SmartHTTPServiceServer).PostReceivePack(&smartHTTPServicePostReceivePackServer{stream}) } -type SmartHTTP_PostReceivePackServer interface { +type SmartHTTPService_PostReceivePackServer interface { Send(*PostReceivePackResponse) error Recv() (*PostReceivePackRequest, error) grpc.ServerStream } -type smartHTTPPostReceivePackServer struct { +type smartHTTPServicePostReceivePackServer struct { grpc.ServerStream } -func (x *smartHTTPPostReceivePackServer) Send(m *PostReceivePackResponse) error { +func (x *smartHTTPServicePostReceivePackServer) Send(m *PostReceivePackResponse) error { return x.ServerStream.SendMsg(m) } -func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) { +func (x *smartHTTPServicePostReceivePackServer) Recv() (*PostReceivePackRequest, error) { m := new(PostReceivePackRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err @@ -428,30 +428,30 @@ func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) return m, nil } -var _SmartHTTP_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gitaly.SmartHTTP", - HandlerType: (*SmartHTTPServer)(nil), +var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.SmartHTTPService", + HandlerType: (*SmartHTTPServiceServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "InfoRefsUploadPack", - Handler: _SmartHTTP_InfoRefsUploadPack_Handler, + Handler: _SmartHTTPService_InfoRefsUploadPack_Handler, ServerStreams: true, }, { StreamName: "InfoRefsReceivePack", - Handler: _SmartHTTP_InfoRefsReceivePack_Handler, + Handler: _SmartHTTPService_InfoRefsReceivePack_Handler, ServerStreams: true, }, { StreamName: "PostUploadPack", - Handler: _SmartHTTP_PostUploadPack_Handler, + Handler: _SmartHTTPService_PostUploadPack_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "PostReceivePack", - Handler: _SmartHTTP_PostReceivePack_Handler, + Handler: _SmartHTTPService_PostReceivePack_Handler, ServerStreams: true, ClientStreams: true, }, @@ -459,29 +459,29 @@ var _SmartHTTP_serviceDesc = grpc.ServiceDesc{ Metadata: "smarthttp.proto", } -func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor6) } +func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor7) } -var fileDescriptor6 = []byte{ - // 321 bytes of a gzipped FileDescriptorProto +var fileDescriptor7 = []byte{ + // 327 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x4b, 0xc3, 0x40, - 0x10, 0x75, 0x6b, 0x2d, 0x74, 0xac, 0x56, 0xa6, 0x68, 0x4b, 0x40, 0x2d, 0x11, 0xa4, 0x07, 0x0d, - 0x25, 0xfe, 0x06, 0xc1, 0xa2, 0x87, 0xb0, 0xb6, 0xe0, 0x2d, 0xac, 0xcd, 0x36, 0x0d, 0xae, 0xdd, - 0x98, 0x5d, 0x85, 0xfe, 0x15, 0xff, 0x98, 0x7f, 0x47, 0x4c, 0xc8, 0x47, 0x13, 0xe3, 0x41, 0xf1, - 0x16, 0xe6, 0xcd, 0xbc, 0xf7, 0x66, 0x5e, 0x16, 0xba, 0xea, 0x99, 0x45, 0x7a, 0xa9, 0x75, 0x68, - 0x85, 0x91, 0xd4, 0x12, 0x5b, 0x7e, 0xa0, 0x99, 0x58, 0x1b, 0x1d, 0xb5, 0x64, 0x11, 0xf7, 0x92, - 0xaa, 0x79, 0x0d, 0xdd, 0xc9, 0x6a, 0x21, 0x29, 0x5f, 0x28, 0xca, 0x5f, 0x5e, 0xb9, 0xd2, 0x68, - 0x03, 0x44, 0x3c, 0x94, 0x2a, 0xd0, 0x32, 0x5a, 0x0f, 0xc8, 0x90, 0x8c, 0x76, 0x6d, 0xb4, 0x92, - 0x69, 0x8b, 0x66, 0x08, 0x2d, 0x74, 0x99, 0xe7, 0x70, 0x90, 0xd3, 0xa8, 0x50, 0xae, 0x14, 0x47, - 0x84, 0xa6, 0xc7, 0x34, 0x8b, 0x19, 0x3a, 0x34, 0xfe, 0x36, 0x5d, 0x38, 0x74, 0xa4, 0xd2, 0xb3, - 0x50, 0x48, 0xe6, 0x39, 0x6c, 0xfe, 0xf4, 0x07, 0xd1, 0x4c, 0xa0, 0x51, 0x10, 0xb8, 0x80, 0xa3, - 0xb2, 0xc0, 0x0f, 0x76, 0xde, 0x49, 0xd2, 0x4e, 0xf9, 0x9c, 0x07, 0x6f, 0xfc, 0x1f, 0x0c, 0x61, - 0x0f, 0x76, 0x7c, 0xe1, 0x06, 0xde, 0x60, 0x7b, 0x48, 0x46, 0x6d, 0xda, 0xf4, 0xc5, 0xc4, 0xc3, - 0x33, 0xd8, 0xf3, 0x85, 0x5b, 0xe0, 0x6f, 0xc6, 0x60, 0xc7, 0x17, 0x39, 0xb3, 0x79, 0x09, 0xfd, - 0x8a, 0xb7, 0xfa, 0x5d, 0xec, 0x8f, 0x06, 0xb4, 0xef, 0xbf, 0x32, 0xbf, 0x99, 0x4e, 0x1d, 0xbc, - 0x05, 0x4c, 0x03, 0xc9, 0x6f, 0x81, 0xfd, 0x74, 0x81, 0x52, 0xe6, 0xc6, 0xa0, 0x0a, 0x24, 0x52, - 0xe6, 0xd6, 0x98, 0xe0, 0x1d, 0xf4, 0xf2, 0x7a, 0xe6, 0xe6, 0xb7, 0x6c, 0x33, 0xd8, 0xdf, 0x8c, - 0x08, 0x8f, 0xd3, 0xfe, 0x6f, 0xff, 0x0d, 0xe3, 0xa4, 0x0e, 0x4e, 0x49, 0x47, 0x64, 0x4c, 0xf0, - 0x01, 0xba, 0xa5, 0x73, 0xe1, 0xc6, 0x60, 0x35, 0x63, 0xe3, 0xb4, 0x16, 0x2f, 0x32, 0x3f, 0xb6, - 0xe2, 0xa7, 0x72, 0xf5, 0x19, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x33, 0x8a, 0x1a, 0x53, 0x03, 0x00, - 0x00, + 0x10, 0x75, 0x6b, 0x2d, 0x38, 0x56, 0x5b, 0xa6, 0x68, 0x4b, 0x40, 0x2d, 0x11, 0xa4, 0x07, 0x2d, + 0xa5, 0xfe, 0x06, 0xc1, 0xa2, 0x87, 0xb2, 0x6d, 0xc1, 0x5b, 0x59, 0x93, 0x6d, 0x1a, 0x5c, 0xbb, + 0x71, 0x77, 0x2d, 0xf4, 0xaf, 0xf8, 0xe3, 0xfc, 0x2d, 0x62, 0x42, 0x3e, 0x9a, 0x18, 0x0f, 0x8a, + 0xb7, 0x30, 0x6f, 0xe6, 0xbd, 0x37, 0xf3, 0xb2, 0xd0, 0xd0, 0x2f, 0x4c, 0x99, 0xa5, 0x31, 0x41, + 0x3f, 0x50, 0xd2, 0x48, 0xac, 0x79, 0xbe, 0x61, 0x62, 0x63, 0xd5, 0xf5, 0x92, 0x29, 0xee, 0x46, + 0x55, 0xfb, 0x16, 0x1a, 0xa3, 0xd5, 0x42, 0x52, 0xbe, 0xd0, 0x94, 0xbf, 0xbe, 0x71, 0x6d, 0x70, + 0x08, 0xa0, 0x78, 0x20, 0xb5, 0x6f, 0xa4, 0xda, 0x74, 0x48, 0x97, 0xf4, 0x0e, 0x86, 0xd8, 0x8f, + 0xa6, 0xfb, 0x34, 0x41, 0x68, 0xa6, 0xcb, 0xbe, 0x84, 0x66, 0x4a, 0xa3, 0x03, 0xb9, 0xd2, 0x1c, + 0x11, 0xaa, 0x2e, 0x33, 0x2c, 0x64, 0xa8, 0xd3, 0xf0, 0xdb, 0x9e, 0xc3, 0xf1, 0x58, 0x6a, 0x33, + 0x0b, 0x84, 0x64, 0xee, 0x98, 0x39, 0xcf, 0x7f, 0x10, 0x4d, 0x04, 0x2a, 0x19, 0x81, 0x2b, 0x38, + 0xc9, 0x0b, 0xfc, 0x60, 0xe7, 0x9d, 0x44, 0xed, 0x94, 0x3b, 0xdc, 0x5f, 0xf3, 0x7f, 0x30, 0x84, + 0x2d, 0xd8, 0xf3, 0xc4, 0xdc, 0x77, 0x3b, 0xbb, 0x5d, 0xd2, 0xdb, 0xa7, 0x55, 0x4f, 0x8c, 0x5c, + 0xbc, 0x80, 0x43, 0x4f, 0xcc, 0x33, 0xfc, 0xd5, 0x10, 0xac, 0x7b, 0x22, 0x65, 0xb6, 0xaf, 0xa1, + 0x5d, 0xf0, 0x56, 0xbe, 0xcb, 0xf0, 0xa3, 0x02, 0xcd, 0xc9, 0x57, 0xe6, 0x77, 0xd3, 0xe9, 0x78, + 0xc2, 0xd5, 0xda, 0x77, 0x38, 0xde, 0x03, 0xc6, 0xb9, 0xa4, 0x27, 0xc1, 0x76, 0xbc, 0x47, 0x2e, + 0x7a, 0xab, 0x53, 0x04, 0x22, 0x45, 0x7b, 0x67, 0x40, 0xf0, 0x01, 0x5a, 0x69, 0x3d, 0x31, 0xf5, + 0x5b, 0xb6, 0x19, 0x1c, 0x6d, 0x27, 0x85, 0xa7, 0x71, 0xff, 0xb7, 0xbf, 0x88, 0x75, 0x56, 0x06, + 0xc7, 0xa4, 0x3d, 0x32, 0x20, 0xf8, 0x08, 0x8d, 0xdc, 0xd5, 0x70, 0x6b, 0xb0, 0x18, 0xb5, 0x75, + 0x5e, 0x8a, 0x67, 0x99, 0x9f, 0x6a, 0xe1, 0x8b, 0xb9, 0xf9, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xbe, + 0x10, 0x08, 0x81, 0x5a, 0x03, 0x00, 0x00, } diff --git a/go/ssh.pb.go b/go/ssh.pb.go index ae6a9509ae6c5afd1eb83ebb9e52181093136b2c..453786795a95eb9af3d4d52602fb6d9632b09840 100644 --- a/go/ssh.pb.go +++ b/go/ssh.pb.go @@ -27,7 +27,7 @@ type SSHUploadPackRequest struct { func (m *SSHUploadPackRequest) Reset() { *m = SSHUploadPackRequest{} } func (m *SSHUploadPackRequest) String() string { return proto.CompactTextString(m) } func (*SSHUploadPackRequest) ProtoMessage() {} -func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} } +func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} } func (m *SSHUploadPackRequest) GetRepository() *Repository { if m != nil { @@ -56,7 +56,7 @@ type SSHUploadPackResponse struct { func (m *SSHUploadPackResponse) Reset() { *m = SSHUploadPackResponse{} } func (m *SSHUploadPackResponse) String() string { return proto.CompactTextString(m) } func (*SSHUploadPackResponse) ProtoMessage() {} -func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} } +func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} } func (m *SSHUploadPackResponse) GetStdout() []byte { if m != nil { @@ -93,7 +93,7 @@ type SSHReceivePackRequest struct { func (m *SSHReceivePackRequest) Reset() { *m = SSHReceivePackRequest{} } func (m *SSHReceivePackRequest) String() string { return proto.CompactTextString(m) } func (*SSHReceivePackRequest) ProtoMessage() {} -func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} } +func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} } func (m *SSHReceivePackRequest) GetRepository() *Repository { if m != nil { @@ -136,7 +136,7 @@ type SSHReceivePackResponse struct { func (m *SSHReceivePackResponse) Reset() { *m = SSHReceivePackResponse{} } func (m *SSHReceivePackResponse) String() string { return proto.CompactTextString(m) } func (*SSHReceivePackResponse) ProtoMessage() {} -func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} } +func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} } func (m *SSHReceivePackResponse) GetStdout() []byte { if m != nil { @@ -174,47 +174,47 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for SSH service +// Client API for SSHService service -type SSHClient interface { +type SSHServiceClient interface { // To forward 'git upload-pack' to Gitaly for SSH sessions - SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) + SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error) // To forward 'git receive-pack' to Gitaly for SSH sessions - SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) + SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error) } -type sSHClient struct { +type sSHServiceClient struct { cc *grpc.ClientConn } -func NewSSHClient(cc *grpc.ClientConn) SSHClient { - return &sSHClient{cc} +func NewSSHServiceClient(cc *grpc.ClientConn) SSHServiceClient { + return &sSHServiceClient{cc} } -func (c *sSHClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) { - stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[0], c.cc, "/gitaly.SSH/SSHUploadPack", opts...) +func (c *sSHServiceClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[0], c.cc, "/gitaly.SSHService/SSHUploadPack", opts...) if err != nil { return nil, err } - x := &sSHSSHUploadPackClient{stream} + x := &sSHServiceSSHUploadPackClient{stream} return x, nil } -type SSH_SSHUploadPackClient interface { +type SSHService_SSHUploadPackClient interface { Send(*SSHUploadPackRequest) error Recv() (*SSHUploadPackResponse, error) grpc.ClientStream } -type sSHSSHUploadPackClient struct { +type sSHServiceSSHUploadPackClient struct { grpc.ClientStream } -func (x *sSHSSHUploadPackClient) Send(m *SSHUploadPackRequest) error { +func (x *sSHServiceSSHUploadPackClient) Send(m *SSHUploadPackRequest) error { return x.ClientStream.SendMsg(m) } -func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) { +func (x *sSHServiceSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) { m := new(SSHUploadPackResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -222,30 +222,30 @@ func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) { return m, nil } -func (c *sSHClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) { - stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[1], c.cc, "/gitaly.SSH/SSHReceivePack", opts...) +func (c *sSHServiceClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error) { + stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[1], c.cc, "/gitaly.SSHService/SSHReceivePack", opts...) if err != nil { return nil, err } - x := &sSHSSHReceivePackClient{stream} + x := &sSHServiceSSHReceivePackClient{stream} return x, nil } -type SSH_SSHReceivePackClient interface { +type SSHService_SSHReceivePackClient interface { Send(*SSHReceivePackRequest) error Recv() (*SSHReceivePackResponse, error) grpc.ClientStream } -type sSHSSHReceivePackClient struct { +type sSHServiceSSHReceivePackClient struct { grpc.ClientStream } -func (x *sSHSSHReceivePackClient) Send(m *SSHReceivePackRequest) error { +func (x *sSHServiceSSHReceivePackClient) Send(m *SSHReceivePackRequest) error { return x.ClientStream.SendMsg(m) } -func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) { +func (x *sSHServiceSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) { m := new(SSHReceivePackResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err @@ -253,38 +253,38 @@ func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) { return m, nil } -// Server API for SSH service +// Server API for SSHService service -type SSHServer interface { +type SSHServiceServer interface { // To forward 'git upload-pack' to Gitaly for SSH sessions - SSHUploadPack(SSH_SSHUploadPackServer) error + SSHUploadPack(SSHService_SSHUploadPackServer) error // To forward 'git receive-pack' to Gitaly for SSH sessions - SSHReceivePack(SSH_SSHReceivePackServer) error + SSHReceivePack(SSHService_SSHReceivePackServer) error } -func RegisterSSHServer(s *grpc.Server, srv SSHServer) { - s.RegisterService(&_SSH_serviceDesc, srv) +func RegisterSSHServiceServer(s *grpc.Server, srv SSHServiceServer) { + s.RegisterService(&_SSHService_serviceDesc, srv) } -func _SSH_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(SSHServer).SSHUploadPack(&sSHSSHUploadPackServer{stream}) +func _SSHService_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SSHServiceServer).SSHUploadPack(&sSHServiceSSHUploadPackServer{stream}) } -type SSH_SSHUploadPackServer interface { +type SSHService_SSHUploadPackServer interface { Send(*SSHUploadPackResponse) error Recv() (*SSHUploadPackRequest, error) grpc.ServerStream } -type sSHSSHUploadPackServer struct { +type sSHServiceSSHUploadPackServer struct { grpc.ServerStream } -func (x *sSHSSHUploadPackServer) Send(m *SSHUploadPackResponse) error { +func (x *sSHServiceSSHUploadPackServer) Send(m *SSHUploadPackResponse) error { return x.ServerStream.SendMsg(m) } -func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) { +func (x *sSHServiceSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) { m := new(SSHUploadPackRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err @@ -292,25 +292,25 @@ func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) { return m, nil } -func _SSH_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(SSHServer).SSHReceivePack(&sSHSSHReceivePackServer{stream}) +func _SSHService_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SSHServiceServer).SSHReceivePack(&sSHServiceSSHReceivePackServer{stream}) } -type SSH_SSHReceivePackServer interface { +type SSHService_SSHReceivePackServer interface { Send(*SSHReceivePackResponse) error Recv() (*SSHReceivePackRequest, error) grpc.ServerStream } -type sSHSSHReceivePackServer struct { +type sSHServiceSSHReceivePackServer struct { grpc.ServerStream } -func (x *sSHSSHReceivePackServer) Send(m *SSHReceivePackResponse) error { +func (x *sSHServiceSSHReceivePackServer) Send(m *SSHReceivePackResponse) error { return x.ServerStream.SendMsg(m) } -func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) { +func (x *sSHServiceSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) { m := new(SSHReceivePackRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err @@ -318,20 +318,20 @@ func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) { return m, nil } -var _SSH_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gitaly.SSH", - HandlerType: (*SSHServer)(nil), +var _SSHService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.SSHService", + HandlerType: (*SSHServiceServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "SSHUploadPack", - Handler: _SSH_SSHUploadPack_Handler, + Handler: _SSHService_SSHUploadPack_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "SSHReceivePack", - Handler: _SSH_SSHReceivePack_Handler, + Handler: _SSHService_SSHReceivePack_Handler, ServerStreams: true, ClientStreams: true, }, @@ -339,27 +339,28 @@ var _SSH_serviceDesc = grpc.ServiceDesc{ Metadata: "ssh.proto", } -func init() { proto.RegisterFile("ssh.proto", fileDescriptor7) } - -var fileDescriptor7 = []byte{ - // 304 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4e, 0xf3, 0x30, - 0x10, 0xfc, 0xfc, 0xf5, 0x47, 0xea, 0x36, 0xe5, 0xb0, 0x94, 0xaa, 0x8a, 0x00, 0x55, 0xe1, 0x92, - 0x53, 0x84, 0xd2, 0x67, 0x40, 0x2a, 0x37, 0xe4, 0xa8, 0xe7, 0x10, 0x6a, 0x2b, 0xb5, 0xb0, 0xea, - 0x60, 0x3b, 0xa8, 0x95, 0xe0, 0x49, 0x78, 0x09, 0x1e, 0x11, 0xc9, 0x09, 0x25, 0x29, 0xf4, 0x08, - 0xb7, 0xcc, 0x4e, 0x76, 0x66, 0xd6, 0xbb, 0x30, 0x30, 0x66, 0x1d, 0x15, 0x5a, 0x59, 0x85, 0xfd, - 0x5c, 0xd8, 0x4c, 0xee, 0x7c, 0xcf, 0xac, 0x33, 0xcd, 0x59, 0x55, 0x0d, 0xee, 0x61, 0x9c, 0x24, - 0x8b, 0x65, 0x21, 0x55, 0xc6, 0xee, 0xb2, 0xd5, 0x23, 0xe5, 0x4f, 0x25, 0x37, 0x16, 0x63, 0x00, - 0xcd, 0x0b, 0x65, 0x84, 0x55, 0x7a, 0x37, 0x25, 0x33, 0x12, 0x0e, 0x63, 0x8c, 0x2a, 0x89, 0x88, - 0xee, 0x19, 0xda, 0xf8, 0x0b, 0xc7, 0xd0, 0x33, 0x96, 0x89, 0xcd, 0xf4, 0xff, 0x8c, 0x84, 0x1e, - 0xad, 0x40, 0xf0, 0x02, 0x67, 0x07, 0x0e, 0xa6, 0x50, 0x1b, 0xc3, 0x71, 0x02, 0x7d, 0x63, 0x99, - 0x2a, 0xad, 0x93, 0xf7, 0x68, 0x8d, 0xea, 0x3a, 0xd7, 0xba, 0xd6, 0xa9, 0x11, 0xce, 0x61, 0xc8, - 0xb7, 0xc2, 0xa6, 0xc6, 0x66, 0xb6, 0x34, 0xd3, 0x4e, 0x3b, 0xd3, 0xcd, 0x56, 0xd8, 0xc4, 0x31, - 0x14, 0xf8, 0xfe, 0x3b, 0x78, 0x23, 0xce, 0x9e, 0xf2, 0x15, 0x17, 0xcf, 0xfc, 0x57, 0x26, 0xc4, - 0x53, 0xe8, 0xe5, 0x32, 0x15, 0xcc, 0x45, 0x1a, 0xd0, 0x6e, 0x2e, 0x6f, 0x19, 0x5e, 0xc1, 0x28, - 0x97, 0x69, 0xc3, 0xa1, 0xeb, 0x48, 0x2f, 0x97, 0x5f, 0xda, 0xc1, 0x2b, 0x4c, 0x0e, 0xc3, 0xfd, - 0xe1, 0xe3, 0xc4, 0xef, 0x04, 0x3a, 0x49, 0xb2, 0x40, 0x0a, 0xa3, 0xd6, 0x8a, 0xf0, 0xfc, 0xb3, - 0xf1, 0xa7, 0xdb, 0xf0, 0x2f, 0x8e, 0xb0, 0x55, 0xf4, 0xe0, 0x5f, 0x48, 0xae, 0x09, 0x2e, 0xe1, - 0xa4, 0x3d, 0x1a, 0x36, 0xdb, 0xbe, 0xef, 0xc3, 0xbf, 0x3c, 0x46, 0x37, 0x65, 0x1f, 0xfa, 0xee, - 0x6c, 0xe7, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x3d, 0xb9, 0xce, 0xd9, 0x02, 0x00, 0x00, +func init() { proto.RegisterFile("ssh.proto", fileDescriptor8) } + +var fileDescriptor8 = []byte{ + // 307 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcf, 0x4e, 0x32, 0x31, + 0x10, 0xff, 0xfa, 0x09, 0x24, 0x0c, 0x8b, 0x87, 0x11, 0x09, 0x21, 0x6a, 0xc8, 0x7a, 0xe1, 0x44, + 0x0c, 0x3c, 0x83, 0x09, 0xde, 0x4c, 0x1b, 0xce, 0xb8, 0xd2, 0xc9, 0xd2, 0xd8, 0xd0, 0xb5, 0x2d, + 0x04, 0x12, 0x7d, 0x12, 0x1f, 0xc4, 0xd7, 0x33, 0xe9, 0xae, 0xb8, 0x8b, 0x72, 0xd4, 0xdb, 0xce, + 0xfc, 0x76, 0x7e, 0x7f, 0x3a, 0x03, 0x4d, 0xe7, 0x96, 0xa3, 0xcc, 0x1a, 0x6f, 0xb0, 0x91, 0x2a, + 0x9f, 0xe8, 0x5d, 0x3f, 0x72, 0xcb, 0xc4, 0x92, 0xcc, 0xbb, 0xf1, 0x03, 0x74, 0x84, 0x98, 0xce, + 0x32, 0x6d, 0x12, 0x79, 0x9f, 0x2c, 0x9e, 0x38, 0x3d, 0xaf, 0xc9, 0x79, 0x1c, 0x03, 0x58, 0xca, + 0x8c, 0x53, 0xde, 0xd8, 0x5d, 0x8f, 0x0d, 0xd8, 0xb0, 0x35, 0xc6, 0x51, 0x4e, 0x31, 0xe2, 0x7b, + 0x84, 0x97, 0xfe, 0xc2, 0x0e, 0xd4, 0x9d, 0x97, 0x6a, 0xd5, 0xfb, 0x3f, 0x60, 0xc3, 0x88, 0xe7, + 0x45, 0xfc, 0x02, 0xe7, 0x07, 0x0a, 0x2e, 0x33, 0x2b, 0x47, 0xd8, 0x85, 0x86, 0xf3, 0xd2, 0xac, + 0x7d, 0xa0, 0x8f, 0x78, 0x51, 0x15, 0x7d, 0xb2, 0xb6, 0xe0, 0x29, 0x2a, 0x9c, 0x40, 0x8b, 0xb6, + 0xca, 0xcf, 0x9d, 0x4f, 0xfc, 0xda, 0xf5, 0x4e, 0xaa, 0x9e, 0x6e, 0xb7, 0xca, 0x8b, 0x80, 0x70, + 0xa0, 0xfd, 0x77, 0xfc, 0xc6, 0x82, 0x3c, 0xa7, 0x05, 0xa9, 0x0d, 0xfd, 0x4a, 0x42, 0x3c, 0x83, + 0x7a, 0xaa, 0xe7, 0x4a, 0x06, 0x4b, 0x4d, 0x5e, 0x4b, 0xf5, 0x9d, 0xc4, 0x6b, 0x68, 0xa7, 0x7a, + 0x5e, 0x52, 0xa8, 0x05, 0x30, 0x4a, 0xf5, 0x17, 0x77, 0xfc, 0x0a, 0xdd, 0x43, 0x73, 0x7f, 0xf8, + 0x38, 0xe3, 0x77, 0x06, 0x20, 0xc4, 0x54, 0x90, 0xdd, 0xa8, 0x05, 0x21, 0x87, 0x76, 0x65, 0x53, + 0x78, 0xf1, 0x39, 0xff, 0xd3, 0x89, 0xf4, 0x2f, 0x8f, 0xa0, 0x79, 0x82, 0xf8, 0xdf, 0x90, 0xdd, + 0x30, 0x9c, 0xc1, 0x69, 0x35, 0x21, 0x96, 0xc7, 0xbe, 0xaf, 0xa5, 0x7f, 0x75, 0x0c, 0x2e, 0xd3, + 0x3e, 0x36, 0xc2, 0xf5, 0x4e, 0x3e, 0x02, 0x00, 0x00, 0xff, 0xff, 0x79, 0x5b, 0x32, 0x2b, 0xe0, + 0x02, 0x00, 0x00, } diff --git a/notifications.proto b/notifications.proto index cdc59eef3deedd9562e209171caecf8fdda73943..57bc3b1230e2f272c152b48a3c421c64f0d7ad71 100644 --- a/notifications.proto +++ b/notifications.proto @@ -4,7 +4,7 @@ package gitaly; import "shared.proto"; -service Notifications { +service NotificationService { rpc PostReceive(PostReceiveRequest) returns (PostReceiveResponse) {} } diff --git a/ref.proto b/ref.proto index d8cc63fc2560e4785ff8a2a27bf9624f5b91cf38..92311964c31b9a7eec67d01bfd686c4bbd601545 100644 --- a/ref.proto +++ b/ref.proto @@ -5,7 +5,7 @@ package gitaly; import "shared.proto"; import "google/protobuf/timestamp.proto"; -service Ref { +service RefService { rpc FindDefaultBranchName(FindDefaultBranchNameRequest) returns (FindDefaultBranchNameResponse) {} rpc FindAllBranchNames(FindAllBranchNamesRequest) returns (stream FindAllBranchNamesResponse) {} rpc FindAllTagNames(FindAllTagNamesRequest) returns (stream FindAllTagNamesResponse) {} diff --git a/ruby/lib/gitaly.rb b/ruby/lib/gitaly.rb index 9c90bd7651101637ed0734cd84ae0f9dc52f4a00..e1e5303e2fc2c2d9e5ff586c8aeb683b1a51dd39 100644 --- a/ruby/lib/gitaly.rb +++ b/ruby/lib/gitaly.rb @@ -5,6 +5,8 @@ require 'gitaly/version' require 'gitaly/commit_services_pb' +require 'gitaly/deprecated-services_services_pb' + require 'gitaly/diff_services_pb' require 'gitaly/notifications_services_pb' diff --git a/ruby/lib/gitaly/commit_services_pb.rb b/ruby/lib/gitaly/commit_services_pb.rb index 51331e28c17e8bafdc3470d20f9ef864fd69619f..f04b406c0bba055fec9288716f0a178cdd64dff7 100644 --- a/ruby/lib/gitaly/commit_services_pb.rb +++ b/ruby/lib/gitaly/commit_services_pb.rb @@ -5,14 +5,14 @@ require 'grpc' require 'commit_pb' module Gitaly - module Commit + module CommitService class Service include GRPC::GenericService self.marshal_class_method = :encode self.unmarshal_class_method = :decode - self.service_name = 'gitaly.Commit' + self.service_name = 'gitaly.CommitService' rpc :CommitIsAncestor, CommitIsAncestorRequest, CommitIsAncestorResponse rpc :TreeEntry, TreeEntryRequest, stream(TreeEntryResponse) diff --git a/ruby/lib/gitaly/deprecated-services_pb.rb b/ruby/lib/gitaly/deprecated-services_pb.rb new file mode 100644 index 0000000000000000000000000000000000000000..a823f75f66654ab9d25cf4a5d57fe5921a748134 --- /dev/null +++ b/ruby/lib/gitaly/deprecated-services_pb.rb @@ -0,0 +1,16 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: deprecated-services.proto + +require 'google/protobuf' + +require 'commit_pb' +require 'diff_pb' +require 'notifications_pb' +require 'ref_pb' +require 'smarthttp_pb' +require 'ssh_pb' +Google::Protobuf::DescriptorPool.generated_pool.build do +end + +module Gitaly +end diff --git a/ruby/lib/gitaly/deprecated-services_services_pb.rb b/ruby/lib/gitaly/deprecated-services_services_pb.rb new file mode 100644 index 0000000000000000000000000000000000000000..987e4b2a776d900c3fb8376806c119e0709f42ca --- /dev/null +++ b/ruby/lib/gitaly/deprecated-services_services_pb.rb @@ -0,0 +1,120 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# Source: deprecated-services.proto for package 'gitaly' + +require 'grpc' +require 'deprecated-services_pb' + +module Gitaly + module Commit + # TODO: remove all these legacy RPC interfaces when client references to them are removed. + # + # Deprecated + class Service + + include GRPC::GenericService + + self.marshal_class_method = :encode + self.unmarshal_class_method = :decode + self.service_name = 'gitaly.Commit' + + rpc :CommitIsAncestor, CommitIsAncestorRequest, CommitIsAncestorResponse + rpc :TreeEntry, TreeEntryRequest, stream(TreeEntryResponse) + end + + Stub = Service.rpc_stub_class + end + module Diff + # Deprecated + class Service + + include GRPC::GenericService + + self.marshal_class_method = :encode + self.unmarshal_class_method = :decode + self.service_name = 'gitaly.Diff' + + # Returns stream of CommitDiffResponse with patches chunked over messages + rpc :CommitDiff, CommitDiffRequest, stream(CommitDiffResponse) + # Return a stream so we can divide the response in chunks of deltas + rpc :CommitDelta, CommitDeltaRequest, stream(CommitDeltaResponse) + end + + Stub = Service.rpc_stub_class + end + module Notifications + # Deprecated + class Service + + include GRPC::GenericService + + self.marshal_class_method = :encode + self.unmarshal_class_method = :decode + self.service_name = 'gitaly.Notifications' + + rpc :PostReceive, PostReceiveRequest, PostReceiveResponse + end + + Stub = Service.rpc_stub_class + end + module Ref + # Deprecated + class Service + + include GRPC::GenericService + + self.marshal_class_method = :encode + self.unmarshal_class_method = :decode + self.service_name = 'gitaly.Ref' + + rpc :FindDefaultBranchName, FindDefaultBranchNameRequest, FindDefaultBranchNameResponse + rpc :FindAllBranchNames, FindAllBranchNamesRequest, stream(FindAllBranchNamesResponse) + rpc :FindAllTagNames, FindAllTagNamesRequest, stream(FindAllTagNamesResponse) + # Find a Ref matching the given constraints. Response may be empty. + rpc :FindRefName, FindRefNameRequest, FindRefNameResponse + # Return a stream so we can divide the response in chunks of branches + rpc :FindLocalBranches, FindLocalBranchesRequest, stream(FindLocalBranchesResponse) + end + + Stub = Service.rpc_stub_class + end + module SmartHTTP + # DEPRECATED + class Service + + include GRPC::GenericService + + self.marshal_class_method = :encode + self.unmarshal_class_method = :decode + self.service_name = 'gitaly.SmartHTTP' + + # The response body for GET /info/refs?service=git-upload-pack + rpc :InfoRefsUploadPack, InfoRefsRequest, stream(InfoRefsResponse) + # The response body for GET /info/refs?service=git-receive-pack + rpc :InfoRefsReceivePack, InfoRefsRequest, stream(InfoRefsResponse) + # Request and response body for POST /upload-pack + rpc :PostUploadPack, stream(PostUploadPackRequest), stream(PostUploadPackResponse) + # Request and response body for POST /receive-pack + rpc :PostReceivePack, stream(PostReceivePackRequest), stream(PostReceivePackResponse) + end + + Stub = Service.rpc_stub_class + end + module SSH + # DEPRECATED + class Service + + include GRPC::GenericService + + self.marshal_class_method = :encode + self.unmarshal_class_method = :decode + self.service_name = 'gitaly.SSH' + + # To forward 'git upload-pack' to Gitaly for SSH sessions + rpc :SSHUploadPack, stream(SSHUploadPackRequest), stream(SSHUploadPackResponse) + # To forward 'git receive-pack' to Gitaly for SSH sessions + rpc :SSHReceivePack, stream(SSHReceivePackRequest), stream(SSHReceivePackResponse) + end + + Stub = Service.rpc_stub_class + end +end diff --git a/ruby/lib/gitaly/diff_services_pb.rb b/ruby/lib/gitaly/diff_services_pb.rb index a60fb50dfb1b0af942045e4ab9579ac44fc6e86c..2aa585da9a0945356c62634360188965d58b911c 100644 --- a/ruby/lib/gitaly/diff_services_pb.rb +++ b/ruby/lib/gitaly/diff_services_pb.rb @@ -5,14 +5,14 @@ require 'grpc' require 'diff_pb' module Gitaly - module Diff + module DiffService class Service include GRPC::GenericService self.marshal_class_method = :encode self.unmarshal_class_method = :decode - self.service_name = 'gitaly.Diff' + self.service_name = 'gitaly.DiffService' # Returns stream of CommitDiffResponse with patches chunked over messages rpc :CommitDiff, CommitDiffRequest, stream(CommitDiffResponse) diff --git a/ruby/lib/gitaly/notifications_services_pb.rb b/ruby/lib/gitaly/notifications_services_pb.rb index 1c0dd287ee35cdf372b4ab7ba6ef90ec4c616ac1..4acae834d95b7dba742a3428736f936c0ba7e578 100644 --- a/ruby/lib/gitaly/notifications_services_pb.rb +++ b/ruby/lib/gitaly/notifications_services_pb.rb @@ -5,14 +5,14 @@ require 'grpc' require 'notifications_pb' module Gitaly - module Notifications + module NotificationService class Service include GRPC::GenericService self.marshal_class_method = :encode self.unmarshal_class_method = :decode - self.service_name = 'gitaly.Notifications' + self.service_name = 'gitaly.NotificationService' rpc :PostReceive, PostReceiveRequest, PostReceiveResponse end diff --git a/ruby/lib/gitaly/ref_services_pb.rb b/ruby/lib/gitaly/ref_services_pb.rb index 34e3cba6b5c4cf958f30622b6826c859d799e33f..f013dd8f32b0b0e257009319a2a4cabd1f5d3076 100644 --- a/ruby/lib/gitaly/ref_services_pb.rb +++ b/ruby/lib/gitaly/ref_services_pb.rb @@ -5,14 +5,14 @@ require 'grpc' require 'ref_pb' module Gitaly - module Ref + module RefService class Service include GRPC::GenericService self.marshal_class_method = :encode self.unmarshal_class_method = :decode - self.service_name = 'gitaly.Ref' + self.service_name = 'gitaly.RefService' rpc :FindDefaultBranchName, FindDefaultBranchNameRequest, FindDefaultBranchNameResponse rpc :FindAllBranchNames, FindAllBranchNamesRequest, stream(FindAllBranchNamesResponse) diff --git a/ruby/lib/gitaly/smarthttp_services_pb.rb b/ruby/lib/gitaly/smarthttp_services_pb.rb index cfdc7ab7d73f82dfe9bf9c6616c465bdafe4523f..2d65c93abec75cacbd19f05df9ebcc71ba844e41 100644 --- a/ruby/lib/gitaly/smarthttp_services_pb.rb +++ b/ruby/lib/gitaly/smarthttp_services_pb.rb @@ -5,14 +5,14 @@ require 'grpc' require 'smarthttp_pb' module Gitaly - module SmartHTTP + module SmartHTTPService class Service include GRPC::GenericService self.marshal_class_method = :encode self.unmarshal_class_method = :decode - self.service_name = 'gitaly.SmartHTTP' + self.service_name = 'gitaly.SmartHTTPService' # The response body for GET /info/refs?service=git-upload-pack rpc :InfoRefsUploadPack, InfoRefsRequest, stream(InfoRefsResponse) diff --git a/ruby/lib/gitaly/ssh_services_pb.rb b/ruby/lib/gitaly/ssh_services_pb.rb index 70c078934da7990ed99f149b0c7aa7f3273dca69..4ebb9611aa54f373831778d95f546c40e3b99189 100644 --- a/ruby/lib/gitaly/ssh_services_pb.rb +++ b/ruby/lib/gitaly/ssh_services_pb.rb @@ -5,14 +5,14 @@ require 'grpc' require 'ssh_pb' module Gitaly - module SSH + module SSHService class Service include GRPC::GenericService self.marshal_class_method = :encode self.unmarshal_class_method = :decode - self.service_name = 'gitaly.SSH' + self.service_name = 'gitaly.SSHService' # To forward 'git upload-pack' to Gitaly for SSH sessions rpc :SSHUploadPack, stream(SSHUploadPackRequest), stream(SSHUploadPackResponse) diff --git a/smarthttp.proto b/smarthttp.proto index 286566b23f5175aaf93be9d1f6fe0ce33e982a70..503fff5981d3201b7b3eac995455debb6da75f64 100644 --- a/smarthttp.proto +++ b/smarthttp.proto @@ -4,7 +4,7 @@ package gitaly; import "shared.proto"; -service SmartHTTP { +service SmartHTTPService { // The response body for GET /info/refs?service=git-upload-pack rpc InfoRefsUploadPack(InfoRefsRequest) returns (stream InfoRefsResponse) {} diff --git a/ssh.proto b/ssh.proto index 91cb0b69e00a35b089dff574b60fe0cd619a293e..4a31e01fbf0603d9c8739d9bc6f0f84ed9cc1380 100644 --- a/ssh.proto +++ b/ssh.proto @@ -4,7 +4,7 @@ package gitaly; import "shared.proto"; -service SSH { +service SSHService { // To forward 'git upload-pack' to Gitaly for SSH sessions rpc SSHUploadPack(stream SSHUploadPackRequest) returns (stream SSHUploadPackResponse) {}