From 902eb30ff17714e82a25cde5fe470ea256f8b3e7 Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Wed, 21 Jun 2017 12:45:25 +0100 Subject: [PATCH 1/7] Renamed services --- internal/service/register.go | 12 +- internal/service/smarthttp/inforefs.go | 4 +- internal/service/smarthttp/receive_pack.go | 2 +- internal/service/smarthttp/rename_bridge.go | 28 ++ internal/service/smarthttp/server.go | 2 +- internal/service/smarthttp/upload_pack.go | 2 +- internal/service/ssh/receive_pack.go | 2 +- internal/service/ssh/rename_bridge.go | 20 ++ internal/service/ssh/server.go | 2 +- internal/service/ssh/uploadpack.go | 2 +- .../gitaly-proto/go/smarthttp.pb.go | 334 ++++++++++++++++-- .../gitlab-org/gitaly-proto/go/ssh.pb.go | 206 +++++++++-- 12 files changed, 564 insertions(+), 52 deletions(-) create mode 100644 internal/service/smarthttp/rename_bridge.go create mode 100644 internal/service/ssh/rename_bridge.go diff --git a/internal/service/register.go b/internal/service/register.go index a2c3b350af..ba7cc19383 100644 --- a/internal/service/register.go +++ b/internal/service/register.go @@ -19,9 +19,17 @@ import ( func RegisterAll(grpcServer *grpc.Server) { pb.RegisterNotificationsServer(grpcServer, notifications.NewServer()) pb.RegisterRefServer(grpcServer, ref.NewServer()) - pb.RegisterSmartHTTPServer(grpcServer, smarthttp.NewServer()) + + smartHTTPService := smarthttp.NewServer() + pb.RegisterSmartHTTPServiceServer(grpcServer, smartHTTPService) + pb.RegisterSmartHTTPServer(grpcServer, smarthttp.NewRenameBridge(smartHTTPService)) + pb.RegisterDiffServer(grpcServer, diff.NewServer()) pb.RegisterCommitServer(grpcServer, commit.NewServer()) - pb.RegisterSSHServer(grpcServer, ssh.NewServer()) + + sshService := ssh.NewServer() + pb.RegisterSSHServiceServer(grpcServer, sshService) + pb.RegisterSSHServer(grpcServer, ssh.NewRenameBridge(sshService)) + healthpb.RegisterHealthServer(grpcServer, health.NewServer()) } diff --git a/internal/service/smarthttp/inforefs.go b/internal/service/smarthttp/inforefs.go index 8eae55974f..870ab0cc34 100644 --- a/internal/service/smarthttp/inforefs.go +++ b/internal/service/smarthttp/inforefs.go @@ -13,14 +13,14 @@ import ( "google.golang.org/grpc/codes" ) -func (s *server) InfoRefsUploadPack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsUploadPackServer) error { +func (s *server) InfoRefsUploadPack(in *pb.InfoRefsRequest, stream pb.SmartHTTPService_InfoRefsUploadPackServer) error { w := pbhelper.NewSendWriter(func(p []byte) error { return stream.Send(&pb.InfoRefsResponse{Data: p}) }) return handleInfoRefs("upload-pack", in.Repository, w) } -func (s *server) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsReceivePackServer) error { +func (s *server) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb.SmartHTTPService_InfoRefsReceivePackServer) error { w := pbhelper.NewSendWriter(func(p []byte) error { return stream.Send(&pb.InfoRefsResponse{Data: p}) }) diff --git a/internal/service/smarthttp/receive_pack.go b/internal/service/smarthttp/receive_pack.go index 9251d8b885..4971665e66 100644 --- a/internal/service/smarthttp/receive_pack.go +++ b/internal/service/smarthttp/receive_pack.go @@ -13,7 +13,7 @@ import ( "google.golang.org/grpc/codes" ) -func (s *server) PostReceivePack(stream pb.SmartHTTP_PostReceivePackServer) error { +func (s *server) PostReceivePack(stream pb.SmartHTTPService_PostReceivePackServer) error { req, err := stream.Recv() // First request contains only Repository and GlId if err != nil { return err diff --git a/internal/service/smarthttp/rename_bridge.go b/internal/service/smarthttp/rename_bridge.go new file mode 100644 index 0000000000..eefae4d65c --- /dev/null +++ b/internal/service/smarthttp/rename_bridge.go @@ -0,0 +1,28 @@ +package smarthttp + +import pb "gitlab.com/gitlab-org/gitaly-proto/go" + +type bridge struct { + upstream pb.SmartHTTPServiceServer +} + +func (s *bridge) InfoRefsUploadPack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsUploadPackServer) error { + return s.upstream.InfoRefsReceivePack(in, stream) +} + +func (s *bridge) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsReceivePackServer) error { + return s.upstream.InfoRefsReceivePack(in, stream) +} + +func (s *bridge) PostUploadPack(stream pb.SmartHTTP_PostUploadPackServer) error { + return s.upstream.PostUploadPack(stream) +} + +func (s *bridge) PostReceivePack(stream pb.SmartHTTP_PostReceivePackServer) error { + return s.upstream.PostReceivePack(stream) +} + +// NewRenameBridge creates a bridge between SmartHTTPServiceServer and SmartHTTPServer +func NewRenameBridge(upstream pb.SmartHTTPServiceServer) pb.SmartHTTPServer { + return &bridge{upstream} +} diff --git a/internal/service/smarthttp/server.go b/internal/service/smarthttp/server.go index afbe12ac02..581cb21517 100644 --- a/internal/service/smarthttp/server.go +++ b/internal/service/smarthttp/server.go @@ -5,6 +5,6 @@ import pb "gitlab.com/gitlab-org/gitaly-proto/go" type server struct{} // NewServer creates a new instance of a grpc SmartHTTPServer -func NewServer() pb.SmartHTTPServer { +func NewServer() pb.SmartHTTPServiceServer { return &server{} } diff --git a/internal/service/smarthttp/upload_pack.go b/internal/service/smarthttp/upload_pack.go index fad83d14d0..bd397396c5 100644 --- a/internal/service/smarthttp/upload_pack.go +++ b/internal/service/smarthttp/upload_pack.go @@ -28,7 +28,7 @@ func init() { prometheus.MustRegister(deepenCount) } -func (s *server) PostUploadPack(stream pb.SmartHTTP_PostUploadPackServer) error { +func (s *server) PostUploadPack(stream pb.SmartHTTPService_PostUploadPackServer) error { req, err := stream.Recv() // First request contains Repository only if err != nil { return err diff --git a/internal/service/ssh/receive_pack.go b/internal/service/ssh/receive_pack.go index 5eadbc3cca..158564b814 100644 --- a/internal/service/ssh/receive_pack.go +++ b/internal/service/ssh/receive_pack.go @@ -13,7 +13,7 @@ import ( "google.golang.org/grpc/codes" ) -func (s *server) SSHReceivePack(stream pb.SSH_SSHReceivePackServer) error { +func (s *server) SSHReceivePack(stream pb.SSHService_SSHReceivePackServer) error { req, err := stream.Recv() // First request contains only Repository and GlId if err != nil { return err diff --git a/internal/service/ssh/rename_bridge.go b/internal/service/ssh/rename_bridge.go new file mode 100644 index 0000000000..d4f98649f0 --- /dev/null +++ b/internal/service/ssh/rename_bridge.go @@ -0,0 +1,20 @@ +package ssh + +import pb "gitlab.com/gitlab-org/gitaly-proto/go" + +type bridge struct { + upstream pb.SSHServiceServer +} + +func (s *bridge) SSHUploadPack(stream pb.SSH_SSHUploadPackServer) error { + return s.upstream.SSHUploadPack(stream) +} + +func (s *bridge) SSHReceivePack(stream pb.SSH_SSHReceivePackServer) error { + return s.upstream.SSHReceivePack(stream) +} + +// NewRenameBridge creates a bridge between SmartHTTPServiceServer and SmartHTTPServer +func NewRenameBridge(upstream pb.SSHServiceServer) pb.SSHServer { + return &bridge{upstream} +} diff --git a/internal/service/ssh/server.go b/internal/service/ssh/server.go index 5012f022f8..c423228a7d 100644 --- a/internal/service/ssh/server.go +++ b/internal/service/ssh/server.go @@ -5,6 +5,6 @@ import pb "gitlab.com/gitlab-org/gitaly-proto/go" type server struct{} // NewServer creates a new instance of a grpc SSHServer -func NewServer() pb.SSHServer { +func NewServer() pb.SSHServiceServer { return &server{} } diff --git a/internal/service/ssh/uploadpack.go b/internal/service/ssh/uploadpack.go index aecf251dda..d09d018c72 100644 --- a/internal/service/ssh/uploadpack.go +++ b/internal/service/ssh/uploadpack.go @@ -11,7 +11,7 @@ import ( "google.golang.org/grpc/codes" ) -func (s *server) SSHUploadPack(stream pb.SSH_SSHUploadPackServer) error { +func (s *server) SSHUploadPack(stream pb.SSHService_SSHUploadPackServer) error { req, err := stream.Recv() // First request contains Repository only if err != nil { return err diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go index 3024bf626e..692c81c7d1 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go @@ -459,29 +459,319 @@ var _SmartHTTP_serviceDesc = grpc.ServiceDesc{ Metadata: "smarthttp.proto", } +// Client API for SmartHTTPService service + +type SmartHTTPServiceClient interface { + // The response body for GET /info/refs?service=git-upload-pack + 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) (SmartHTTPService_InfoRefsReceivePackClient, error) + // Request and response body for POST /upload-pack + 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) (SmartHTTPService_PostReceivePackClient, error) +} + +type smartHTTPServiceClient struct { + cc *grpc.ClientConn +} + +func NewSmartHTTPServiceClient(cc *grpc.ClientConn) SmartHTTPServiceClient { + return &smartHTTPServiceClient{cc} +} + +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 := &smartHTTPServiceInfoRefsUploadPackClient{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 SmartHTTPService_InfoRefsUploadPackClient interface { + Recv() (*InfoRefsResponse, error) + grpc.ClientStream +} + +type smartHTTPServiceInfoRefsUploadPackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPServiceInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) { + m := new(InfoRefsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +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 := &smartHTTPServiceInfoRefsReceivePackClient{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 SmartHTTPService_InfoRefsReceivePackClient interface { + Recv() (*InfoRefsResponse, error) + grpc.ClientStream +} + +type smartHTTPServiceInfoRefsReceivePackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPServiceInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) { + m := new(InfoRefsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +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 := &smartHTTPServicePostUploadPackClient{stream} + return x, nil +} + +type SmartHTTPService_PostUploadPackClient interface { + Send(*PostUploadPackRequest) error + Recv() (*PostUploadPackResponse, error) + grpc.ClientStream +} + +type smartHTTPServicePostUploadPackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPServicePostUploadPackClient) Send(m *PostUploadPackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *smartHTTPServicePostUploadPackClient) Recv() (*PostUploadPackResponse, error) { + m := new(PostUploadPackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +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 := &smartHTTPServicePostReceivePackClient{stream} + return x, nil +} + +type SmartHTTPService_PostReceivePackClient interface { + Send(*PostReceivePackRequest) error + Recv() (*PostReceivePackResponse, error) + grpc.ClientStream +} + +type smartHTTPServicePostReceivePackClient struct { + grpc.ClientStream +} + +func (x *smartHTTPServicePostReceivePackClient) Send(m *PostReceivePackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *smartHTTPServicePostReceivePackClient) Recv() (*PostReceivePackResponse, error) { + m := new(PostReceivePackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for SmartHTTPService service + +type SmartHTTPServiceServer interface { + // The response body for GET /info/refs?service=git-upload-pack + InfoRefsUploadPack(*InfoRefsRequest, SmartHTTPService_InfoRefsUploadPackServer) error + // The response body for GET /info/refs?service=git-receive-pack + InfoRefsReceivePack(*InfoRefsRequest, SmartHTTPService_InfoRefsReceivePackServer) error + // Request and response body for POST /upload-pack + PostUploadPack(SmartHTTPService_PostUploadPackServer) error + // Request and response body for POST /receive-pack + PostReceivePack(SmartHTTPService_PostReceivePackServer) error +} + +func RegisterSmartHTTPServiceServer(s *grpc.Server, srv SmartHTTPServiceServer) { + s.RegisterService(&_SmartHTTPService_serviceDesc, srv) +} + +func _SmartHTTPService_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(InfoRefsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SmartHTTPServiceServer).InfoRefsUploadPack(m, &smartHTTPServiceInfoRefsUploadPackServer{stream}) +} + +type SmartHTTPService_InfoRefsUploadPackServer interface { + Send(*InfoRefsResponse) error + grpc.ServerStream +} + +type smartHTTPServiceInfoRefsUploadPackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPServiceInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _SmartHTTPService_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(InfoRefsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SmartHTTPServiceServer).InfoRefsReceivePack(m, &smartHTTPServiceInfoRefsReceivePackServer{stream}) +} + +type SmartHTTPService_InfoRefsReceivePackServer interface { + Send(*InfoRefsResponse) error + grpc.ServerStream +} + +type smartHTTPServiceInfoRefsReceivePackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPServiceInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _SmartHTTPService_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SmartHTTPServiceServer).PostUploadPack(&smartHTTPServicePostUploadPackServer{stream}) +} + +type SmartHTTPService_PostUploadPackServer interface { + Send(*PostUploadPackResponse) error + Recv() (*PostUploadPackRequest, error) + grpc.ServerStream +} + +type smartHTTPServicePostUploadPackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPServicePostUploadPackServer) Send(m *PostUploadPackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *smartHTTPServicePostUploadPackServer) Recv() (*PostUploadPackRequest, error) { + m := new(PostUploadPackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _SmartHTTPService_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SmartHTTPServiceServer).PostReceivePack(&smartHTTPServicePostReceivePackServer{stream}) +} + +type SmartHTTPService_PostReceivePackServer interface { + Send(*PostReceivePackResponse) error + Recv() (*PostReceivePackRequest, error) + grpc.ServerStream +} + +type smartHTTPServicePostReceivePackServer struct { + grpc.ServerStream +} + +func (x *smartHTTPServicePostReceivePackServer) Send(m *PostReceivePackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *smartHTTPServicePostReceivePackServer) Recv() (*PostReceivePackRequest, error) { + m := new(PostReceivePackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.SmartHTTPService", + HandlerType: (*SmartHTTPServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "InfoRefsUploadPack", + Handler: _SmartHTTPService_InfoRefsUploadPack_Handler, + ServerStreams: true, + }, + { + StreamName: "InfoRefsReceivePack", + Handler: _SmartHTTPService_InfoRefsReceivePack_Handler, + ServerStreams: true, + }, + { + StreamName: "PostUploadPack", + Handler: _SmartHTTPService_PostUploadPack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "PostReceivePack", + Handler: _SmartHTTPService_PostReceivePack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "smarthttp.proto", +} + func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor5) } var fileDescriptor5 = []byte{ - // 321 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, + // 342 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0xdd, 0x4a, 0x02, 0x41, + 0x18, 0x6d, 0xcc, 0x04, 0xbf, 0x2c, 0xe5, 0x93, 0x52, 0x16, 0x2a, 0xd9, 0x20, 0xbc, 0x28, 0x91, + 0xed, 0x19, 0x82, 0xa4, 0x2e, 0x64, 0x54, 0xe8, 0x4e, 0x26, 0x77, 0x5c, 0x97, 0x26, 0x67, 0x9b, + 0x99, 0x04, 0x5f, 0xa5, 0x17, 0xeb, 0xae, 0x67, 0x89, 0x76, 0xd9, 0x1f, 0xb5, 0xed, 0xa2, 0x9f, + 0xbb, 0xee, 0x96, 0x39, 0xdf, 0x9c, 0x73, 0xbe, 0x73, 0x96, 0x81, 0xaa, 0x7e, 0x64, 0xca, 0xcc, + 0x8c, 0x09, 0x3a, 0x81, 0x92, 0x46, 0x62, 0xc9, 0xf3, 0x0d, 0x13, 0x4b, 0xab, 0xa2, 0x67, 0x4c, + 0x71, 0x37, 0x3a, 0xb5, 0xaf, 0xa0, 0xda, 0x9b, 0x4f, 0x25, 0xe5, 0x53, 0x4d, 0xf9, 0xd3, 0x33, + 0xd7, 0x06, 0x1d, 0x00, 0xc5, 0x03, 0xa9, 0x7d, 0x23, 0xd5, 0xb2, 0x49, 0x5a, 0xa4, 0xbd, 0xeb, + 0x60, 0x27, 0xba, 0xdd, 0xa1, 0x09, 0x42, 0x33, 0x53, 0xf6, 0x19, 0xd4, 0x52, 0x1a, 0x1d, 0xc8, + 0xb9, 0xe6, 0x88, 0x50, 0x74, 0x99, 0x61, 0x21, 0x43, 0x85, 0x86, 0xdf, 0xf6, 0x18, 0x0e, 0xfa, + 0x52, 0x9b, 0x51, 0x20, 0x24, 0x73, 0xfb, 0x6c, 0xf2, 0xf0, 0x03, 0xd1, 0x44, 0xa0, 0x90, 0x11, + 0x38, 0x87, 0xc3, 0x75, 0x81, 0x2f, 0xec, 0xbc, 0x90, 0x68, 0x9c, 0xf2, 0x09, 0xf7, 0x17, 0xfc, + 0x0f, 0x0c, 0x61, 0x1d, 0x76, 0x3c, 0x31, 0xf6, 0xdd, 0xe6, 0x76, 0x8b, 0xb4, 0xcb, 0xb4, 0xe8, + 0x89, 0x9e, 0x8b, 0xa7, 0xb0, 0xe7, 0x89, 0x71, 0x86, 0xbf, 0x18, 0x82, 0x15, 0x4f, 0xa4, 0xcc, + 0xf6, 0x05, 0x34, 0x36, 0xbc, 0xe5, 0xef, 0xe2, 0xbc, 0x16, 0xa0, 0x3c, 0xf8, 0xe8, 0xfc, 0x7a, + 0x38, 0xec, 0xe3, 0x0d, 0x60, 0x5c, 0x48, 0x9a, 0x05, 0x36, 0xe2, 0x05, 0xd6, 0x3a, 0xb7, 0x9a, + 0x9b, 0x40, 0x24, 0x65, 0x6f, 0x75, 0x09, 0xde, 0x42, 0x3d, 0x3d, 0x4f, 0xdc, 0x7c, 0x97, 0x6d, + 0x04, 0xfb, 0xab, 0x15, 0xe1, 0x51, 0x3c, 0xff, 0xe9, 0xbf, 0x61, 0x1d, 0xe7, 0xc1, 0x31, 0x69, + 0x9b, 0x74, 0x09, 0xde, 0x41, 0x75, 0x2d, 0x2e, 0x5c, 0xb9, 0xb8, 0xd9, 0xb1, 0x75, 0x92, 0x8b, + 0x67, 0x99, 0x9d, 0xb7, 0x02, 0xd4, 0x92, 0x64, 0x07, 0x5c, 0x2d, 0xfc, 0x09, 0xff, 0x0f, 0xf8, + 0xf7, 0x02, 0xbe, 0x2f, 0x85, 0x6f, 0xd1, 0xe5, 0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0xfc, + 0x01, 0xd1, 0xb4, 0x04, 0x00, 0x00, } diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go index 81693891a2..8eab1a53e2 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go @@ -339,27 +339,193 @@ var _SSH_serviceDesc = grpc.ServiceDesc{ Metadata: "ssh.proto", } +// Client API for SSHService service + +type SSHServiceClient interface { + // To forward 'git upload-pack' to Gitaly for SSH sessions + SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error) + // To forward 'git receive-pack' to Gitaly for SSH sessions + SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error) +} + +type sSHServiceClient struct { + cc *grpc.ClientConn +} + +func NewSSHServiceClient(cc *grpc.ClientConn) SSHServiceClient { + return &sSHServiceClient{cc} +} + +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 := &sSHServiceSSHUploadPackClient{stream} + return x, nil +} + +type SSHService_SSHUploadPackClient interface { + Send(*SSHUploadPackRequest) error + Recv() (*SSHUploadPackResponse, error) + grpc.ClientStream +} + +type sSHServiceSSHUploadPackClient struct { + grpc.ClientStream +} + +func (x *sSHServiceSSHUploadPackClient) Send(m *SSHUploadPackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *sSHServiceSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) { + m := new(SSHUploadPackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +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 := &sSHServiceSSHReceivePackClient{stream} + return x, nil +} + +type SSHService_SSHReceivePackClient interface { + Send(*SSHReceivePackRequest) error + Recv() (*SSHReceivePackResponse, error) + grpc.ClientStream +} + +type sSHServiceSSHReceivePackClient struct { + grpc.ClientStream +} + +func (x *sSHServiceSSHReceivePackClient) Send(m *SSHReceivePackRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *sSHServiceSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) { + m := new(SSHReceivePackResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// Server API for SSHService service + +type SSHServiceServer interface { + // To forward 'git upload-pack' to Gitaly for SSH sessions + SSHUploadPack(SSHService_SSHUploadPackServer) error + // To forward 'git receive-pack' to Gitaly for SSH sessions + SSHReceivePack(SSHService_SSHReceivePackServer) error +} + +func RegisterSSHServiceServer(s *grpc.Server, srv SSHServiceServer) { + s.RegisterService(&_SSHService_serviceDesc, srv) +} + +func _SSHService_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SSHServiceServer).SSHUploadPack(&sSHServiceSSHUploadPackServer{stream}) +} + +type SSHService_SSHUploadPackServer interface { + Send(*SSHUploadPackResponse) error + Recv() (*SSHUploadPackRequest, error) + grpc.ServerStream +} + +type sSHServiceSSHUploadPackServer struct { + grpc.ServerStream +} + +func (x *sSHServiceSSHUploadPackServer) Send(m *SSHUploadPackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *sSHServiceSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) { + m := new(SSHUploadPackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _SSHService_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(SSHServiceServer).SSHReceivePack(&sSHServiceSSHReceivePackServer{stream}) +} + +type SSHService_SSHReceivePackServer interface { + Send(*SSHReceivePackResponse) error + Recv() (*SSHReceivePackRequest, error) + grpc.ServerStream +} + +type sSHServiceSSHReceivePackServer struct { + grpc.ServerStream +} + +func (x *sSHServiceSSHReceivePackServer) Send(m *SSHReceivePackResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *sSHServiceSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) { + m := new(SSHReceivePackRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _SSHService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.SSHService", + HandlerType: (*SSHServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "SSHUploadPack", + Handler: _SSHService_SSHUploadPack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "SSHReceivePack", + Handler: _SSHService_SSHReceivePack_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "ssh.proto", +} + func init() { proto.RegisterFile("ssh.proto", fileDescriptor6) } var fileDescriptor6 = []byte{ - // 304 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4e, 0xf3, 0x30, - 0x10, 0xfc, 0xfc, 0xf5, 0x47, 0xea, 0x36, 0xe5, 0xb0, 0x94, 0xaa, 0x8a, 0x00, 0x55, 0xe1, 0x92, - 0x53, 0x84, 0xd2, 0x67, 0x40, 0x2a, 0x37, 0xe4, 0xa8, 0xe7, 0x10, 0x6a, 0x2b, 0xb5, 0xb0, 0xea, - 0x60, 0x3b, 0xa8, 0x95, 0xe0, 0x49, 0x78, 0x09, 0x1e, 0x11, 0xc9, 0x09, 0x25, 0x29, 0xf4, 0x08, - 0xb7, 0xcc, 0x4e, 0x76, 0x66, 0xd6, 0xbb, 0x30, 0x30, 0x66, 0x1d, 0x15, 0x5a, 0x59, 0x85, 0xfd, - 0x5c, 0xd8, 0x4c, 0xee, 0x7c, 0xcf, 0xac, 0x33, 0xcd, 0x59, 0x55, 0x0d, 0xee, 0x61, 0x9c, 0x24, - 0x8b, 0x65, 0x21, 0x55, 0xc6, 0xee, 0xb2, 0xd5, 0x23, 0xe5, 0x4f, 0x25, 0x37, 0x16, 0x63, 0x00, - 0xcd, 0x0b, 0x65, 0x84, 0x55, 0x7a, 0x37, 0x25, 0x33, 0x12, 0x0e, 0x63, 0x8c, 0x2a, 0x89, 0x88, - 0xee, 0x19, 0xda, 0xf8, 0x0b, 0xc7, 0xd0, 0x33, 0x96, 0x89, 0xcd, 0xf4, 0xff, 0x8c, 0x84, 0x1e, - 0xad, 0x40, 0xf0, 0x02, 0x67, 0x07, 0x0e, 0xa6, 0x50, 0x1b, 0xc3, 0x71, 0x02, 0x7d, 0x63, 0x99, - 0x2a, 0xad, 0x93, 0xf7, 0x68, 0x8d, 0xea, 0x3a, 0xd7, 0xba, 0xd6, 0xa9, 0x11, 0xce, 0x61, 0xc8, - 0xb7, 0xc2, 0xa6, 0xc6, 0x66, 0xb6, 0x34, 0xd3, 0x4e, 0x3b, 0xd3, 0xcd, 0x56, 0xd8, 0xc4, 0x31, - 0x14, 0xf8, 0xfe, 0x3b, 0x78, 0x23, 0xce, 0x9e, 0xf2, 0x15, 0x17, 0xcf, 0xfc, 0x57, 0x26, 0xc4, - 0x53, 0xe8, 0xe5, 0x32, 0x15, 0xcc, 0x45, 0x1a, 0xd0, 0x6e, 0x2e, 0x6f, 0x19, 0x5e, 0xc1, 0x28, - 0x97, 0x69, 0xc3, 0xa1, 0xeb, 0x48, 0x2f, 0x97, 0x5f, 0xda, 0xc1, 0x2b, 0x4c, 0x0e, 0xc3, 0xfd, - 0xe1, 0xe3, 0xc4, 0xef, 0x04, 0x3a, 0x49, 0xb2, 0x40, 0x0a, 0xa3, 0xd6, 0x8a, 0xf0, 0xfc, 0xb3, - 0xf1, 0xa7, 0xdb, 0xf0, 0x2f, 0x8e, 0xb0, 0x55, 0xf4, 0xe0, 0x5f, 0x48, 0xae, 0x09, 0x2e, 0xe1, - 0xa4, 0x3d, 0x1a, 0x36, 0xdb, 0xbe, 0xef, 0xc3, 0xbf, 0x3c, 0x46, 0x37, 0x65, 0x1f, 0xfa, 0xee, - 0x6c, 0xe7, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x3d, 0xb9, 0xce, 0xd9, 0x02, 0x00, 0x00, + // 319 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x53, 0x4d, 0x4f, 0x02, 0x31, + 0x10, 0xb5, 0xf2, 0x91, 0x30, 0x2c, 0x1e, 0x46, 0x24, 0x84, 0xa8, 0x21, 0xeb, 0x85, 0x13, 0x31, + 0xcb, 0x6f, 0x30, 0xc1, 0x9b, 0x69, 0xc3, 0x19, 0x57, 0x76, 0xb2, 0x34, 0x36, 0x74, 0x6d, 0x0b, + 0x81, 0x44, 0x7f, 0x89, 0x7f, 0xc2, 0x9b, 0x7f, 0xcf, 0xa4, 0xbb, 0xe2, 0x82, 0x72, 0xd4, 0xc4, + 0xdb, 0xbe, 0x79, 0x3b, 0xef, 0xbd, 0xe9, 0xb4, 0xd0, 0xb0, 0x76, 0x3e, 0xcc, 0x8c, 0x76, 0x1a, + 0xeb, 0xa9, 0x74, 0xb1, 0xda, 0xf4, 0x02, 0x3b, 0x8f, 0x0d, 0x25, 0x79, 0x35, 0xbc, 0x87, 0xb6, + 0x10, 0xe3, 0x49, 0xa6, 0x74, 0x9c, 0xdc, 0xc5, 0xb3, 0x47, 0x4e, 0x4f, 0x4b, 0xb2, 0x0e, 0x23, + 0x00, 0x43, 0x99, 0xb6, 0xd2, 0x69, 0xb3, 0xe9, 0xb2, 0x3e, 0x1b, 0x34, 0x23, 0x1c, 0xe6, 0x12, + 0x43, 0xbe, 0x65, 0x78, 0xe9, 0x2f, 0x6c, 0x43, 0xcd, 0xba, 0x44, 0x2e, 0xba, 0xc7, 0x7d, 0x36, + 0x08, 0x78, 0x0e, 0xc2, 0x67, 0x38, 0xdb, 0x73, 0xb0, 0x99, 0x5e, 0x58, 0xc2, 0x0e, 0xd4, 0xad, + 0x4b, 0xf4, 0xd2, 0x79, 0xf9, 0x80, 0x17, 0xa8, 0xa8, 0x93, 0x31, 0x85, 0x4e, 0x81, 0x70, 0x04, + 0x4d, 0x5a, 0x4b, 0x37, 0xb5, 0x2e, 0x76, 0x4b, 0xdb, 0xad, 0xec, 0x66, 0xba, 0x59, 0x4b, 0x27, + 0x3c, 0xc3, 0x81, 0xb6, 0xdf, 0xe1, 0x2b, 0xf3, 0xf6, 0x9c, 0x66, 0x24, 0x57, 0xf4, 0x2b, 0x13, + 0xe2, 0x29, 0xd4, 0x52, 0x35, 0x95, 0x89, 0x8f, 0xd4, 0xe0, 0xd5, 0x54, 0xdd, 0x26, 0x78, 0x05, + 0xad, 0x54, 0x4d, 0x4b, 0x0e, 0x55, 0x4f, 0x06, 0xa9, 0xfa, 0xd2, 0x0e, 0x5f, 0xa0, 0xb3, 0x1f, + 0xee, 0x0f, 0x0f, 0x27, 0x7a, 0x63, 0x50, 0x11, 0x62, 0x8c, 0x1c, 0x5a, 0x3b, 0x2b, 0xc2, 0xf3, + 0xcf, 0xc6, 0x9f, 0xee, 0x46, 0xef, 0xe2, 0x00, 0x9b, 0x47, 0x0f, 0x8f, 0x06, 0xec, 0x9a, 0xe1, + 0x04, 0x4e, 0x76, 0x47, 0xc3, 0x72, 0xdb, 0xf7, 0x7d, 0xf4, 0x2e, 0x0f, 0xd1, 0x65, 0xd9, 0xe8, + 0x9d, 0x01, 0x08, 0x31, 0x16, 0x64, 0x56, 0x72, 0x46, 0xff, 0x28, 0xf9, 0x43, 0xdd, 0x3f, 0xb8, + 0xd1, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc3, 0xee, 0x90, 0x93, 0x93, 0x03, 0x00, 0x00, } -- GitLab From 24be173862bd4fa07f9e773cfa2f65898a0cdb9f Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Mon, 26 Jun 2017 09:59:25 +0100 Subject: [PATCH 2/7] Added bridge to test helper --- internal/service/smarthttp/testhelper_test.go | 2 +- internal/service/ssh/testhelper_test.go | 2 +- vendor/vendor.json | 14 +++++--------- 3 files changed, 7 insertions(+), 11 deletions(-) diff --git a/internal/service/smarthttp/testhelper_test.go b/internal/service/smarthttp/testhelper_test.go index 25b88b96c2..2de6aaa120 100644 --- a/internal/service/smarthttp/testhelper_test.go +++ b/internal/service/smarthttp/testhelper_test.go @@ -47,7 +47,7 @@ func runSmartHTTPServer(t *testing.T) *grpc.Server { t.Fatal(err) } - pb.RegisterSmartHTTPServer(server, NewServer()) + pb.RegisterSmartHTTPServer(server, NewRenameBridge(NewServer())) reflection.Register(server) go server.Serve(listener) diff --git a/internal/service/ssh/testhelper_test.go b/internal/service/ssh/testhelper_test.go index db29a038e6..015fd1cc28 100644 --- a/internal/service/ssh/testhelper_test.go +++ b/internal/service/ssh/testhelper_test.go @@ -41,7 +41,7 @@ func runSSHServer(t *testing.T) *grpc.Server { t.Fatal(err) } - pb.RegisterSSHServer(server, NewServer()) + pb.RegisterSSHServer(server, NewRenameBridge(NewServer())) reflection.Register(server) go server.Serve(listener) diff --git a/vendor/vendor.json b/vendor/vendor.json index fba4ee36a3..6b3a587542 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -191,20 +191,16 @@ "revisionTime": "2017-01-30T11:31:45Z" }, { - "checksumSHA1": "6SVQZeJ2M//eFTZwDe1ArP7RF8g=", + "checksumSHA1": "zGSXE91ijUmwNJI28+v8PbP3foY=", "path": "gitlab.com/gitlab-org/gitaly-proto/go", - "revision": "e302a46f7ccd889bfaa683d2ba06ffe06ca5875b", - "revisionTime": "2017-06-12T18:49:50Z", - "version": "v0.9.0", - "versionExact": "v0.9.0" + "revision": "ad5be24f8de7579c077b837fbb2696a517ae2457", + "revisionTime": "2017-06-21T11:43:20Z" }, { "checksumSHA1": "GkeSZfXVbtAkBZOrswot19GJZqQ=", "path": "gitlab.com/gitlab-org/gitaly-proto/go/helper", - "revision": "e302a46f7ccd889bfaa683d2ba06ffe06ca5875b", - "revisionTime": "2017-06-12T18:49:50Z", - "version": "v0.9.0", - "versionExact": "v0.9.0" + "revision": "ad5be24f8de7579c077b837fbb2696a517ae2457", + "revisionTime": "2017-06-21T11:43:20Z" }, { "checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=", -- GitLab From 1447f6b12ace9af9d225f328223145ef9c87e467 Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Mon, 26 Jun 2017 10:44:40 +0100 Subject: [PATCH 3/7] Adapters are all implemented --- internal/service/commit/server.go | 2 +- internal/service/commit/tree_entry.go | 2 +- internal/service/diff/commit.go | 4 +- internal/service/diff/commit_test.go | 4 +- internal/service/diff/server.go | 2 +- internal/service/notifications/server.go | 2 +- internal/service/ref/refs.go | 6 +- internal/service/ref/server.go | 2 +- internal/service/register.go | 25 +- internal/service/renameadapter/commit.go | 23 + internal/service/renameadapter/diff.go | 20 + .../service/renameadapter/notifications.go | 19 + internal/service/renameadapter/ref.go | 32 + internal/service/renameadapter/smarthttp.go | 28 + internal/service/renameadapter/ssh.go | 20 + internal/service/smarthttp/rename_bridge.go | 28 - internal/service/ssh/rename_bridge.go | 20 - .../gitlab-org/gitaly-proto/go/commit.pb.go | 124 +- .../gitaly-proto/go/deprecated-services.pb.go | 1146 +++++++++++++++++ .../gitlab-org/gitaly-proto/go/diff.pb.go | 159 +-- .../gitaly-proto/go/notifications.pb.go | 56 +- .../gitlab-org/gitaly-proto/go/ref.pb.go | 248 ++-- .../gitaly-proto/go/repository-service.pb.go | 144 +++ .../gitlab-org/gitaly-proto/go/shared.pb.go | 8 +- .../gitaly-proto/go/smarthttp.pb.go | 352 +---- .../gitlab-org/gitaly-proto/go/ssh.pb.go | 221 +--- vendor/vendor.json | 14 +- 27 files changed, 1831 insertions(+), 880 deletions(-) create mode 100644 internal/service/renameadapter/commit.go create mode 100644 internal/service/renameadapter/diff.go create mode 100644 internal/service/renameadapter/notifications.go create mode 100644 internal/service/renameadapter/ref.go create mode 100644 internal/service/renameadapter/smarthttp.go create mode 100644 internal/service/renameadapter/ssh.go delete mode 100644 internal/service/smarthttp/rename_bridge.go delete mode 100644 internal/service/ssh/rename_bridge.go create mode 100644 vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go create mode 100644 vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go diff --git a/internal/service/commit/server.go b/internal/service/commit/server.go index 31c4d25162..d904489841 100644 --- a/internal/service/commit/server.go +++ b/internal/service/commit/server.go @@ -5,6 +5,6 @@ import pb "gitlab.com/gitlab-org/gitaly-proto/go" type server struct{} // NewServer creates a new instance of a grpc CommitServer -func NewServer() pb.CommitServer { +func NewServer() pb.CommitServiceServer { return &server{} } diff --git a/internal/service/commit/tree_entry.go b/internal/service/commit/tree_entry.go index 4ad1ddbff9..d1cf538225 100644 --- a/internal/service/commit/tree_entry.go +++ b/internal/service/commit/tree_entry.go @@ -25,7 +25,7 @@ type objectInfo struct { mode int32 } -func (s *server) TreeEntry(in *pb.TreeEntryRequest, stream pb.Commit_TreeEntryServer) error { +func (s *server) TreeEntry(in *pb.TreeEntryRequest, stream pb.CommitService_TreeEntryServer) error { if err := validateRequest(in); err != nil { return grpc.Errorf(codes.InvalidArgument, "TreeEntry: %v", err) } diff --git a/internal/service/diff/commit.go b/internal/service/diff/commit.go index 252363d8e9..db8ed52ce4 100644 --- a/internal/service/diff/commit.go +++ b/internal/service/diff/commit.go @@ -16,7 +16,7 @@ type requestWithLeftRightCommitIds interface { GetRightCommitId() string } -func (s *server) CommitDiff(in *pb.CommitDiffRequest, stream pb.Diff_CommitDiffServer) error { +func (s *server) CommitDiff(in *pb.CommitDiffRequest, stream pb.DiffService_CommitDiffServer) error { if err := validateRequest(in); err != nil { return grpc.Errorf(codes.InvalidArgument, "CommitDiff: %v", err) } @@ -104,7 +104,7 @@ func (s *server) CommitDiff(in *pb.CommitDiffRequest, stream pb.Diff_CommitDiffS return err } -func (s *server) CommitDelta(in *pb.CommitDeltaRequest, stream pb.Diff_CommitDeltaServer) error { +func (s *server) CommitDelta(in *pb.CommitDeltaRequest, stream pb.DiffService_CommitDeltaServer) error { if err := validateRequest(in); err != nil { return grpc.Errorf(codes.InvalidArgument, "CommitDelta: %v", err) } diff --git a/internal/service/diff/commit_test.go b/internal/service/diff/commit_test.go index 0d69f759c7..e8404389ca 100644 --- a/internal/service/diff/commit_test.go +++ b/internal/service/diff/commit_test.go @@ -695,7 +695,7 @@ func drainCommitDeltaResponse(c pb.Diff_CommitDeltaClient) error { return nil } -func getDiffsFromCommitDiffClient(t *testing.T, client pb.Diff_CommitDiffClient) []*diff.Diff { +func getDiffsFromCommitDiffClient(t *testing.T, client pb.DiffService_CommitDiffClient) []*diff.Diff { var diffs []*diff.Diff var currentDiff *diff.Diff @@ -731,7 +731,7 @@ func getDiffsFromCommitDiffClient(t *testing.T, client pb.Diff_CommitDiffClient) return diffs } -func assertExactReceivedDiffs(t *testing.T, client pb.Diff_CommitDiffClient, expectedDiffs []diff.Diff) { +func assertExactReceivedDiffs(t *testing.T, client pb.DiffService_CommitDiffClient, expectedDiffs []diff.Diff) { fetchedDiffs := getDiffsFromCommitDiffClient(t, client) var i int diff --git a/internal/service/diff/server.go b/internal/service/diff/server.go index e75cbd3865..343a9c4a73 100644 --- a/internal/service/diff/server.go +++ b/internal/service/diff/server.go @@ -11,6 +11,6 @@ type server struct { } // NewServer creates a new instance of a gRPC DiffServer -func NewServer() pb.DiffServer { +func NewServer() pb.DiffServiceServer { return &server{MsgSizeThreshold: msgSizeThreshold} } diff --git a/internal/service/notifications/server.go b/internal/service/notifications/server.go index 786867780d..ace7cdd079 100644 --- a/internal/service/notifications/server.go +++ b/internal/service/notifications/server.go @@ -5,6 +5,6 @@ import pb "gitlab.com/gitlab-org/gitaly-proto/go" type server struct{} // NewServer creates a new instance of a grpc NotificationsServer -func NewServer() pb.NotificationsServer { +func NewServer() pb.NotificationServiceServer { return &server{} } diff --git a/internal/service/ref/refs.go b/internal/service/ref/refs.go index c8d5d343cd..5e08188167 100644 --- a/internal/service/ref/refs.go +++ b/internal/service/ref/refs.go @@ -69,12 +69,12 @@ func findRefs(writer refsWriter, repo *pb.Repository, pattern string, args ...st } // FindAllBranchNames creates a stream of ref names for all branches in the given repository -func (s *server) FindAllBranchNames(in *pb.FindAllBranchNamesRequest, stream pb.Ref_FindAllBranchNamesServer) error { +func (s *server) FindAllBranchNames(in *pb.FindAllBranchNamesRequest, stream pb.RefService_FindAllBranchNamesServer) error { return findRefs(newFindAllBranchNamesWriter(stream, s.MaxMsgSize), in.Repository, "refs/heads") } // FindAllTagNames creates a stream of ref names for all tags in the given repository -func (s *server) FindAllTagNames(in *pb.FindAllTagNamesRequest, stream pb.Ref_FindAllTagNamesServer) error { +func (s *server) FindAllTagNames(in *pb.FindAllTagNamesRequest, stream pb.RefService_FindAllTagNamesServer) error { return findRefs(newFindAllTagNamesWriter(stream, s.MaxMsgSize), in.Repository, "refs/tags") } @@ -204,7 +204,7 @@ func parseSortKey(sortKey pb.FindLocalBranchesRequest_SortBy) string { } // FindLocalBranches creates a stream of branches for all local branches in the given repository -func (s *server) FindLocalBranches(in *pb.FindLocalBranchesRequest, stream pb.Ref_FindLocalBranchesServer) error { +func (s *server) FindLocalBranches(in *pb.FindLocalBranchesRequest, stream pb.RefService_FindLocalBranchesServer) error { // %00 inserts the null character into the output (see for-each-ref docs) formatFlag := "--format=" + strings.Join(localBranchFormatFields, "%00") sortFlag := "--sort=" + parseSortKey(in.GetSortBy()) diff --git a/internal/service/ref/server.go b/internal/service/ref/server.go index 22e3778909..ea400f9a9a 100644 --- a/internal/service/ref/server.go +++ b/internal/service/ref/server.go @@ -9,6 +9,6 @@ type server struct { } // NewServer creates a new instance of a grpc RefServer -func NewServer() pb.RefServer { +func NewServer() pb.RefServiceServer { return &server{MaxMsgSize: maxMsgSize} } diff --git a/internal/service/register.go b/internal/service/register.go index ba7cc19383..cbf21d6f76 100644 --- a/internal/service/register.go +++ b/internal/service/register.go @@ -6,6 +6,7 @@ import ( "gitlab.com/gitlab-org/gitaly/internal/service/diff" "gitlab.com/gitlab-org/gitaly/internal/service/notifications" "gitlab.com/gitlab-org/gitaly/internal/service/ref" + "gitlab.com/gitlab-org/gitaly/internal/service/renameadapter" "gitlab.com/gitlab-org/gitaly/internal/service/smarthttp" "gitlab.com/gitlab-org/gitaly/internal/service/ssh" @@ -17,19 +18,31 @@ import ( // RegisterAll will register all the known grpc services with // the specified grpc service instance func RegisterAll(grpcServer *grpc.Server) { - pb.RegisterNotificationsServer(grpcServer, notifications.NewServer()) - pb.RegisterRefServer(grpcServer, ref.NewServer()) + notificationsService := notifications.NewServer() + pb.RegisterNotificationServiceServer(grpcServer, notificationsService) + + refService := ref.NewServer() + pb.RegisterRefServiceServer(grpcServer, refService) smartHTTPService := smarthttp.NewServer() pb.RegisterSmartHTTPServiceServer(grpcServer, smartHTTPService) - pb.RegisterSmartHTTPServer(grpcServer, smarthttp.NewRenameBridge(smartHTTPService)) - pb.RegisterDiffServer(grpcServer, diff.NewServer()) - pb.RegisterCommitServer(grpcServer, commit.NewServer()) + diffService := diff.NewServer() + pb.RegisterDiffServiceServer(grpcServer, diffService) + + commitService := commit.NewServer() + pb.RegisterCommitServiceServer(grpcServer, commitService) sshService := ssh.NewServer() pb.RegisterSSHServiceServer(grpcServer, sshService) - pb.RegisterSSHServer(grpcServer, ssh.NewRenameBridge(sshService)) + + // Deprecated Services + pb.RegisterNotificationServiceServer(grpcServer, renameadapter.NewNotificationAdapter(notificationsService)) + pb.RegisterRefServer(grpcServer, renameadapter.NewRefAdapter(refService)) + pb.RegisterSmartHTTPServer(grpcServer, renameadapter.NewSmartHTTPAdapter(smartHTTPService)) + pb.RegisterDiffServer(grpcServer, renameadapter.NewDiffAdapter(diffService)) + pb.RegisterCommitServer(grpcServer, renameadapter.NewCommitAdapter(commitService)) + pb.RegisterSSHServer(grpcServer, renameadapter.NewSSHAdapter(sshService)) healthpb.RegisterHealthServer(grpcServer, health.NewServer()) } diff --git a/internal/service/renameadapter/commit.go b/internal/service/renameadapter/commit.go new file mode 100644 index 0000000000..d46efc66d1 --- /dev/null +++ b/internal/service/renameadapter/commit.go @@ -0,0 +1,23 @@ +package renameadapter + +import ( + pb "gitlab.com/gitlab-org/gitaly-proto/go" + "golang.org/x/net/context" +) + +type commitAdapter struct { + upstream pb.CommitServiceServer +} + +func (s *commitAdapter) CommitIsAncestor(ctx context.Context, req *pb.CommitIsAncestorRequest) (*pb.CommitIsAncestorResponse, error) { + return s.upstream.CommitIsAncestor(ctx, req) +} + +func (s *commitAdapter) TreeEntry(req *pb.TreeEntryRequest, res pb.Commit_TreeEntryServer) error { + return s.upstream.TreeEntry(req, res) +} + +// NewCommitAdapter adapts CommitServiceServer to CommitServer +func NewCommitAdapter(upstream pb.CommitServiceServer) pb.CommitServer { + return &commitAdapter{upstream} +} diff --git a/internal/service/renameadapter/diff.go b/internal/service/renameadapter/diff.go new file mode 100644 index 0000000000..06f437569b --- /dev/null +++ b/internal/service/renameadapter/diff.go @@ -0,0 +1,20 @@ +package renameadapter + +import pb "gitlab.com/gitlab-org/gitaly-proto/go" + +type diffAdapter struct { + upstream pb.DiffServiceServer +} + +func (s *diffAdapter) CommitDiff(req *pb.CommitDiffRequest, res pb.Diff_CommitDiffServer) error { + return s.upstream.CommitDiff(req, res) +} + +func (s *diffAdapter) CommitDelta(req *pb.CommitDeltaRequest, res pb.Diff_CommitDeltaServer) error { + return s.upstream.CommitDelta(req, res) +} + +// NewDiffAdapter adapts DiffServiceServer to DiffServer +func NewDiffAdapter(upstream pb.DiffServiceServer) pb.DiffServer { + return &diffAdapter{upstream} +} diff --git a/internal/service/renameadapter/notifications.go b/internal/service/renameadapter/notifications.go new file mode 100644 index 0000000000..70f8fb20a4 --- /dev/null +++ b/internal/service/renameadapter/notifications.go @@ -0,0 +1,19 @@ +package renameadapter + +import ( + pb "gitlab.com/gitlab-org/gitaly-proto/go" + "golang.org/x/net/context" +) + +type notificationAdapter struct { + upstream pb.NotificationServiceServer +} + +func (s *notificationAdapter) PostReceive(ctx context.Context, req *pb.PostReceiveRequest) (*pb.PostReceiveResponse, error) { + return s.upstream.PostReceive(ctx, req) +} + +// NewNotificationAdapter adapts NotificationServiceServer to NotificationsServer +func NewNotificationAdapter(upstream pb.NotificationServiceServer) pb.NotificationsServer { + return ¬ificationAdapter{upstream} +} diff --git a/internal/service/renameadapter/ref.go b/internal/service/renameadapter/ref.go new file mode 100644 index 0000000000..9e97a829f2 --- /dev/null +++ b/internal/service/renameadapter/ref.go @@ -0,0 +1,32 @@ +package renameadapter + +import ( + pb "gitlab.com/gitlab-org/gitaly-proto/go" + "golang.org/x/net/context" +) + +type refAdapter struct { + upstream pb.RefServiceServer +} + +func (s *refAdapter) FindDefaultBranchName(ctx context.Context, req *pb.FindDefaultBranchNameRequest) (*pb.FindDefaultBranchNameResponse, error) { + return s.upstream.FindDefaultBranchName(ctx, req) +} + +func (s *refAdapter) FindAllBranchNames(req *pb.FindAllBranchNamesRequest, res pb.Ref_FindAllBranchNamesServer) error { + return s.upstream.FindAllBranchNames(req, res) +} +func (s *refAdapter) FindAllTagNames(req *pb.FindAllTagNamesRequest, res pb.Ref_FindAllTagNamesServer) error { + return s.upstream.FindAllTagNames(req, res) +} +func (s *refAdapter) FindRefName(ctx context.Context, req *pb.FindRefNameRequest) (*pb.FindRefNameResponse, error) { + return s.upstream.FindRefName(ctx, req) +} +func (s *refAdapter) FindLocalBranches(req *pb.FindLocalBranchesRequest, res pb.Ref_FindLocalBranchesServer) error { + return s.upstream.FindLocalBranches(req, res) +} + +// NewRefAdapter adapts RefServiceServer to RefServer +func NewRefAdapter(upstream pb.RefServiceServer) pb.RefServer { + return &refAdapter{upstream} +} diff --git a/internal/service/renameadapter/smarthttp.go b/internal/service/renameadapter/smarthttp.go new file mode 100644 index 0000000000..0e6b7e015b --- /dev/null +++ b/internal/service/renameadapter/smarthttp.go @@ -0,0 +1,28 @@ +package renameadapter + +import pb "gitlab.com/gitlab-org/gitaly-proto/go" + +type smartHTTPAdapter struct { + upstream pb.SmartHTTPServiceServer +} + +func (s *smartHTTPAdapter) InfoRefsUploadPack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsUploadPackServer) error { + return s.upstream.InfoRefsReceivePack(in, stream) +} + +func (s *smartHTTPAdapter) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsReceivePackServer) error { + return s.upstream.InfoRefsReceivePack(in, stream) +} + +func (s *smartHTTPAdapter) PostUploadPack(stream pb.SmartHTTP_PostUploadPackServer) error { + return s.upstream.PostUploadPack(stream) +} + +func (s *smartHTTPAdapter) PostReceivePack(stream pb.SmartHTTP_PostReceivePackServer) error { + return s.upstream.PostReceivePack(stream) +} + +// NewSmartHTTPAdapter creates an adapter between SmartHTTPServiceServer and SmartHTTPServer +func NewSmartHTTPAdapter(upstream pb.SmartHTTPServiceServer) pb.SmartHTTPServer { + return &smartHTTPAdapter{upstream} +} diff --git a/internal/service/renameadapter/ssh.go b/internal/service/renameadapter/ssh.go new file mode 100644 index 0000000000..45d21f3b53 --- /dev/null +++ b/internal/service/renameadapter/ssh.go @@ -0,0 +1,20 @@ +package renameadapter + +import pb "gitlab.com/gitlab-org/gitaly-proto/go" + +type sshAdapter struct { + upstream pb.SSHServiceServer +} + +func (s *sshAdapter) SSHUploadPack(stream pb.SSH_SSHUploadPackServer) error { + return s.upstream.SSHUploadPack(stream) +} + +func (s *sshAdapter) SSHReceivePack(stream pb.SSH_SSHReceivePackServer) error { + return s.upstream.SSHReceivePack(stream) +} + +// NewSSHAdapter creates a sshAdapter between SmartHTTPServiceServer and SmartHTTPServer +func NewSSHAdapter(upstream pb.SSHServiceServer) pb.SSHServer { + return &sshAdapter{upstream} +} diff --git a/internal/service/smarthttp/rename_bridge.go b/internal/service/smarthttp/rename_bridge.go deleted file mode 100644 index eefae4d65c..0000000000 --- a/internal/service/smarthttp/rename_bridge.go +++ /dev/null @@ -1,28 +0,0 @@ -package smarthttp - -import pb "gitlab.com/gitlab-org/gitaly-proto/go" - -type bridge struct { - upstream pb.SmartHTTPServiceServer -} - -func (s *bridge) InfoRefsUploadPack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsUploadPackServer) error { - return s.upstream.InfoRefsReceivePack(in, stream) -} - -func (s *bridge) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsReceivePackServer) error { - return s.upstream.InfoRefsReceivePack(in, stream) -} - -func (s *bridge) PostUploadPack(stream pb.SmartHTTP_PostUploadPackServer) error { - return s.upstream.PostUploadPack(stream) -} - -func (s *bridge) PostReceivePack(stream pb.SmartHTTP_PostReceivePackServer) error { - return s.upstream.PostReceivePack(stream) -} - -// NewRenameBridge creates a bridge between SmartHTTPServiceServer and SmartHTTPServer -func NewRenameBridge(upstream pb.SmartHTTPServiceServer) pb.SmartHTTPServer { - return &bridge{upstream} -} diff --git a/internal/service/ssh/rename_bridge.go b/internal/service/ssh/rename_bridge.go deleted file mode 100644 index d4f98649f0..0000000000 --- a/internal/service/ssh/rename_bridge.go +++ /dev/null @@ -1,20 +0,0 @@ -package ssh - -import pb "gitlab.com/gitlab-org/gitaly-proto/go" - -type bridge struct { - upstream pb.SSHServiceServer -} - -func (s *bridge) SSHUploadPack(stream pb.SSH_SSHUploadPackServer) error { - return s.upstream.SSHUploadPack(stream) -} - -func (s *bridge) SSHReceivePack(stream pb.SSH_SSHReceivePackServer) error { - return s.upstream.SSHReceivePack(stream) -} - -// NewRenameBridge creates a bridge between SmartHTTPServiceServer and SmartHTTPServer -func NewRenameBridge(upstream pb.SSHServiceServer) pb.SSHServer { - return &bridge{upstream} -} diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go index b3c9351c54..f6721a336f 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go @@ -6,9 +6,11 @@ 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 + repository-service.proto shared.proto smarthttp.proto ssh.proto @@ -37,6 +39,8 @@ It has these top-level messages: FindLocalBranchesResponse FindLocalBranchResponse FindLocalBranchCommitAuthor + RepositoryExistsRequest + RepositoryExistsResponse Repository ExitStatus InfoRefsRequest @@ -253,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 } @@ -292,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 @@ -309,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, }, }, @@ -381,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/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go new file mode 100644 index 0000000000..b7d43d77e5 --- /dev/null +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/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{ + // 540 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40, + 0x10, 0x80, 0xe5, 0x06, 0x55, 0xca, 0x84, 0x36, 0xb0, 0x15, 0xa2, 0x31, 0x34, 0x69, 0x2b, 0x90, + 0x78, 0x21, 0x42, 0xe1, 0x04, 0x85, 0x02, 0x29, 0x85, 0x10, 0xd9, 0xa9, 0x54, 0x7e, 0x24, 0xb4, + 0xb5, 0x67, 0x9b, 0x15, 0x8e, 0xd7, 0x78, 0xb7, 0x95, 0x7a, 0x03, 0xae, 0xc1, 0x01, 0x78, 0xe5, + 0x36, 0x3c, 0x71, 0x11, 0xe4, 0x9f, 0x25, 0xbb, 0x8e, 0x5d, 0x1e, 0x78, 0xdb, 0xcc, 0x37, 0xf3, + 0xcd, 0x64, 0x7f, 0x0c, 0xbd, 0x10, 0x93, 0x14, 0x03, 0xaa, 0x30, 0x7c, 0x2c, 0x31, 0xbd, 0xe4, + 0x01, 0xca, 0x61, 0x92, 0x0a, 0x25, 0xc8, 0xfa, 0x39, 0x57, 0x34, 0xba, 0x72, 0x6f, 0x06, 0x62, + 0xb1, 0xe0, 0xaa, 0x88, 0xba, 0x10, 0x72, 0xc6, 0xca, 0xf5, 0x56, 0x2c, 0x14, 0x67, 0x3c, 0xa0, + 0x8a, 0x8b, 0xb8, 0x2c, 0x73, 0xdb, 0x29, 0x6a, 0xde, 0x95, 0x0b, 0x9a, 0xaa, 0xb9, 0x52, 0x89, + 0x66, 0x52, 0xce, 0x8b, 0xe5, 0xe8, 0x87, 0x03, 0xeb, 0xcf, 0x73, 0x31, 0xf9, 0x00, 0xb7, 0x8a, + 0xd5, 0x91, 0x3c, 0x88, 0x03, 0x94, 0x4a, 0xa4, 0x64, 0x30, 0x2c, 0xba, 0x0f, 0xab, 0xc4, 0xc3, + 0xaf, 0x17, 0x28, 0x95, 0xbb, 0xdb, 0x9c, 0x20, 0x13, 0x11, 0x4b, 0xdc, 0x6f, 0x7d, 0x5b, 0x73, + 0xc8, 0x2b, 0x68, 0xcf, 0x52, 0xc4, 0x17, 0xb1, 0x4a, 0xaf, 0xc8, 0xb6, 0xae, 0xf9, 0x1b, 0xd2, + 0xb6, 0x5e, 0x0d, 0x31, 0x34, 0x4f, 0x9c, 0xd1, 0x77, 0x07, 0x6e, 0x1c, 0x72, 0xc6, 0xc8, 0x6b, + 0x80, 0xa2, 0x65, 0xfe, 0xab, 0x67, 0x8f, 0x91, 0xc5, 0xb4, 0xd3, 0xad, 0x43, 0x96, 0x94, 0xbc, + 0x85, 0x4e, 0x09, 0x31, 0x52, 0x94, 0x54, 0x2b, 0xb2, 0xa0, 0xb6, 0xdd, 0xab, 0x65, 0xf6, 0x8c, + 0x9f, 0x60, 0x63, 0x62, 0x9e, 0x08, 0x39, 0x86, 0xce, 0x54, 0x48, 0xe5, 0x61, 0x80, 0xfc, 0x12, + 0x97, 0x7e, 0x23, 0xb8, 0xe2, 0xb7, 0x98, 0xe1, 0x1f, 0xfd, 0x6a, 0x41, 0xcb, 0x43, 0x46, 0x38, + 0xdc, 0x79, 0xc9, 0xe3, 0xf0, 0x10, 0x19, 0xbd, 0x88, 0xd4, 0xb3, 0x94, 0xc6, 0xc1, 0x7c, 0x42, + 0x17, 0x48, 0x1e, 0x68, 0x45, 0x2d, 0xd6, 0x8d, 0x1e, 0xfe, 0x23, 0xcb, 0x3c, 0xbd, 0x33, 0x20, + 0x59, 0xd6, 0x41, 0x14, 0x2d, 0x33, 0x24, 0xd9, 0x33, 0x0d, 0x36, 0xd3, 0x4d, 0xf6, 0xaf, 0x4b, + 0xb1, 0xcf, 0xe0, 0x3d, 0x74, 0xcb, 0xa4, 0x19, 0x3d, 0x2f, 0x1a, 0xf4, 0x2b, 0xd5, 0x1a, 0x68, + 0xfb, 0xa0, 0x91, 0xdb, 0xea, 0x63, 0xe8, 0x64, 0x19, 0x1e, 0xb2, 0x7c, 0x7f, 0x5c, 0xb3, 0xac, + 0x0c, 0xae, 0x6c, 0xbf, 0xc5, 0xcc, 0xbd, 0xf8, 0x0c, 0xb7, 0x33, 0xf6, 0x46, 0x04, 0xb4, 0xfc, + 0x3b, 0x28, 0xc9, 0xae, 0x59, 0x66, 0x21, 0x2d, 0xde, 0xbb, 0x26, 0xc3, 0xbe, 0x3d, 0xbf, 0xd7, + 0xa0, 0xed, 0x67, 0x0f, 0x76, 0x3c, 0x9b, 0x4d, 0xc9, 0x04, 0xc8, 0x51, 0xcc, 0x84, 0x87, 0x4c, + 0x9e, 0x24, 0x91, 0xa0, 0xe1, 0x94, 0x06, 0x5f, 0xc8, 0x5d, 0x6d, 0xd3, 0x4c, 0xb7, 0xd9, 0x5e, + 0x05, 0xf6, 0x5e, 0xbc, 0x83, 0xad, 0x25, 0xca, 0x6f, 0xd7, 0x7f, 0x0a, 0x4f, 0x61, 0x33, 0xbb, + 0xaa, 0xc6, 0x70, 0x3b, 0xe6, 0x15, 0x5e, 0xc6, 0xb5, 0xb1, 0xdf, 0x84, 0x0d, 0xef, 0xa3, 0xcc, + 0xfc, 0x11, 0xba, 0xc6, 0x23, 0xc8, 0xd5, 0xfd, 0x9a, 0xd7, 0x61, 0xba, 0x07, 0x8d, 0xbc, 0x22, + 0x1f, 0xfd, 0x74, 0xa0, 0xe5, 0xfb, 0x63, 0x72, 0x02, 0x1b, 0xbe, 0x3f, 0x36, 0xa6, 0xbf, 0xaf, + 0x15, 0x56, 0x58, 0x37, 0xd8, 0x69, 0xa0, 0xd5, 0xd9, 0x4f, 0x61, 0xd3, 0xf7, 0xc7, 0xe6, 0xe8, + 0x66, 0x65, 0xcd, 0xe4, 0xfd, 0x26, 0x5c, 0x31, 0x9f, 0xad, 0xe7, 0xdf, 0xed, 0xa7, 0x7f, 0x02, + 0x00, 0x00, 0xff, 0xff, 0xd4, 0x6c, 0x53, 0x6f, 0x32, 0x06, 0x00, 0x00, +} diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go index 737e542168..1dcc5365cd 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go @@ -28,7 +28,7 @@ type CommitDiffRequest struct { func (m *CommitDiffRequest) Reset() { *m = CommitDiffRequest{} } func (m *CommitDiffRequest) String() string { return proto.CompactTextString(m) } func (*CommitDiffRequest) ProtoMessage() {} -func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } +func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return 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/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go index 49891c3a09..e0948dc592 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go @@ -24,7 +24,7 @@ type PostReceiveRequest struct { func (m *PostReceiveRequest) Reset() { *m = PostReceiveRequest{} } func (m *PostReceiveRequest) String() string { return proto.CompactTextString(m) } func (*PostReceiveRequest) ProtoMessage() {} -func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } +func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return 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/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go index fe3178e9f1..bd8ed75a8a 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/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/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go new file mode 100644 index 0000000000..9a213f26cc --- /dev/null +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go @@ -0,0 +1,144 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: repository-service.proto + +package gitaly + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type RepositoryExistsRequest struct { + Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"` +} + +func (m *RepositoryExistsRequest) Reset() { *m = RepositoryExistsRequest{} } +func (m *RepositoryExistsRequest) String() string { return proto.CompactTextString(m) } +func (*RepositoryExistsRequest) ProtoMessage() {} +func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} } + +func (m *RepositoryExistsRequest) GetRepository() *Repository { + if m != nil { + return m.Repository + } + return nil +} + +type RepositoryExistsResponse struct { + Exists bool `protobuf:"varint,1,opt,name=exists" json:"exists,omitempty"` +} + +func (m *RepositoryExistsResponse) Reset() { *m = RepositoryExistsResponse{} } +func (m *RepositoryExistsResponse) String() string { return proto.CompactTextString(m) } +func (*RepositoryExistsResponse) ProtoMessage() {} +func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} } + +func (m *RepositoryExistsResponse) GetExists() bool { + if m != nil { + return m.Exists + } + return false +} + +func init() { + proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest") + proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// Client API for RepositoryService service + +type RepositoryServiceClient interface { + Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error) +} + +type repositoryServiceClient struct { + cc *grpc.ClientConn +} + +func NewRepositoryServiceClient(cc *grpc.ClientConn) RepositoryServiceClient { + return &repositoryServiceClient{cc} +} + +func (c *repositoryServiceClient) Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error) { + out := new(RepositoryExistsResponse) + err := grpc.Invoke(ctx, "/gitaly.RepositoryService/Exists", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for RepositoryService service + +type RepositoryServiceServer interface { + Exists(context.Context, *RepositoryExistsRequest) (*RepositoryExistsResponse, error) +} + +func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) { + s.RegisterService(&_RepositoryService_serviceDesc, srv) +} + +func _RepositoryService_Exists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RepositoryExistsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RepositoryServiceServer).Exists(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/gitaly.RepositoryService/Exists", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RepositoryServiceServer).Exists(ctx, req.(*RepositoryExistsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _RepositoryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "gitaly.RepositoryService", + HandlerType: (*RepositoryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Exists", + Handler: _RepositoryService_Exists_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "repository-service.proto", +} + +func init() { proto.RegisterFile("repository-service.proto", fileDescriptor5) } + +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, + 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, + 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0xf9, 0x72, 0x89, 0x07, 0xc1, 0x75, 0xb8, 0x56, 0x64, + 0x16, 0x97, 0x14, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x21, 0x0c, + 0x93, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x12, 0xd2, 0x83, 0x98, 0xa2, 0x87, 0xd0, 0x14, 0x84, + 0xa4, 0x4a, 0xc9, 0x88, 0x4b, 0x02, 0xd3, 0xb8, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x21, 0x31, + 0x2e, 0xb6, 0x54, 0xb0, 0x08, 0xd8, 0x2c, 0x8e, 0x20, 0x28, 0xcf, 0x28, 0x89, 0x4b, 0x10, 0xa1, + 0x27, 0x18, 0xe2, 0x66, 0x21, 0x5f, 0x2e, 0x36, 0x88, 0x76, 0x21, 0x79, 0x4c, 0x2b, 0x51, 0xdc, + 0x29, 0xa5, 0x80, 0x5b, 0x01, 0xc4, 0x66, 0x25, 0x86, 0x24, 0x36, 0xb0, 0x6f, 0x8d, 0x01, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x7e, 0xc1, 0x7d, 0x44, 0x1f, 0x01, 0x00, 0x00, +} diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go index 544b899581..71598846d1 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/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 fileDescriptor4, []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 fileDescriptor4, []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", fileDescriptor4) } +func init() { proto.RegisterFile("shared.proto", fileDescriptor6) } -var fileDescriptor4 = []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/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go index 692c81c7d1..46802c2c4d 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/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 fileDescriptor5, []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 fileDescriptor5, []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 fileDescriptor5, []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 fileDescriptor5, []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 fileDescriptor5, []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 fileDescriptor5, []int{5} } +func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{5} } func (m *PostReceivePackResponse) GetData() []byte { if m != nil { @@ -170,295 +170,6 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// 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: "smarthttp.proto", -} - // Client API for SmartHTTPService service type SmartHTTPServiceClient interface { @@ -748,30 +459,29 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{ Metadata: "smarthttp.proto", } -func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor5) } - -var fileDescriptor5 = []byte{ - // 342 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0xdd, 0x4a, 0x02, 0x41, - 0x18, 0x6d, 0xcc, 0x04, 0xbf, 0x2c, 0xe5, 0x93, 0x52, 0x16, 0x2a, 0xd9, 0x20, 0xbc, 0x28, 0x91, - 0xed, 0x19, 0x82, 0xa4, 0x2e, 0x64, 0x54, 0xe8, 0x4e, 0x26, 0x77, 0x5c, 0x97, 0x26, 0x67, 0x9b, - 0x99, 0x04, 0x5f, 0xa5, 0x17, 0xeb, 0xae, 0x67, 0x89, 0x76, 0xd9, 0x1f, 0xb5, 0xed, 0xa2, 0x9f, - 0xbb, 0xee, 0x96, 0x39, 0xdf, 0x9c, 0x73, 0xbe, 0x73, 0x96, 0x81, 0xaa, 0x7e, 0x64, 0xca, 0xcc, - 0x8c, 0x09, 0x3a, 0x81, 0x92, 0x46, 0x62, 0xc9, 0xf3, 0x0d, 0x13, 0x4b, 0xab, 0xa2, 0x67, 0x4c, - 0x71, 0x37, 0x3a, 0xb5, 0xaf, 0xa0, 0xda, 0x9b, 0x4f, 0x25, 0xe5, 0x53, 0x4d, 0xf9, 0xd3, 0x33, - 0xd7, 0x06, 0x1d, 0x00, 0xc5, 0x03, 0xa9, 0x7d, 0x23, 0xd5, 0xb2, 0x49, 0x5a, 0xa4, 0xbd, 0xeb, - 0x60, 0x27, 0xba, 0xdd, 0xa1, 0x09, 0x42, 0x33, 0x53, 0xf6, 0x19, 0xd4, 0x52, 0x1a, 0x1d, 0xc8, - 0xb9, 0xe6, 0x88, 0x50, 0x74, 0x99, 0x61, 0x21, 0x43, 0x85, 0x86, 0xdf, 0xf6, 0x18, 0x0e, 0xfa, - 0x52, 0x9b, 0x51, 0x20, 0x24, 0x73, 0xfb, 0x6c, 0xf2, 0xf0, 0x03, 0xd1, 0x44, 0xa0, 0x90, 0x11, - 0x38, 0x87, 0xc3, 0x75, 0x81, 0x2f, 0xec, 0xbc, 0x90, 0x68, 0x9c, 0xf2, 0x09, 0xf7, 0x17, 0xfc, - 0x0f, 0x0c, 0x61, 0x1d, 0x76, 0x3c, 0x31, 0xf6, 0xdd, 0xe6, 0x76, 0x8b, 0xb4, 0xcb, 0xb4, 0xe8, - 0x89, 0x9e, 0x8b, 0xa7, 0xb0, 0xe7, 0x89, 0x71, 0x86, 0xbf, 0x18, 0x82, 0x15, 0x4f, 0xa4, 0xcc, - 0xf6, 0x05, 0x34, 0x36, 0xbc, 0xe5, 0xef, 0xe2, 0xbc, 0x16, 0xa0, 0x3c, 0xf8, 0xe8, 0xfc, 0x7a, - 0x38, 0xec, 0xe3, 0x0d, 0x60, 0x5c, 0x48, 0x9a, 0x05, 0x36, 0xe2, 0x05, 0xd6, 0x3a, 0xb7, 0x9a, - 0x9b, 0x40, 0x24, 0x65, 0x6f, 0x75, 0x09, 0xde, 0x42, 0x3d, 0x3d, 0x4f, 0xdc, 0x7c, 0x97, 0x6d, - 0x04, 0xfb, 0xab, 0x15, 0xe1, 0x51, 0x3c, 0xff, 0xe9, 0xbf, 0x61, 0x1d, 0xe7, 0xc1, 0x31, 0x69, - 0x9b, 0x74, 0x09, 0xde, 0x41, 0x75, 0x2d, 0x2e, 0x5c, 0xb9, 0xb8, 0xd9, 0xb1, 0x75, 0x92, 0x8b, - 0x67, 0x99, 0x9d, 0xb7, 0x02, 0xd4, 0x92, 0x64, 0x07, 0x5c, 0x2d, 0xfc, 0x09, 0xff, 0x0f, 0xf8, - 0xf7, 0x02, 0xbe, 0x2f, 0x85, 0x6f, 0xd1, 0xe5, 0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0xfc, - 0x01, 0xd1, 0xb4, 0x04, 0x00, 0x00, +func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor7) } + +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, 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/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go index 8eab1a53e2..453786795a 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go @@ -27,7 +27,7 @@ type SSHUploadPackRequest struct { func (m *SSHUploadPackRequest) Reset() { *m = SSHUploadPackRequest{} } func (m *SSHUploadPackRequest) String() string { return proto.CompactTextString(m) } func (*SSHUploadPackRequest) ProtoMessage() {} -func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} } +func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return 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 fileDescriptor6, []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 fileDescriptor6, []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 fileDescriptor6, []int{3} } +func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} } func (m *SSHReceivePackResponse) GetStdout() []byte { if m != nil { @@ -174,171 +174,6 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// 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: "ssh.proto", -} - // Client API for SSHService service type SSHServiceClient interface { @@ -504,28 +339,28 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{ Metadata: "ssh.proto", } -func init() { proto.RegisterFile("ssh.proto", fileDescriptor6) } - -var fileDescriptor6 = []byte{ - // 319 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x53, 0x4d, 0x4f, 0x02, 0x31, - 0x10, 0xb5, 0xf2, 0x91, 0x30, 0x2c, 0x1e, 0x46, 0x24, 0x84, 0xa8, 0x21, 0xeb, 0x85, 0x13, 0x31, - 0xcb, 0x6f, 0x30, 0xc1, 0x9b, 0x69, 0xc3, 0x19, 0x57, 0x76, 0xb2, 0x34, 0x36, 0x74, 0x6d, 0x0b, - 0x81, 0x44, 0x7f, 0x89, 0x7f, 0xc2, 0x9b, 0x7f, 0xcf, 0xa4, 0xbb, 0xe2, 0x82, 0x72, 0xd4, 0xc4, - 0xdb, 0xbe, 0x79, 0x3b, 0xef, 0xbd, 0xe9, 0xb4, 0xd0, 0xb0, 0x76, 0x3e, 0xcc, 0x8c, 0x76, 0x1a, - 0xeb, 0xa9, 0x74, 0xb1, 0xda, 0xf4, 0x02, 0x3b, 0x8f, 0x0d, 0x25, 0x79, 0x35, 0xbc, 0x87, 0xb6, - 0x10, 0xe3, 0x49, 0xa6, 0x74, 0x9c, 0xdc, 0xc5, 0xb3, 0x47, 0x4e, 0x4f, 0x4b, 0xb2, 0x0e, 0x23, - 0x00, 0x43, 0x99, 0xb6, 0xd2, 0x69, 0xb3, 0xe9, 0xb2, 0x3e, 0x1b, 0x34, 0x23, 0x1c, 0xe6, 0x12, - 0x43, 0xbe, 0x65, 0x78, 0xe9, 0x2f, 0x6c, 0x43, 0xcd, 0xba, 0x44, 0x2e, 0xba, 0xc7, 0x7d, 0x36, - 0x08, 0x78, 0x0e, 0xc2, 0x67, 0x38, 0xdb, 0x73, 0xb0, 0x99, 0x5e, 0x58, 0xc2, 0x0e, 0xd4, 0xad, - 0x4b, 0xf4, 0xd2, 0x79, 0xf9, 0x80, 0x17, 0xa8, 0xa8, 0x93, 0x31, 0x85, 0x4e, 0x81, 0x70, 0x04, - 0x4d, 0x5a, 0x4b, 0x37, 0xb5, 0x2e, 0x76, 0x4b, 0xdb, 0xad, 0xec, 0x66, 0xba, 0x59, 0x4b, 0x27, - 0x3c, 0xc3, 0x81, 0xb6, 0xdf, 0xe1, 0x2b, 0xf3, 0xf6, 0x9c, 0x66, 0x24, 0x57, 0xf4, 0x2b, 0x13, - 0xe2, 0x29, 0xd4, 0x52, 0x35, 0x95, 0x89, 0x8f, 0xd4, 0xe0, 0xd5, 0x54, 0xdd, 0x26, 0x78, 0x05, - 0xad, 0x54, 0x4d, 0x4b, 0x0e, 0x55, 0x4f, 0x06, 0xa9, 0xfa, 0xd2, 0x0e, 0x5f, 0xa0, 0xb3, 0x1f, - 0xee, 0x0f, 0x0f, 0x27, 0x7a, 0x63, 0x50, 0x11, 0x62, 0x8c, 0x1c, 0x5a, 0x3b, 0x2b, 0xc2, 0xf3, - 0xcf, 0xc6, 0x9f, 0xee, 0x46, 0xef, 0xe2, 0x00, 0x9b, 0x47, 0x0f, 0x8f, 0x06, 0xec, 0x9a, 0xe1, - 0x04, 0x4e, 0x76, 0x47, 0xc3, 0x72, 0xdb, 0xf7, 0x7d, 0xf4, 0x2e, 0x0f, 0xd1, 0x65, 0xd9, 0xe8, - 0x9d, 0x01, 0x08, 0x31, 0x16, 0x64, 0x56, 0x72, 0x46, 0xff, 0x28, 0xf9, 0x43, 0xdd, 0x3f, 0xb8, - 0xd1, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc3, 0xee, 0x90, 0x93, 0x93, 0x03, 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/vendor/vendor.json b/vendor/vendor.json index 6b3a587542..1bfcf3d33b 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -191,16 +191,20 @@ "revisionTime": "2017-01-30T11:31:45Z" }, { - "checksumSHA1": "zGSXE91ijUmwNJI28+v8PbP3foY=", + "checksumSHA1": "/dGhR40Q/BR9nltIt0Gc607D3vw=", "path": "gitlab.com/gitlab-org/gitaly-proto/go", - "revision": "ad5be24f8de7579c077b837fbb2696a517ae2457", - "revisionTime": "2017-06-21T11:43:20Z" + "revision": "05af69b918d6f0129424a1ce1d9c70765ee8b449", + "revisionTime": "2017-06-26T08:53:21Z", + "version": "=rename-services", + "versionExact": "rename-services" }, { "checksumSHA1": "GkeSZfXVbtAkBZOrswot19GJZqQ=", "path": "gitlab.com/gitlab-org/gitaly-proto/go/helper", - "revision": "ad5be24f8de7579c077b837fbb2696a517ae2457", - "revisionTime": "2017-06-21T11:43:20Z" + "revision": "05af69b918d6f0129424a1ce1d9c70765ee8b449", + "revisionTime": "2017-06-26T08:53:21Z", + "version": "=rename-services", + "versionExact": "rename-services" }, { "checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=", -- GitLab From 915f225c4c450639c9e2a9141ed0e355b18bf0e8 Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Mon, 26 Jun 2017 11:00:34 +0100 Subject: [PATCH 4/7] Tests are using the bridge --- internal/service/commit/testhelper_test.go | 3 ++- internal/service/diff/commit_test.go | 3 ++- internal/service/ref/main_test.go | 3 ++- internal/service/smarthttp/testhelper_test.go | 3 ++- internal/service/ssh/testhelper_test.go | 3 ++- 5 files changed, 10 insertions(+), 5 deletions(-) diff --git a/internal/service/commit/testhelper_test.go b/internal/service/commit/testhelper_test.go index 16f4d62790..6ead8ea2a6 100644 --- a/internal/service/commit/testhelper_test.go +++ b/internal/service/commit/testhelper_test.go @@ -15,6 +15,7 @@ import ( "google.golang.org/grpc/reflection" pb "gitlab.com/gitlab-org/gitaly-proto/go" + "gitlab.com/gitlab-org/gitaly/internal/service/renameadapter" ) const scratchDir = "testdata/scratch" @@ -50,7 +51,7 @@ func runCommitServer(m *testing.M) *grpc.Server { log.WithError(err).Fatal("failed to start server") } - pb.RegisterCommitServer(server, NewServer()) + pb.RegisterCommitServer(server, renameadapter.NewCommitAdapter(NewServer())) reflection.Register(server) go server.Serve(listener) diff --git a/internal/service/diff/commit_test.go b/internal/service/diff/commit_test.go index e8404389ca..5a87cbb3fc 100644 --- a/internal/service/diff/commit_test.go +++ b/internal/service/diff/commit_test.go @@ -10,6 +10,7 @@ import ( pb "gitlab.com/gitlab-org/gitaly-proto/go" "gitlab.com/gitlab-org/gitaly/internal/diff" + "gitlab.com/gitlab-org/gitaly/internal/service/renameadapter" "gitlab.com/gitlab-org/gitaly/internal/testhelper" "golang.org/x/net/context" @@ -650,7 +651,7 @@ func runDiffServer(t *testing.T) *grpc.Server { t.Fatal(err) } - pb.RegisterDiffServer(server, NewServer()) + pb.RegisterDiffServer(server, renameadapter.NewDiffAdapter(NewServer())) reflection.Register(server) go server.Serve(listener) diff --git a/internal/service/ref/main_test.go b/internal/service/ref/main_test.go index f95608d523..0185a63f68 100644 --- a/internal/service/ref/main_test.go +++ b/internal/service/ref/main_test.go @@ -16,6 +16,7 @@ import ( "google.golang.org/grpc/reflection" pb "gitlab.com/gitlab-org/gitaly-proto/go" + "gitlab.com/gitlab-org/gitaly/internal/service/renameadapter" ) const scratchDir = "testdata/scratch" @@ -53,7 +54,7 @@ func runRefServer(t *testing.T) *grpc.Server { } // Use 100 bytes as the maximum message size to test that fragmenting the ref list works correctly - pb.RegisterRefServer(grpcServer, &server{MaxMsgSize: 100}) + pb.RegisterRefServer(grpcServer, renameadapter.NewRefAdapter(&server{MaxMsgSize: 100})) reflection.Register(grpcServer) go grpcServer.Serve(listener) diff --git a/internal/service/smarthttp/testhelper_test.go b/internal/service/smarthttp/testhelper_test.go index 2de6aaa120..e223c4dddc 100644 --- a/internal/service/smarthttp/testhelper_test.go +++ b/internal/service/smarthttp/testhelper_test.go @@ -13,6 +13,7 @@ import ( pb "gitlab.com/gitlab-org/gitaly-proto/go" + "gitlab.com/gitlab-org/gitaly/internal/service/renameadapter" "google.golang.org/grpc" "google.golang.org/grpc/reflection" ) @@ -47,7 +48,7 @@ func runSmartHTTPServer(t *testing.T) *grpc.Server { t.Fatal(err) } - pb.RegisterSmartHTTPServer(server, NewRenameBridge(NewServer())) + pb.RegisterSmartHTTPServer(server, renameadapter.NewSmartHTTPAdapter(NewServer())) reflection.Register(server) go server.Serve(listener) diff --git a/internal/service/ssh/testhelper_test.go b/internal/service/ssh/testhelper_test.go index 015fd1cc28..9363d88aa5 100644 --- a/internal/service/ssh/testhelper_test.go +++ b/internal/service/ssh/testhelper_test.go @@ -11,6 +11,7 @@ import ( pb "gitlab.com/gitlab-org/gitaly-proto/go" + "gitlab.com/gitlab-org/gitaly/internal/service/renameadapter" "google.golang.org/grpc" "google.golang.org/grpc/reflection" ) @@ -41,7 +42,7 @@ func runSSHServer(t *testing.T) *grpc.Server { t.Fatal(err) } - pb.RegisterSSHServer(server, NewRenameBridge(NewServer())) + pb.RegisterSSHServer(server, renameadapter.NewSSHAdapter(NewServer())) reflection.Register(server) go server.Serve(listener) -- GitLab From 7f534803525110e0350718fe94abe0d1a983ad94 Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Mon, 26 Jun 2017 11:04:16 +0100 Subject: [PATCH 5/7] Typo on the notification server registration --- internal/service/register.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/service/register.go b/internal/service/register.go index cbf21d6f76..4557ba3785 100644 --- a/internal/service/register.go +++ b/internal/service/register.go @@ -37,7 +37,7 @@ func RegisterAll(grpcServer *grpc.Server) { pb.RegisterSSHServiceServer(grpcServer, sshService) // Deprecated Services - pb.RegisterNotificationServiceServer(grpcServer, renameadapter.NewNotificationAdapter(notificationsService)) + pb.RegisterNotificationsServer(grpcServer, renameadapter.NewNotificationAdapter(notificationsService)) pb.RegisterRefServer(grpcServer, renameadapter.NewRefAdapter(refService)) pb.RegisterSmartHTTPServer(grpcServer, renameadapter.NewSmartHTTPAdapter(smartHTTPService)) pb.RegisterDiffServer(grpcServer, renameadapter.NewDiffAdapter(diffService)) -- GitLab From 02ea18ec47c50546140ff2617b95ffea2212e82e Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Mon, 26 Jun 2017 11:38:46 +0100 Subject: [PATCH 6/7] Fixed routing problem --- internal/service/renameadapter/smarthttp.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/service/renameadapter/smarthttp.go b/internal/service/renameadapter/smarthttp.go index 0e6b7e015b..ae061f422c 100644 --- a/internal/service/renameadapter/smarthttp.go +++ b/internal/service/renameadapter/smarthttp.go @@ -7,7 +7,7 @@ type smartHTTPAdapter struct { } func (s *smartHTTPAdapter) InfoRefsUploadPack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsUploadPackServer) error { - return s.upstream.InfoRefsReceivePack(in, stream) + return s.upstream.InfoRefsUploadPack(in, stream) } func (s *smartHTTPAdapter) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb.SmartHTTP_InfoRefsReceivePackServer) error { -- GitLab From bfac8cbf685a66023b8707eb1ff296e8d2ee25ae Mon Sep 17 00:00:00 2001 From: Andrew Newdigate Date: Mon, 26 Jun 2017 12:13:01 +0100 Subject: [PATCH 7/7] Switched to v0.10.0 gitaly proto version --- .../gitlab-org/gitaly-proto/go/VERSION | 2 +- .../gitaly-proto/go/deprecated-services.pb.go | 68 +++++++++---------- vendor/vendor.json | 18 ++--- 3 files changed, 44 insertions(+), 44 deletions(-) diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION index ac39a106c4..78bc1abd14 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION @@ -1 +1 @@ -0.9.0 +0.10.0 diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go index b7d43d77e5..cc4c7563f1 100644 --- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go +++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go @@ -1108,39 +1108,39 @@ var _SSH_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor1) } var fileDescriptor1 = []byte{ - // 540 bytes of a gzipped FileDescriptorProto + // 534 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40, - 0x10, 0x80, 0xe5, 0x06, 0x55, 0xca, 0x84, 0x36, 0xb0, 0x15, 0xa2, 0x31, 0x34, 0x69, 0x2b, 0x90, - 0x78, 0x21, 0x42, 0xe1, 0x04, 0x85, 0x02, 0x29, 0x85, 0x10, 0xd9, 0xa9, 0x54, 0x7e, 0x24, 0xb4, - 0xb5, 0x67, 0x9b, 0x15, 0x8e, 0xd7, 0x78, 0xb7, 0x95, 0x7a, 0x03, 0xae, 0xc1, 0x01, 0x78, 0xe5, - 0x36, 0x3c, 0x71, 0x11, 0xe4, 0x9f, 0x25, 0xbb, 0x8e, 0x5d, 0x1e, 0x78, 0xdb, 0xcc, 0x37, 0xf3, - 0xcd, 0x64, 0x7f, 0x0c, 0xbd, 0x10, 0x93, 0x14, 0x03, 0xaa, 0x30, 0x7c, 0x2c, 0x31, 0xbd, 0xe4, - 0x01, 0xca, 0x61, 0x92, 0x0a, 0x25, 0xc8, 0xfa, 0x39, 0x57, 0x34, 0xba, 0x72, 0x6f, 0x06, 0x62, - 0xb1, 0xe0, 0xaa, 0x88, 0xba, 0x10, 0x72, 0xc6, 0xca, 0xf5, 0x56, 0x2c, 0x14, 0x67, 0x3c, 0xa0, - 0x8a, 0x8b, 0xb8, 0x2c, 0x73, 0xdb, 0x29, 0x6a, 0xde, 0x95, 0x0b, 0x9a, 0xaa, 0xb9, 0x52, 0x89, - 0x66, 0x52, 0xce, 0x8b, 0xe5, 0xe8, 0x87, 0x03, 0xeb, 0xcf, 0x73, 0x31, 0xf9, 0x00, 0xb7, 0x8a, - 0xd5, 0x91, 0x3c, 0x88, 0x03, 0x94, 0x4a, 0xa4, 0x64, 0x30, 0x2c, 0xba, 0x0f, 0xab, 0xc4, 0xc3, - 0xaf, 0x17, 0x28, 0x95, 0xbb, 0xdb, 0x9c, 0x20, 0x13, 0x11, 0x4b, 0xdc, 0x6f, 0x7d, 0x5b, 0x73, - 0xc8, 0x2b, 0x68, 0xcf, 0x52, 0xc4, 0x17, 0xb1, 0x4a, 0xaf, 0xc8, 0xb6, 0xae, 0xf9, 0x1b, 0xd2, - 0xb6, 0x5e, 0x0d, 0x31, 0x34, 0x4f, 0x9c, 0xd1, 0x77, 0x07, 0x6e, 0x1c, 0x72, 0xc6, 0xc8, 0x6b, - 0x80, 0xa2, 0x65, 0xfe, 0xab, 0x67, 0x8f, 0x91, 0xc5, 0xb4, 0xd3, 0xad, 0x43, 0x96, 0x94, 0xbc, - 0x85, 0x4e, 0x09, 0x31, 0x52, 0x94, 0x54, 0x2b, 0xb2, 0xa0, 0xb6, 0xdd, 0xab, 0x65, 0xf6, 0x8c, - 0x9f, 0x60, 0x63, 0x62, 0x9e, 0x08, 0x39, 0x86, 0xce, 0x54, 0x48, 0xe5, 0x61, 0x80, 0xfc, 0x12, - 0x97, 0x7e, 0x23, 0xb8, 0xe2, 0xb7, 0x98, 0xe1, 0x1f, 0xfd, 0x6a, 0x41, 0xcb, 0x43, 0x46, 0x38, - 0xdc, 0x79, 0xc9, 0xe3, 0xf0, 0x10, 0x19, 0xbd, 0x88, 0xd4, 0xb3, 0x94, 0xc6, 0xc1, 0x7c, 0x42, - 0x17, 0x48, 0x1e, 0x68, 0x45, 0x2d, 0xd6, 0x8d, 0x1e, 0xfe, 0x23, 0xcb, 0x3c, 0xbd, 0x33, 0x20, - 0x59, 0xd6, 0x41, 0x14, 0x2d, 0x33, 0x24, 0xd9, 0x33, 0x0d, 0x36, 0xd3, 0x4d, 0xf6, 0xaf, 0x4b, - 0xb1, 0xcf, 0xe0, 0x3d, 0x74, 0xcb, 0xa4, 0x19, 0x3d, 0x2f, 0x1a, 0xf4, 0x2b, 0xd5, 0x1a, 0x68, - 0xfb, 0xa0, 0x91, 0xdb, 0xea, 0x63, 0xe8, 0x64, 0x19, 0x1e, 0xb2, 0x7c, 0x7f, 0x5c, 0xb3, 0xac, - 0x0c, 0xae, 0x6c, 0xbf, 0xc5, 0xcc, 0xbd, 0xf8, 0x0c, 0xb7, 0x33, 0xf6, 0x46, 0x04, 0xb4, 0xfc, - 0x3b, 0x28, 0xc9, 0xae, 0x59, 0x66, 0x21, 0x2d, 0xde, 0xbb, 0x26, 0xc3, 0xbe, 0x3d, 0xbf, 0xd7, - 0xa0, 0xed, 0x67, 0x0f, 0x76, 0x3c, 0x9b, 0x4d, 0xc9, 0x04, 0xc8, 0x51, 0xcc, 0x84, 0x87, 0x4c, - 0x9e, 0x24, 0x91, 0xa0, 0xe1, 0x94, 0x06, 0x5f, 0xc8, 0x5d, 0x6d, 0xd3, 0x4c, 0xb7, 0xd9, 0x5e, - 0x05, 0xf6, 0x5e, 0xbc, 0x83, 0xad, 0x25, 0xca, 0x6f, 0xd7, 0x7f, 0x0a, 0x4f, 0x61, 0x33, 0xbb, - 0xaa, 0xc6, 0x70, 0x3b, 0xe6, 0x15, 0x5e, 0xc6, 0xb5, 0xb1, 0xdf, 0x84, 0x0d, 0xef, 0xa3, 0xcc, - 0xfc, 0x11, 0xba, 0xc6, 0x23, 0xc8, 0xd5, 0xfd, 0x9a, 0xd7, 0x61, 0xba, 0x07, 0x8d, 0xbc, 0x22, - 0x1f, 0xfd, 0x74, 0xa0, 0xe5, 0xfb, 0x63, 0x72, 0x02, 0x1b, 0xbe, 0x3f, 0x36, 0xa6, 0xbf, 0xaf, - 0x15, 0x56, 0x58, 0x37, 0xd8, 0x69, 0xa0, 0xd5, 0xd9, 0x4f, 0x61, 0xd3, 0xf7, 0xc7, 0xe6, 0xe8, - 0x66, 0x65, 0xcd, 0xe4, 0xfd, 0x26, 0x5c, 0x31, 0x9f, 0xad, 0xe7, 0xdf, 0xed, 0xa7, 0x7f, 0x02, - 0x00, 0x00, 0xff, 0xff, 0xd4, 0x6c, 0x53, 0x6f, 0x32, 0x06, 0x00, 0x00, + 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/vendor/vendor.json b/vendor/vendor.json index 1bfcf3d33b..5f421c97d3 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -191,20 +191,20 @@ "revisionTime": "2017-01-30T11:31:45Z" }, { - "checksumSHA1": "/dGhR40Q/BR9nltIt0Gc607D3vw=", + "checksumSHA1": "FLmxR5JvjKDRngzvCIQtBmgsssA=", "path": "gitlab.com/gitlab-org/gitaly-proto/go", - "revision": "05af69b918d6f0129424a1ce1d9c70765ee8b449", - "revisionTime": "2017-06-26T08:53:21Z", - "version": "=rename-services", - "versionExact": "rename-services" + "revision": "caef1404f9c28e1a2e12a79bb313ee0a89addac4", + "revisionTime": "2017-06-26T11:11:20Z", + "version": "=v0.10.0", + "versionExact": "v0.10.0" }, { "checksumSHA1": "GkeSZfXVbtAkBZOrswot19GJZqQ=", "path": "gitlab.com/gitlab-org/gitaly-proto/go/helper", - "revision": "05af69b918d6f0129424a1ce1d9c70765ee8b449", - "revisionTime": "2017-06-26T08:53:21Z", - "version": "=rename-services", - "versionExact": "rename-services" + "revision": "caef1404f9c28e1a2e12a79bb313ee0a89addac4", + "revisionTime": "2017-06-26T11:11:20Z", + "version": "=v0.10.0", + "versionExact": "v0.10.0" }, { "checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=", -- GitLab