Source file src/golang.conradwood.net/apis/getestservice/getestservice.pb.go

Documentation: golang.conradwood.net/apis/getestservice

     1  // Code generated by protoc-gen-go.
     2  // source: golang.conradwood.net/apis/getestservice/getestservice.proto
     3  // DO NOT EDIT!
     4  
     5  /*
     6  Package getestservice is a generated protocol buffer package.
     7  
     8  It is generated from these files:
     9  	golang.conradwood.net/apis/getestservice/getestservice.proto
    10  
    11  It has these top-level messages:
    12  	Call
    13  	PingRequest
    14  	PingResponse
    15  	FindServiceRequest
    16  	FindServiceResponse
    17  	UserByLoginRequest
    18  	UserByTokenRequest
    19  	AuthResponse
    20  	Target
    21  	SerialisedContext
    22  	RequiredContext
    23  	SleepRequest
    24  	TriggerRPCRequest
    25  	Chain
    26  	Count
    27  */
    28  package getestservice
    29  
    30  import proto "github.com/golang/protobuf/proto"
    31  import fmt "fmt"
    32  import math "math"
    33  import auth "golang.conradwood.net/apis/auth"
    34  import common "golang.conradwood.net/apis/common"
    35  
    36  import (
    37  	context "golang.org/x/net/context"
    38  	grpc "google.golang.org/grpc"
    39  )
    40  
    41  // Reference imports to suppress errors if they are not otherwise used.
    42  var _ = proto.Marshal
    43  var _ = fmt.Errorf
    44  var _ = math.Inf
    45  
    46  // This is a compile-time assertion to ensure that this generated file
    47  // is compatible with the proto package it is being compiled against.
    48  // A compilation error at this line likely means your copy of the
    49  // proto package needs to be updated.
    50  const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
    51  
    52  type Call struct {
    53  	Position  int32  `protobuf:"varint,1,opt,name=Position" json:"Position,omitempty"`
    54  	UserID    string `protobuf:"bytes,2,opt,name=UserID" json:"UserID,omitempty"`
    55  	ServiceID string `protobuf:"bytes,3,opt,name=ServiceID" json:"ServiceID,omitempty"`
    56  	RequestID string `protobuf:"bytes,4,opt,name=RequestID" json:"RequestID,omitempty"`
    57  }
    58  
    59  func (m *Call) Reset()                    { *m = Call{} }
    60  func (m *Call) String() string            { return proto.CompactTextString(m) }
    61  func (*Call) ProtoMessage()               {}
    62  func (*Call) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
    63  
    64  func (m *Call) GetPosition() int32 {
    65  	if m != nil {
    66  		return m.Position
    67  	}
    68  	return 0
    69  }
    70  
    71  func (m *Call) GetUserID() string {
    72  	if m != nil {
    73  		return m.UserID
    74  	}
    75  	return ""
    76  }
    77  
    78  func (m *Call) GetServiceID() string {
    79  	if m != nil {
    80  		return m.ServiceID
    81  	}
    82  	return ""
    83  }
    84  
    85  func (m *Call) GetRequestID() string {
    86  	if m != nil {
    87  		return m.RequestID
    88  	}
    89  	return ""
    90  }
    91  
    92  type PingRequest struct {
    93  	SequenceNumber uint32 `protobuf:"varint,1,opt,name=SequenceNumber" json:"SequenceNumber,omitempty"`
    94  	Payload        string `protobuf:"bytes,2,opt,name=Payload" json:"Payload,omitempty"`
    95  	TTL            uint32 `protobuf:"varint,3,opt,name=TTL" json:"TTL,omitempty"`
    96  	PleaseFail     bool   `protobuf:"varint,4,opt,name=PleaseFail" json:"PleaseFail,omitempty"`
    97  }
    98  
    99  func (m *PingRequest) Reset()                    { *m = PingRequest{} }
   100  func (m *PingRequest) String() string            { return proto.CompactTextString(m) }
   101  func (*PingRequest) ProtoMessage()               {}
   102  func (*PingRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
   103  
   104  func (m *PingRequest) GetSequenceNumber() uint32 {
   105  	if m != nil {
   106  		return m.SequenceNumber
   107  	}
   108  	return 0
   109  }
   110  
   111  func (m *PingRequest) GetPayload() string {
   112  	if m != nil {
   113  		return m.Payload
   114  	}
   115  	return ""
   116  }
   117  
   118  func (m *PingRequest) GetTTL() uint32 {
   119  	if m != nil {
   120  		return m.TTL
   121  	}
   122  	return 0
   123  }
   124  
   125  func (m *PingRequest) GetPleaseFail() bool {
   126  	if m != nil {
   127  		return m.PleaseFail
   128  	}
   129  	return false
   130  }
   131  
   132  type PingResponse struct {
   133  	Response   *PingRequest      `protobuf:"bytes,1,opt,name=Response" json:"Response,omitempty"`
   134  	ServerTags map[string]string `protobuf:"bytes,2,rep,name=ServerTags" json:"ServerTags,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
   135  }
   136  
   137  func (m *PingResponse) Reset()                    { *m = PingResponse{} }
   138  func (m *PingResponse) String() string            { return proto.CompactTextString(m) }
   139  func (*PingResponse) ProtoMessage()               {}
   140  func (*PingResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
   141  
   142  func (m *PingResponse) GetResponse() *PingRequest {
   143  	if m != nil {
   144  		return m.Response
   145  	}
   146  	return nil
   147  }
   148  
   149  func (m *PingResponse) GetServerTags() map[string]string {
   150  	if m != nil {
   151  		return m.ServerTags
   152  	}
   153  	return nil
   154  }
   155  
   156  // for internal testing only
   157  type FindServiceRequest struct {
   158  	Name string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"`
   159  }
   160  
   161  func (m *FindServiceRequest) Reset()                    { *m = FindServiceRequest{} }
   162  func (m *FindServiceRequest) String() string            { return proto.CompactTextString(m) }
   163  func (*FindServiceRequest) ProtoMessage()               {}
   164  func (*FindServiceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
   165  
   166  func (m *FindServiceRequest) GetName() string {
   167  	if m != nil {
   168  		return m.Name
   169  	}
   170  	return ""
   171  }
   172  
   173  // for internal testing only
   174  type FindServiceResponse struct {
   175  	Targets []*Target `protobuf:"bytes,1,rep,name=Targets" json:"Targets,omitempty"`
   176  }
   177  
   178  func (m *FindServiceResponse) Reset()                    { *m = FindServiceResponse{} }
   179  func (m *FindServiceResponse) String() string            { return proto.CompactTextString(m) }
   180  func (*FindServiceResponse) ProtoMessage()               {}
   181  func (*FindServiceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
   182  
   183  func (m *FindServiceResponse) GetTargets() []*Target {
   184  	if m != nil {
   185  		return m.Targets
   186  	}
   187  	return nil
   188  }
   189  
   190  // for internal testing only
   191  type UserByLoginRequest struct {
   192  	Username string `protobuf:"bytes,1,opt,name=Username" json:"Username,omitempty"`
   193  	Password string `protobuf:"bytes,2,opt,name=Password" json:"Password,omitempty"`
   194  }
   195  
   196  func (m *UserByLoginRequest) Reset()                    { *m = UserByLoginRequest{} }
   197  func (m *UserByLoginRequest) String() string            { return proto.CompactTextString(m) }
   198  func (*UserByLoginRequest) ProtoMessage()               {}
   199  func (*UserByLoginRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
   200  
   201  func (m *UserByLoginRequest) GetUsername() string {
   202  	if m != nil {
   203  		return m.Username
   204  	}
   205  	return ""
   206  }
   207  
   208  func (m *UserByLoginRequest) GetPassword() string {
   209  	if m != nil {
   210  		return m.Password
   211  	}
   212  	return ""
   213  }
   214  
   215  // for internal testing only
   216  type UserByTokenRequest struct {
   217  	Token string `protobuf:"bytes,1,opt,name=Token" json:"Token,omitempty"`
   218  }
   219  
   220  func (m *UserByTokenRequest) Reset()                    { *m = UserByTokenRequest{} }
   221  func (m *UserByTokenRequest) String() string            { return proto.CompactTextString(m) }
   222  func (*UserByTokenRequest) ProtoMessage()               {}
   223  func (*UserByTokenRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
   224  
   225  func (m *UserByTokenRequest) GetToken() string {
   226  	if m != nil {
   227  		return m.Token
   228  	}
   229  	return ""
   230  }
   231  
   232  // for internal testing only
   233  type AuthResponse struct {
   234  	Valid bool       `protobuf:"varint,1,opt,name=Valid" json:"Valid,omitempty"`
   235  	User  *auth.User `protobuf:"bytes,2,opt,name=User" json:"User,omitempty"`
   236  }
   237  
   238  func (m *AuthResponse) Reset()                    { *m = AuthResponse{} }
   239  func (m *AuthResponse) String() string            { return proto.CompactTextString(m) }
   240  func (*AuthResponse) ProtoMessage()               {}
   241  func (*AuthResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
   242  
   243  func (m *AuthResponse) GetValid() bool {
   244  	if m != nil {
   245  		return m.Valid
   246  	}
   247  	return false
   248  }
   249  
   250  func (m *AuthResponse) GetUser() *auth.User {
   251  	if m != nil {
   252  		return m.User
   253  	}
   254  	return nil
   255  }
   256  
   257  // for internal testing only
   258  type Target struct {
   259  	IP   string `protobuf:"bytes,1,opt,name=IP" json:"IP,omitempty"`
   260  	Port uint32 `protobuf:"varint,2,opt,name=Port" json:"Port,omitempty"`
   261  }
   262  
   263  func (m *Target) Reset()                    { *m = Target{} }
   264  func (m *Target) String() string            { return proto.CompactTextString(m) }
   265  func (*Target) ProtoMessage()               {}
   266  func (*Target) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
   267  
   268  func (m *Target) GetIP() string {
   269  	if m != nil {
   270  		return m.IP
   271  	}
   272  	return ""
   273  }
   274  
   275  func (m *Target) GetPort() uint32 {
   276  	if m != nil {
   277  		return m.Port
   278  	}
   279  	return 0
   280  }
   281  
   282  type SerialisedContext struct {
   283  	Data    []byte           `protobuf:"bytes,1,opt,name=Data,proto3" json:"Data,omitempty"`
   284  	SData   string           `protobuf:"bytes,2,opt,name=SData" json:"SData,omitempty"`
   285  	User    *auth.SignedUser `protobuf:"bytes,3,opt,name=User" json:"User,omitempty"`
   286  	Service *auth.SignedUser `protobuf:"bytes,4,opt,name=Service" json:"Service,omitempty"`
   287  }
   288  
   289  func (m *SerialisedContext) Reset()                    { *m = SerialisedContext{} }
   290  func (m *SerialisedContext) String() string            { return proto.CompactTextString(m) }
   291  func (*SerialisedContext) ProtoMessage()               {}
   292  func (*SerialisedContext) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
   293  
   294  func (m *SerialisedContext) GetData() []byte {
   295  	if m != nil {
   296  		return m.Data
   297  	}
   298  	return nil
   299  }
   300  
   301  func (m *SerialisedContext) GetSData() string {
   302  	if m != nil {
   303  		return m.SData
   304  	}
   305  	return ""
   306  }
   307  
   308  func (m *SerialisedContext) GetUser() *auth.SignedUser {
   309  	if m != nil {
   310  		return m.User
   311  	}
   312  	return nil
   313  }
   314  
   315  func (m *SerialisedContext) GetService() *auth.SignedUser {
   316  	if m != nil {
   317  		return m.Service
   318  	}
   319  	return nil
   320  }
   321  
   322  type RequiredContext struct {
   323  	User    *auth.SignedUser `protobuf:"bytes,3,opt,name=User" json:"User,omitempty"`
   324  	Service *auth.SignedUser `protobuf:"bytes,4,opt,name=Service" json:"Service,omitempty"`
   325  }
   326  
   327  func (m *RequiredContext) Reset()                    { *m = RequiredContext{} }
   328  func (m *RequiredContext) String() string            { return proto.CompactTextString(m) }
   329  func (*RequiredContext) ProtoMessage()               {}
   330  func (*RequiredContext) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
   331  
   332  func (m *RequiredContext) GetUser() *auth.SignedUser {
   333  	if m != nil {
   334  		return m.User
   335  	}
   336  	return nil
   337  }
   338  
   339  func (m *RequiredContext) GetService() *auth.SignedUser {
   340  	if m != nil {
   341  		return m.Service
   342  	}
   343  	return nil
   344  }
   345  
   346  type SleepRequest struct {
   347  	Seconds float64 `protobuf:"fixed64,1,opt,name=Seconds" json:"Seconds,omitempty"`
   348  }
   349  
   350  func (m *SleepRequest) Reset()                    { *m = SleepRequest{} }
   351  func (m *SleepRequest) String() string            { return proto.CompactTextString(m) }
   352  func (*SleepRequest) ProtoMessage()               {}
   353  func (*SleepRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
   354  
   355  func (m *SleepRequest) GetSeconds() float64 {
   356  	if m != nil {
   357  		return m.Seconds
   358  	}
   359  	return 0
   360  }
   361  
   362  type TriggerRPCRequest struct {
   363  	Action  uint32 `protobuf:"varint,1,opt,name=Action" json:"Action,omitempty"`
   364  	Counter uint32 `protobuf:"varint,2,opt,name=Counter" json:"Counter,omitempty"`
   365  }
   366  
   367  func (m *TriggerRPCRequest) Reset()                    { *m = TriggerRPCRequest{} }
   368  func (m *TriggerRPCRequest) String() string            { return proto.CompactTextString(m) }
   369  func (*TriggerRPCRequest) ProtoMessage()               {}
   370  func (*TriggerRPCRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
   371  
   372  func (m *TriggerRPCRequest) GetAction() uint32 {
   373  	if m != nil {
   374  		return m.Action
   375  	}
   376  	return 0
   377  }
   378  
   379  func (m *TriggerRPCRequest) GetCounter() uint32 {
   380  	if m != nil {
   381  		return m.Counter
   382  	}
   383  	return 0
   384  }
   385  
   386  type Chain struct {
   387  	Position int32   `protobuf:"varint,1,opt,name=Position" json:"Position,omitempty"`
   388  	Calls    []*Call `protobuf:"bytes,2,rep,name=Calls" json:"Calls,omitempty"`
   389  }
   390  
   391  func (m *Chain) Reset()                    { *m = Chain{} }
   392  func (m *Chain) String() string            { return proto.CompactTextString(m) }
   393  func (*Chain) ProtoMessage()               {}
   394  func (*Chain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
   395  
   396  func (m *Chain) GetPosition() int32 {
   397  	if m != nil {
   398  		return m.Position
   399  	}
   400  	return 0
   401  }
   402  
   403  func (m *Chain) GetCalls() []*Call {
   404  	if m != nil {
   405  		return m.Calls
   406  	}
   407  	return nil
   408  }
   409  
   410  type Count struct {
   411  	Count uint32 `protobuf:"varint,1,opt,name=Count" json:"Count,omitempty"`
   412  }
   413  
   414  func (m *Count) Reset()                    { *m = Count{} }
   415  func (m *Count) String() string            { return proto.CompactTextString(m) }
   416  func (*Count) ProtoMessage()               {}
   417  func (*Count) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
   418  
   419  func (m *Count) GetCount() uint32 {
   420  	if m != nil {
   421  		return m.Count
   422  	}
   423  	return 0
   424  }
   425  
   426  func init() {
   427  	proto.RegisterType((*Call)(nil), "getestservice.Call")
   428  	proto.RegisterType((*PingRequest)(nil), "getestservice.PingRequest")
   429  	proto.RegisterType((*PingResponse)(nil), "getestservice.PingResponse")
   430  	proto.RegisterType((*FindServiceRequest)(nil), "getestservice.FindServiceRequest")
   431  	proto.RegisterType((*FindServiceResponse)(nil), "getestservice.FindServiceResponse")
   432  	proto.RegisterType((*UserByLoginRequest)(nil), "getestservice.UserByLoginRequest")
   433  	proto.RegisterType((*UserByTokenRequest)(nil), "getestservice.UserByTokenRequest")
   434  	proto.RegisterType((*AuthResponse)(nil), "getestservice.AuthResponse")
   435  	proto.RegisterType((*Target)(nil), "getestservice.Target")
   436  	proto.RegisterType((*SerialisedContext)(nil), "getestservice.SerialisedContext")
   437  	proto.RegisterType((*RequiredContext)(nil), "getestservice.RequiredContext")
   438  	proto.RegisterType((*SleepRequest)(nil), "getestservice.SleepRequest")
   439  	proto.RegisterType((*TriggerRPCRequest)(nil), "getestservice.TriggerRPCRequest")
   440  	proto.RegisterType((*Chain)(nil), "getestservice.Chain")
   441  	proto.RegisterType((*Count)(nil), "getestservice.Count")
   442  }
   443  
   444  // Reference imports to suppress errors if they are not otherwise used.
   445  var _ context.Context
   446  var _ grpc.ClientConn
   447  
   448  // This is a compile-time assertion to ensure that this generated file
   449  // is compatible with the grpc package it is being compiled against.
   450  const _ = grpc.SupportPackageIsVersion4
   451  
   452  // Client API for EchoService service
   453  
   454  type EchoServiceClient interface {
   455  	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
   456  }
   457  
   458  type echoServiceClient struct {
   459  	cc *grpc.ClientConn
   460  }
   461  
   462  func NewEchoServiceClient(cc *grpc.ClientConn) EchoServiceClient {
   463  	return &echoServiceClient{cc}
   464  }
   465  
   466  func (c *echoServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
   467  	out := new(PingResponse)
   468  	err := grpc.Invoke(ctx, "/getestservice.EchoService/Ping", in, out, c.cc, opts...)
   469  	if err != nil {
   470  		return nil, err
   471  	}
   472  	return out, nil
   473  }
   474  
   475  // Server API for EchoService service
   476  
   477  type EchoServiceServer interface {
   478  	Ping(context.Context, *PingRequest) (*PingResponse, error)
   479  }
   480  
   481  func RegisterEchoServiceServer(s *grpc.Server, srv EchoServiceServer) {
   482  	s.RegisterService(&_EchoService_serviceDesc, srv)
   483  }
   484  
   485  func _EchoService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   486  	in := new(PingRequest)
   487  	if err := dec(in); err != nil {
   488  		return nil, err
   489  	}
   490  	if interceptor == nil {
   491  		return srv.(EchoServiceServer).Ping(ctx, in)
   492  	}
   493  	info := &grpc.UnaryServerInfo{
   494  		Server:     srv,
   495  		FullMethod: "/getestservice.EchoService/Ping",
   496  	}
   497  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   498  		return srv.(EchoServiceServer).Ping(ctx, req.(*PingRequest))
   499  	}
   500  	return interceptor(ctx, in, info, handler)
   501  }
   502  
   503  var _EchoService_serviceDesc = grpc.ServiceDesc{
   504  	ServiceName: "getestservice.EchoService",
   505  	HandlerType: (*EchoServiceServer)(nil),
   506  	Methods: []grpc.MethodDesc{
   507  		{
   508  			MethodName: "Ping",
   509  			Handler:    _EchoService_Ping_Handler,
   510  		},
   511  	},
   512  	Streams:  []grpc.StreamDesc{},
   513  	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
   514  }
   515  
   516  // Client API for EchoStreamService service
   517  
   518  type EchoStreamServiceClient interface {
   519  	SendToServer(ctx context.Context, opts ...grpc.CallOption) (EchoStreamService_SendToServerClient, error)
   520  }
   521  
   522  type echoStreamServiceClient struct {
   523  	cc *grpc.ClientConn
   524  }
   525  
   526  func NewEchoStreamServiceClient(cc *grpc.ClientConn) EchoStreamServiceClient {
   527  	return &echoStreamServiceClient{cc}
   528  }
   529  
   530  func (c *echoStreamServiceClient) SendToServer(ctx context.Context, opts ...grpc.CallOption) (EchoStreamService_SendToServerClient, error) {
   531  	stream, err := grpc.NewClientStream(ctx, &_EchoStreamService_serviceDesc.Streams[0], c.cc, "/getestservice.EchoStreamService/SendToServer", opts...)
   532  	if err != nil {
   533  		return nil, err
   534  	}
   535  	x := &echoStreamServiceSendToServerClient{stream}
   536  	return x, nil
   537  }
   538  
   539  type EchoStreamService_SendToServerClient interface {
   540  	Send(*PingRequest) error
   541  	CloseAndRecv() (*PingResponse, error)
   542  	grpc.ClientStream
   543  }
   544  
   545  type echoStreamServiceSendToServerClient struct {
   546  	grpc.ClientStream
   547  }
   548  
   549  func (x *echoStreamServiceSendToServerClient) Send(m *PingRequest) error {
   550  	return x.ClientStream.SendMsg(m)
   551  }
   552  
   553  func (x *echoStreamServiceSendToServerClient) CloseAndRecv() (*PingResponse, error) {
   554  	if err := x.ClientStream.CloseSend(); err != nil {
   555  		return nil, err
   556  	}
   557  	m := new(PingResponse)
   558  	if err := x.ClientStream.RecvMsg(m); err != nil {
   559  		return nil, err
   560  	}
   561  	return m, nil
   562  }
   563  
   564  // Server API for EchoStreamService service
   565  
   566  type EchoStreamServiceServer interface {
   567  	SendToServer(EchoStreamService_SendToServerServer) error
   568  }
   569  
   570  func RegisterEchoStreamServiceServer(s *grpc.Server, srv EchoStreamServiceServer) {
   571  	s.RegisterService(&_EchoStreamService_serviceDesc, srv)
   572  }
   573  
   574  func _EchoStreamService_SendToServer_Handler(srv interface{}, stream grpc.ServerStream) error {
   575  	return srv.(EchoStreamServiceServer).SendToServer(&echoStreamServiceSendToServerServer{stream})
   576  }
   577  
   578  type EchoStreamService_SendToServerServer interface {
   579  	SendAndClose(*PingResponse) error
   580  	Recv() (*PingRequest, error)
   581  	grpc.ServerStream
   582  }
   583  
   584  type echoStreamServiceSendToServerServer struct {
   585  	grpc.ServerStream
   586  }
   587  
   588  func (x *echoStreamServiceSendToServerServer) SendAndClose(m *PingResponse) error {
   589  	return x.ServerStream.SendMsg(m)
   590  }
   591  
   592  func (x *echoStreamServiceSendToServerServer) Recv() (*PingRequest, error) {
   593  	m := new(PingRequest)
   594  	if err := x.ServerStream.RecvMsg(m); err != nil {
   595  		return nil, err
   596  	}
   597  	return m, nil
   598  }
   599  
   600  var _EchoStreamService_serviceDesc = grpc.ServiceDesc{
   601  	ServiceName: "getestservice.EchoStreamService",
   602  	HandlerType: (*EchoStreamServiceServer)(nil),
   603  	Methods:     []grpc.MethodDesc{},
   604  	Streams: []grpc.StreamDesc{
   605  		{
   606  			StreamName:    "SendToServer",
   607  			Handler:       _EchoStreamService_SendToServer_Handler,
   608  			ClientStreams: true,
   609  		},
   610  	},
   611  	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
   612  }
   613  
   614  // Client API for EasyOps service
   615  
   616  type EasyOpsClient interface {
   617  	FindService(ctx context.Context, in *FindServiceRequest, opts ...grpc.CallOption) (*FindServiceResponse, error)
   618  	UserByLogin(ctx context.Context, in *UserByLoginRequest, opts ...grpc.CallOption) (*AuthResponse, error)
   619  	UserByToken(ctx context.Context, in *UserByTokenRequest, opts ...grpc.CallOption) (*AuthResponse, error)
   620  }
   621  
   622  type easyOpsClient struct {
   623  	cc *grpc.ClientConn
   624  }
   625  
   626  func NewEasyOpsClient(cc *grpc.ClientConn) EasyOpsClient {
   627  	return &easyOpsClient{cc}
   628  }
   629  
   630  func (c *easyOpsClient) FindService(ctx context.Context, in *FindServiceRequest, opts ...grpc.CallOption) (*FindServiceResponse, error) {
   631  	out := new(FindServiceResponse)
   632  	err := grpc.Invoke(ctx, "/getestservice.EasyOps/FindService", in, out, c.cc, opts...)
   633  	if err != nil {
   634  		return nil, err
   635  	}
   636  	return out, nil
   637  }
   638  
   639  func (c *easyOpsClient) UserByLogin(ctx context.Context, in *UserByLoginRequest, opts ...grpc.CallOption) (*AuthResponse, error) {
   640  	out := new(AuthResponse)
   641  	err := grpc.Invoke(ctx, "/getestservice.EasyOps/UserByLogin", in, out, c.cc, opts...)
   642  	if err != nil {
   643  		return nil, err
   644  	}
   645  	return out, nil
   646  }
   647  
   648  func (c *easyOpsClient) UserByToken(ctx context.Context, in *UserByTokenRequest, opts ...grpc.CallOption) (*AuthResponse, error) {
   649  	out := new(AuthResponse)
   650  	err := grpc.Invoke(ctx, "/getestservice.EasyOps/UserByToken", in, out, c.cc, opts...)
   651  	if err != nil {
   652  		return nil, err
   653  	}
   654  	return out, nil
   655  }
   656  
   657  // Server API for EasyOps service
   658  
   659  type EasyOpsServer interface {
   660  	FindService(context.Context, *FindServiceRequest) (*FindServiceResponse, error)
   661  	UserByLogin(context.Context, *UserByLoginRequest) (*AuthResponse, error)
   662  	UserByToken(context.Context, *UserByTokenRequest) (*AuthResponse, error)
   663  }
   664  
   665  func RegisterEasyOpsServer(s *grpc.Server, srv EasyOpsServer) {
   666  	s.RegisterService(&_EasyOps_serviceDesc, srv)
   667  }
   668  
   669  func _EasyOps_FindService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   670  	in := new(FindServiceRequest)
   671  	if err := dec(in); err != nil {
   672  		return nil, err
   673  	}
   674  	if interceptor == nil {
   675  		return srv.(EasyOpsServer).FindService(ctx, in)
   676  	}
   677  	info := &grpc.UnaryServerInfo{
   678  		Server:     srv,
   679  		FullMethod: "/getestservice.EasyOps/FindService",
   680  	}
   681  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   682  		return srv.(EasyOpsServer).FindService(ctx, req.(*FindServiceRequest))
   683  	}
   684  	return interceptor(ctx, in, info, handler)
   685  }
   686  
   687  func _EasyOps_UserByLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   688  	in := new(UserByLoginRequest)
   689  	if err := dec(in); err != nil {
   690  		return nil, err
   691  	}
   692  	if interceptor == nil {
   693  		return srv.(EasyOpsServer).UserByLogin(ctx, in)
   694  	}
   695  	info := &grpc.UnaryServerInfo{
   696  		Server:     srv,
   697  		FullMethod: "/getestservice.EasyOps/UserByLogin",
   698  	}
   699  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   700  		return srv.(EasyOpsServer).UserByLogin(ctx, req.(*UserByLoginRequest))
   701  	}
   702  	return interceptor(ctx, in, info, handler)
   703  }
   704  
   705  func _EasyOps_UserByToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   706  	in := new(UserByTokenRequest)
   707  	if err := dec(in); err != nil {
   708  		return nil, err
   709  	}
   710  	if interceptor == nil {
   711  		return srv.(EasyOpsServer).UserByToken(ctx, in)
   712  	}
   713  	info := &grpc.UnaryServerInfo{
   714  		Server:     srv,
   715  		FullMethod: "/getestservice.EasyOps/UserByToken",
   716  	}
   717  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   718  		return srv.(EasyOpsServer).UserByToken(ctx, req.(*UserByTokenRequest))
   719  	}
   720  	return interceptor(ctx, in, info, handler)
   721  }
   722  
   723  var _EasyOps_serviceDesc = grpc.ServiceDesc{
   724  	ServiceName: "getestservice.EasyOps",
   725  	HandlerType: (*EasyOpsServer)(nil),
   726  	Methods: []grpc.MethodDesc{
   727  		{
   728  			MethodName: "FindService",
   729  			Handler:    _EasyOps_FindService_Handler,
   730  		},
   731  		{
   732  			MethodName: "UserByLogin",
   733  			Handler:    _EasyOps_UserByLogin_Handler,
   734  		},
   735  		{
   736  			MethodName: "UserByToken",
   737  			Handler:    _EasyOps_UserByToken_Handler,
   738  		},
   739  	},
   740  	Streams:  []grpc.StreamDesc{},
   741  	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
   742  }
   743  
   744  // Client API for EasyOpsTest service
   745  
   746  type EasyOpsTestClient interface {
   747  	CheckSerialisation(ctx context.Context, in *Count, opts ...grpc.CallOption) (*common.Void, error)
   748  	Ping(ctx context.Context, in *Chain, opts ...grpc.CallOption) (*Chain, error)
   749  	// does exactly nothing
   750  	SimplePing(ctx context.Context, in *common.Void, opts ...grpc.CallOption) (*common.Void, error)
   751  }
   752  
   753  type easyOpsTestClient struct {
   754  	cc *grpc.ClientConn
   755  }
   756  
   757  func NewEasyOpsTestClient(cc *grpc.ClientConn) EasyOpsTestClient {
   758  	return &easyOpsTestClient{cc}
   759  }
   760  
   761  func (c *easyOpsTestClient) CheckSerialisation(ctx context.Context, in *Count, opts ...grpc.CallOption) (*common.Void, error) {
   762  	out := new(common.Void)
   763  	err := grpc.Invoke(ctx, "/getestservice.EasyOpsTest/CheckSerialisation", in, out, c.cc, opts...)
   764  	if err != nil {
   765  		return nil, err
   766  	}
   767  	return out, nil
   768  }
   769  
   770  func (c *easyOpsTestClient) Ping(ctx context.Context, in *Chain, opts ...grpc.CallOption) (*Chain, error) {
   771  	out := new(Chain)
   772  	err := grpc.Invoke(ctx, "/getestservice.EasyOpsTest/Ping", in, out, c.cc, opts...)
   773  	if err != nil {
   774  		return nil, err
   775  	}
   776  	return out, nil
   777  }
   778  
   779  func (c *easyOpsTestClient) SimplePing(ctx context.Context, in *common.Void, opts ...grpc.CallOption) (*common.Void, error) {
   780  	out := new(common.Void)
   781  	err := grpc.Invoke(ctx, "/getestservice.EasyOpsTest/SimplePing", in, out, c.cc, opts...)
   782  	if err != nil {
   783  		return nil, err
   784  	}
   785  	return out, nil
   786  }
   787  
   788  // Server API for EasyOpsTest service
   789  
   790  type EasyOpsTestServer interface {
   791  	CheckSerialisation(context.Context, *Count) (*common.Void, error)
   792  	Ping(context.Context, *Chain) (*Chain, error)
   793  	// does exactly nothing
   794  	SimplePing(context.Context, *common.Void) (*common.Void, error)
   795  }
   796  
   797  func RegisterEasyOpsTestServer(s *grpc.Server, srv EasyOpsTestServer) {
   798  	s.RegisterService(&_EasyOpsTest_serviceDesc, srv)
   799  }
   800  
   801  func _EasyOpsTest_CheckSerialisation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   802  	in := new(Count)
   803  	if err := dec(in); err != nil {
   804  		return nil, err
   805  	}
   806  	if interceptor == nil {
   807  		return srv.(EasyOpsTestServer).CheckSerialisation(ctx, in)
   808  	}
   809  	info := &grpc.UnaryServerInfo{
   810  		Server:     srv,
   811  		FullMethod: "/getestservice.EasyOpsTest/CheckSerialisation",
   812  	}
   813  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   814  		return srv.(EasyOpsTestServer).CheckSerialisation(ctx, req.(*Count))
   815  	}
   816  	return interceptor(ctx, in, info, handler)
   817  }
   818  
   819  func _EasyOpsTest_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   820  	in := new(Chain)
   821  	if err := dec(in); err != nil {
   822  		return nil, err
   823  	}
   824  	if interceptor == nil {
   825  		return srv.(EasyOpsTestServer).Ping(ctx, in)
   826  	}
   827  	info := &grpc.UnaryServerInfo{
   828  		Server:     srv,
   829  		FullMethod: "/getestservice.EasyOpsTest/Ping",
   830  	}
   831  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   832  		return srv.(EasyOpsTestServer).Ping(ctx, req.(*Chain))
   833  	}
   834  	return interceptor(ctx, in, info, handler)
   835  }
   836  
   837  func _EasyOpsTest_SimplePing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   838  	in := new(common.Void)
   839  	if err := dec(in); err != nil {
   840  		return nil, err
   841  	}
   842  	if interceptor == nil {
   843  		return srv.(EasyOpsTestServer).SimplePing(ctx, in)
   844  	}
   845  	info := &grpc.UnaryServerInfo{
   846  		Server:     srv,
   847  		FullMethod: "/getestservice.EasyOpsTest/SimplePing",
   848  	}
   849  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   850  		return srv.(EasyOpsTestServer).SimplePing(ctx, req.(*common.Void))
   851  	}
   852  	return interceptor(ctx, in, info, handler)
   853  }
   854  
   855  var _EasyOpsTest_serviceDesc = grpc.ServiceDesc{
   856  	ServiceName: "getestservice.EasyOpsTest",
   857  	HandlerType: (*EasyOpsTestServer)(nil),
   858  	Methods: []grpc.MethodDesc{
   859  		{
   860  			MethodName: "CheckSerialisation",
   861  			Handler:    _EasyOpsTest_CheckSerialisation_Handler,
   862  		},
   863  		{
   864  			MethodName: "Ping",
   865  			Handler:    _EasyOpsTest_Ping_Handler,
   866  		},
   867  		{
   868  			MethodName: "SimplePing",
   869  			Handler:    _EasyOpsTest_SimplePing_Handler,
   870  		},
   871  	},
   872  	Streams:  []grpc.StreamDesc{},
   873  	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
   874  }
   875  
   876  // Client API for CtxTest service
   877  
   878  type CtxTestClient interface {
   879  	TestFork(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
   880  	TestDeSer(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*SerialisedContext, error)
   881  	TestStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_TestStreamClient, error)
   882  	TestUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
   883  	CallUnaryFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallUnaryFromStreamClient, error)
   884  	CallUnaryFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
   885  	CallStreamFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallStreamFromStreamClient, error)
   886  	CallStreamFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error)
   887  	Sleep(ctx context.Context, in *SleepRequest, opts ...grpc.CallOption) (*common.Void, error)
   888  }
   889  
   890  type ctxTestClient struct {
   891  	cc *grpc.ClientConn
   892  }
   893  
   894  func NewCtxTestClient(cc *grpc.ClientConn) CtxTestClient {
   895  	return &ctxTestClient{cc}
   896  }
   897  
   898  func (c *ctxTestClient) TestFork(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
   899  	out := new(common.Void)
   900  	err := grpc.Invoke(ctx, "/getestservice.CtxTest/TestFork", in, out, c.cc, opts...)
   901  	if err != nil {
   902  		return nil, err
   903  	}
   904  	return out, nil
   905  }
   906  
   907  func (c *ctxTestClient) TestDeSer(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*SerialisedContext, error) {
   908  	out := new(SerialisedContext)
   909  	err := grpc.Invoke(ctx, "/getestservice.CtxTest/TestDeSer", in, out, c.cc, opts...)
   910  	if err != nil {
   911  		return nil, err
   912  	}
   913  	return out, nil
   914  }
   915  
   916  func (c *ctxTestClient) TestStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_TestStreamClient, error) {
   917  	stream, err := grpc.NewClientStream(ctx, &_CtxTest_serviceDesc.Streams[0], c.cc, "/getestservice.CtxTest/TestStream", opts...)
   918  	if err != nil {
   919  		return nil, err
   920  	}
   921  	x := &ctxTestTestStreamClient{stream}
   922  	if err := x.ClientStream.SendMsg(in); err != nil {
   923  		return nil, err
   924  	}
   925  	if err := x.ClientStream.CloseSend(); err != nil {
   926  		return nil, err
   927  	}
   928  	return x, nil
   929  }
   930  
   931  type CtxTest_TestStreamClient interface {
   932  	Recv() (*common.Void, error)
   933  	grpc.ClientStream
   934  }
   935  
   936  type ctxTestTestStreamClient struct {
   937  	grpc.ClientStream
   938  }
   939  
   940  func (x *ctxTestTestStreamClient) Recv() (*common.Void, error) {
   941  	m := new(common.Void)
   942  	if err := x.ClientStream.RecvMsg(m); err != nil {
   943  		return nil, err
   944  	}
   945  	return m, nil
   946  }
   947  
   948  func (c *ctxTestClient) TestUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
   949  	out := new(common.Void)
   950  	err := grpc.Invoke(ctx, "/getestservice.CtxTest/TestUnary", in, out, c.cc, opts...)
   951  	if err != nil {
   952  		return nil, err
   953  	}
   954  	return out, nil
   955  }
   956  
   957  func (c *ctxTestClient) CallUnaryFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallUnaryFromStreamClient, error) {
   958  	stream, err := grpc.NewClientStream(ctx, &_CtxTest_serviceDesc.Streams[1], c.cc, "/getestservice.CtxTest/CallUnaryFromStream", opts...)
   959  	if err != nil {
   960  		return nil, err
   961  	}
   962  	x := &ctxTestCallUnaryFromStreamClient{stream}
   963  	if err := x.ClientStream.SendMsg(in); err != nil {
   964  		return nil, err
   965  	}
   966  	if err := x.ClientStream.CloseSend(); err != nil {
   967  		return nil, err
   968  	}
   969  	return x, nil
   970  }
   971  
   972  type CtxTest_CallUnaryFromStreamClient interface {
   973  	Recv() (*common.Void, error)
   974  	grpc.ClientStream
   975  }
   976  
   977  type ctxTestCallUnaryFromStreamClient struct {
   978  	grpc.ClientStream
   979  }
   980  
   981  func (x *ctxTestCallUnaryFromStreamClient) Recv() (*common.Void, error) {
   982  	m := new(common.Void)
   983  	if err := x.ClientStream.RecvMsg(m); err != nil {
   984  		return nil, err
   985  	}
   986  	return m, nil
   987  }
   988  
   989  func (c *ctxTestClient) CallUnaryFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
   990  	out := new(common.Void)
   991  	err := grpc.Invoke(ctx, "/getestservice.CtxTest/CallUnaryFromUnary", in, out, c.cc, opts...)
   992  	if err != nil {
   993  		return nil, err
   994  	}
   995  	return out, nil
   996  }
   997  
   998  func (c *ctxTestClient) CallStreamFromStream(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (CtxTest_CallStreamFromStreamClient, error) {
   999  	stream, err := grpc.NewClientStream(ctx, &_CtxTest_serviceDesc.Streams[2], c.cc, "/getestservice.CtxTest/CallStreamFromStream", opts...)
  1000  	if err != nil {
  1001  		return nil, err
  1002  	}
  1003  	x := &ctxTestCallStreamFromStreamClient{stream}
  1004  	if err := x.ClientStream.SendMsg(in); err != nil {
  1005  		return nil, err
  1006  	}
  1007  	if err := x.ClientStream.CloseSend(); err != nil {
  1008  		return nil, err
  1009  	}
  1010  	return x, nil
  1011  }
  1012  
  1013  type CtxTest_CallStreamFromStreamClient interface {
  1014  	Recv() (*common.Void, error)
  1015  	grpc.ClientStream
  1016  }
  1017  
  1018  type ctxTestCallStreamFromStreamClient struct {
  1019  	grpc.ClientStream
  1020  }
  1021  
  1022  func (x *ctxTestCallStreamFromStreamClient) Recv() (*common.Void, error) {
  1023  	m := new(common.Void)
  1024  	if err := x.ClientStream.RecvMsg(m); err != nil {
  1025  		return nil, err
  1026  	}
  1027  	return m, nil
  1028  }
  1029  
  1030  func (c *ctxTestClient) CallStreamFromUnary(ctx context.Context, in *RequiredContext, opts ...grpc.CallOption) (*common.Void, error) {
  1031  	out := new(common.Void)
  1032  	err := grpc.Invoke(ctx, "/getestservice.CtxTest/CallStreamFromUnary", in, out, c.cc, opts...)
  1033  	if err != nil {
  1034  		return nil, err
  1035  	}
  1036  	return out, nil
  1037  }
  1038  
  1039  func (c *ctxTestClient) Sleep(ctx context.Context, in *SleepRequest, opts ...grpc.CallOption) (*common.Void, error) {
  1040  	out := new(common.Void)
  1041  	err := grpc.Invoke(ctx, "/getestservice.CtxTest/Sleep", in, out, c.cc, opts...)
  1042  	if err != nil {
  1043  		return nil, err
  1044  	}
  1045  	return out, nil
  1046  }
  1047  
  1048  // Server API for CtxTest service
  1049  
  1050  type CtxTestServer interface {
  1051  	TestFork(context.Context, *RequiredContext) (*common.Void, error)
  1052  	TestDeSer(context.Context, *RequiredContext) (*SerialisedContext, error)
  1053  	TestStream(*RequiredContext, CtxTest_TestStreamServer) error
  1054  	TestUnary(context.Context, *RequiredContext) (*common.Void, error)
  1055  	CallUnaryFromStream(*RequiredContext, CtxTest_CallUnaryFromStreamServer) error
  1056  	CallUnaryFromUnary(context.Context, *RequiredContext) (*common.Void, error)
  1057  	CallStreamFromStream(*RequiredContext, CtxTest_CallStreamFromStreamServer) error
  1058  	CallStreamFromUnary(context.Context, *RequiredContext) (*common.Void, error)
  1059  	Sleep(context.Context, *SleepRequest) (*common.Void, error)
  1060  }
  1061  
  1062  func RegisterCtxTestServer(s *grpc.Server, srv CtxTestServer) {
  1063  	s.RegisterService(&_CtxTest_serviceDesc, srv)
  1064  }
  1065  
  1066  func _CtxTest_TestFork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1067  	in := new(RequiredContext)
  1068  	if err := dec(in); err != nil {
  1069  		return nil, err
  1070  	}
  1071  	if interceptor == nil {
  1072  		return srv.(CtxTestServer).TestFork(ctx, in)
  1073  	}
  1074  	info := &grpc.UnaryServerInfo{
  1075  		Server:     srv,
  1076  		FullMethod: "/getestservice.CtxTest/TestFork",
  1077  	}
  1078  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1079  		return srv.(CtxTestServer).TestFork(ctx, req.(*RequiredContext))
  1080  	}
  1081  	return interceptor(ctx, in, info, handler)
  1082  }
  1083  
  1084  func _CtxTest_TestDeSer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1085  	in := new(RequiredContext)
  1086  	if err := dec(in); err != nil {
  1087  		return nil, err
  1088  	}
  1089  	if interceptor == nil {
  1090  		return srv.(CtxTestServer).TestDeSer(ctx, in)
  1091  	}
  1092  	info := &grpc.UnaryServerInfo{
  1093  		Server:     srv,
  1094  		FullMethod: "/getestservice.CtxTest/TestDeSer",
  1095  	}
  1096  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1097  		return srv.(CtxTestServer).TestDeSer(ctx, req.(*RequiredContext))
  1098  	}
  1099  	return interceptor(ctx, in, info, handler)
  1100  }
  1101  
  1102  func _CtxTest_TestStream_Handler(srv interface{}, stream grpc.ServerStream) error {
  1103  	m := new(RequiredContext)
  1104  	if err := stream.RecvMsg(m); err != nil {
  1105  		return err
  1106  	}
  1107  	return srv.(CtxTestServer).TestStream(m, &ctxTestTestStreamServer{stream})
  1108  }
  1109  
  1110  type CtxTest_TestStreamServer interface {
  1111  	Send(*common.Void) error
  1112  	grpc.ServerStream
  1113  }
  1114  
  1115  type ctxTestTestStreamServer struct {
  1116  	grpc.ServerStream
  1117  }
  1118  
  1119  func (x *ctxTestTestStreamServer) Send(m *common.Void) error {
  1120  	return x.ServerStream.SendMsg(m)
  1121  }
  1122  
  1123  func _CtxTest_TestUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1124  	in := new(RequiredContext)
  1125  	if err := dec(in); err != nil {
  1126  		return nil, err
  1127  	}
  1128  	if interceptor == nil {
  1129  		return srv.(CtxTestServer).TestUnary(ctx, in)
  1130  	}
  1131  	info := &grpc.UnaryServerInfo{
  1132  		Server:     srv,
  1133  		FullMethod: "/getestservice.CtxTest/TestUnary",
  1134  	}
  1135  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1136  		return srv.(CtxTestServer).TestUnary(ctx, req.(*RequiredContext))
  1137  	}
  1138  	return interceptor(ctx, in, info, handler)
  1139  }
  1140  
  1141  func _CtxTest_CallUnaryFromStream_Handler(srv interface{}, stream grpc.ServerStream) error {
  1142  	m := new(RequiredContext)
  1143  	if err := stream.RecvMsg(m); err != nil {
  1144  		return err
  1145  	}
  1146  	return srv.(CtxTestServer).CallUnaryFromStream(m, &ctxTestCallUnaryFromStreamServer{stream})
  1147  }
  1148  
  1149  type CtxTest_CallUnaryFromStreamServer interface {
  1150  	Send(*common.Void) error
  1151  	grpc.ServerStream
  1152  }
  1153  
  1154  type ctxTestCallUnaryFromStreamServer struct {
  1155  	grpc.ServerStream
  1156  }
  1157  
  1158  func (x *ctxTestCallUnaryFromStreamServer) Send(m *common.Void) error {
  1159  	return x.ServerStream.SendMsg(m)
  1160  }
  1161  
  1162  func _CtxTest_CallUnaryFromUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1163  	in := new(RequiredContext)
  1164  	if err := dec(in); err != nil {
  1165  		return nil, err
  1166  	}
  1167  	if interceptor == nil {
  1168  		return srv.(CtxTestServer).CallUnaryFromUnary(ctx, in)
  1169  	}
  1170  	info := &grpc.UnaryServerInfo{
  1171  		Server:     srv,
  1172  		FullMethod: "/getestservice.CtxTest/CallUnaryFromUnary",
  1173  	}
  1174  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1175  		return srv.(CtxTestServer).CallUnaryFromUnary(ctx, req.(*RequiredContext))
  1176  	}
  1177  	return interceptor(ctx, in, info, handler)
  1178  }
  1179  
  1180  func _CtxTest_CallStreamFromStream_Handler(srv interface{}, stream grpc.ServerStream) error {
  1181  	m := new(RequiredContext)
  1182  	if err := stream.RecvMsg(m); err != nil {
  1183  		return err
  1184  	}
  1185  	return srv.(CtxTestServer).CallStreamFromStream(m, &ctxTestCallStreamFromStreamServer{stream})
  1186  }
  1187  
  1188  type CtxTest_CallStreamFromStreamServer interface {
  1189  	Send(*common.Void) error
  1190  	grpc.ServerStream
  1191  }
  1192  
  1193  type ctxTestCallStreamFromStreamServer struct {
  1194  	grpc.ServerStream
  1195  }
  1196  
  1197  func (x *ctxTestCallStreamFromStreamServer) Send(m *common.Void) error {
  1198  	return x.ServerStream.SendMsg(m)
  1199  }
  1200  
  1201  func _CtxTest_CallStreamFromUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1202  	in := new(RequiredContext)
  1203  	if err := dec(in); err != nil {
  1204  		return nil, err
  1205  	}
  1206  	if interceptor == nil {
  1207  		return srv.(CtxTestServer).CallStreamFromUnary(ctx, in)
  1208  	}
  1209  	info := &grpc.UnaryServerInfo{
  1210  		Server:     srv,
  1211  		FullMethod: "/getestservice.CtxTest/CallStreamFromUnary",
  1212  	}
  1213  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1214  		return srv.(CtxTestServer).CallStreamFromUnary(ctx, req.(*RequiredContext))
  1215  	}
  1216  	return interceptor(ctx, in, info, handler)
  1217  }
  1218  
  1219  func _CtxTest_Sleep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1220  	in := new(SleepRequest)
  1221  	if err := dec(in); err != nil {
  1222  		return nil, err
  1223  	}
  1224  	if interceptor == nil {
  1225  		return srv.(CtxTestServer).Sleep(ctx, in)
  1226  	}
  1227  	info := &grpc.UnaryServerInfo{
  1228  		Server:     srv,
  1229  		FullMethod: "/getestservice.CtxTest/Sleep",
  1230  	}
  1231  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1232  		return srv.(CtxTestServer).Sleep(ctx, req.(*SleepRequest))
  1233  	}
  1234  	return interceptor(ctx, in, info, handler)
  1235  }
  1236  
  1237  var _CtxTest_serviceDesc = grpc.ServiceDesc{
  1238  	ServiceName: "getestservice.CtxTest",
  1239  	HandlerType: (*CtxTestServer)(nil),
  1240  	Methods: []grpc.MethodDesc{
  1241  		{
  1242  			MethodName: "TestFork",
  1243  			Handler:    _CtxTest_TestFork_Handler,
  1244  		},
  1245  		{
  1246  			MethodName: "TestDeSer",
  1247  			Handler:    _CtxTest_TestDeSer_Handler,
  1248  		},
  1249  		{
  1250  			MethodName: "TestUnary",
  1251  			Handler:    _CtxTest_TestUnary_Handler,
  1252  		},
  1253  		{
  1254  			MethodName: "CallUnaryFromUnary",
  1255  			Handler:    _CtxTest_CallUnaryFromUnary_Handler,
  1256  		},
  1257  		{
  1258  			MethodName: "CallStreamFromUnary",
  1259  			Handler:    _CtxTest_CallStreamFromUnary_Handler,
  1260  		},
  1261  		{
  1262  			MethodName: "Sleep",
  1263  			Handler:    _CtxTest_Sleep_Handler,
  1264  		},
  1265  	},
  1266  	Streams: []grpc.StreamDesc{
  1267  		{
  1268  			StreamName:    "TestStream",
  1269  			Handler:       _CtxTest_TestStream_Handler,
  1270  			ServerStreams: true,
  1271  		},
  1272  		{
  1273  			StreamName:    "CallUnaryFromStream",
  1274  			Handler:       _CtxTest_CallUnaryFromStream_Handler,
  1275  			ServerStreams: true,
  1276  		},
  1277  		{
  1278  			StreamName:    "CallStreamFromStream",
  1279  			Handler:       _CtxTest_CallStreamFromStream_Handler,
  1280  			ServerStreams: true,
  1281  		},
  1282  	},
  1283  	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
  1284  }
  1285  
  1286  // Client API for Ctx2Test service
  1287  
  1288  type Ctx2TestClient interface {
  1289  	TriggerRPC(ctx context.Context, in *TriggerRPCRequest, opts ...grpc.CallOption) (*common.Void, error)
  1290  }
  1291  
  1292  type ctx2TestClient struct {
  1293  	cc *grpc.ClientConn
  1294  }
  1295  
  1296  func NewCtx2TestClient(cc *grpc.ClientConn) Ctx2TestClient {
  1297  	return &ctx2TestClient{cc}
  1298  }
  1299  
  1300  func (c *ctx2TestClient) TriggerRPC(ctx context.Context, in *TriggerRPCRequest, opts ...grpc.CallOption) (*common.Void, error) {
  1301  	out := new(common.Void)
  1302  	err := grpc.Invoke(ctx, "/getestservice.Ctx2Test/TriggerRPC", in, out, c.cc, opts...)
  1303  	if err != nil {
  1304  		return nil, err
  1305  	}
  1306  	return out, nil
  1307  }
  1308  
  1309  // Server API for Ctx2Test service
  1310  
  1311  type Ctx2TestServer interface {
  1312  	TriggerRPC(context.Context, *TriggerRPCRequest) (*common.Void, error)
  1313  }
  1314  
  1315  func RegisterCtx2TestServer(s *grpc.Server, srv Ctx2TestServer) {
  1316  	s.RegisterService(&_Ctx2Test_serviceDesc, srv)
  1317  }
  1318  
  1319  func _Ctx2Test_TriggerRPC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  1320  	in := new(TriggerRPCRequest)
  1321  	if err := dec(in); err != nil {
  1322  		return nil, err
  1323  	}
  1324  	if interceptor == nil {
  1325  		return srv.(Ctx2TestServer).TriggerRPC(ctx, in)
  1326  	}
  1327  	info := &grpc.UnaryServerInfo{
  1328  		Server:     srv,
  1329  		FullMethod: "/getestservice.Ctx2Test/TriggerRPC",
  1330  	}
  1331  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  1332  		return srv.(Ctx2TestServer).TriggerRPC(ctx, req.(*TriggerRPCRequest))
  1333  	}
  1334  	return interceptor(ctx, in, info, handler)
  1335  }
  1336  
  1337  var _Ctx2Test_serviceDesc = grpc.ServiceDesc{
  1338  	ServiceName: "getestservice.Ctx2Test",
  1339  	HandlerType: (*Ctx2TestServer)(nil),
  1340  	Methods: []grpc.MethodDesc{
  1341  		{
  1342  			MethodName: "TriggerRPC",
  1343  			Handler:    _Ctx2Test_TriggerRPC_Handler,
  1344  		},
  1345  	},
  1346  	Streams:  []grpc.StreamDesc{},
  1347  	Metadata: "golang.conradwood.net/apis/getestservice/getestservice.proto",
  1348  }
  1349  
  1350  func init() {
  1351  	proto.RegisterFile("golang.conradwood.net/apis/getestservice/getestservice.proto", fileDescriptor0)
  1352  }
  1353  
  1354  var fileDescriptor0 = []byte{
  1355  	// 993 bytes of a gzipped FileDescriptorProto
  1356  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
  1357  	0x14, 0x96, 0xdb, 0xa4, 0x49, 0x4f, 0x92, 0xdd, 0xed, 0x34, 0xac, 0x22, 0x03, 0x55, 0xb1, 0x10,
  1358  	0xca, 0x16, 0x94, 0x22, 0x23, 0xa1, 0x05, 0x2d, 0x42, 0xdb, 0xfc, 0x88, 0x88, 0x6e, 0x89, 0x26,
  1359  	0xe9, 0x5e, 0x70, 0x81, 0x34, 0x1b, 0x8f, 0x1c, 0xab, 0xce, 0x4c, 0x18, 0x4f, 0xba, 0xcd, 0x25,
  1360  	0x4f, 0xc0, 0x53, 0xf0, 0x42, 0xdc, 0xf0, 0x34, 0x48, 0x68, 0x7e, 0xec, 0xc4, 0x4e, 0x09, 0x6c,
  1361  	0xe1, 0x26, 0x9e, 0x73, 0xe6, 0x9c, 0x6f, 0xbe, 0x33, 0xe7, 0x27, 0x03, 0x2f, 0x42, 0x1e, 0x13,
  1362  	0x16, 0x76, 0xa6, 0x9c, 0x09, 0x12, 0xbc, 0xe5, 0x3c, 0xe8, 0x30, 0x2a, 0xcf, 0xc9, 0x22, 0x4a,
  1363  	0xce, 0x43, 0x2a, 0x69, 0x22, 0x13, 0x2a, 0x6e, 0xa3, 0x29, 0xcd, 0x4b, 0x9d, 0x85, 0xe0, 0x92,
  1364  	0xa3, 0x46, 0x4e, 0xe9, 0x9e, 0xed, 0x00, 0x23, 0x4b, 0x39, 0xd3, 0x3f, 0xc6, 0xd5, 0xed, 0xec,
  1365  	0xb0, 0x9d, 0xf2, 0xf9, 0x9c, 0x33, 0xfb, 0x31, 0xf6, 0xde, 0x2d, 0x94, 0xba, 0x24, 0x8e, 0x91,
  1366  	0x0b, 0xd5, 0x11, 0x4f, 0x22, 0x19, 0x71, 0xd6, 0x72, 0x4e, 0x9d, 0x76, 0x19, 0x67, 0x32, 0x7a,
  1367  	0x0a, 0x07, 0xd7, 0x09, 0x15, 0xc3, 0x5e, 0x6b, 0xef, 0xd4, 0x69, 0x1f, 0x62, 0x2b, 0xa1, 0x0f,
  1368  	0xe0, 0x70, 0x6c, 0x28, 0x0e, 0x7b, 0xad, 0x7d, 0xbd, 0xb5, 0x56, 0xa8, 0x5d, 0x4c, 0x7f, 0x5e,
  1369  	0xd2, 0x44, 0x0e, 0x7b, 0xad, 0x92, 0xd9, 0xcd, 0x14, 0xde, 0x2f, 0x0e, 0xd4, 0x46, 0x11, 0x0b,
  1370  	0xad, 0x06, 0x7d, 0x02, 0x8f, 0xc6, 0x6a, 0xc9, 0xa6, 0xf4, 0x6a, 0x39, 0x7f, 0x43, 0x85, 0x66,
  1371  	0xd1, 0xc0, 0x05, 0x2d, 0x6a, 0x41, 0x65, 0x44, 0x56, 0x31, 0x27, 0x81, 0x25, 0x93, 0x8a, 0xe8,
  1372  	0x09, 0xec, 0x4f, 0x26, 0x97, 0x9a, 0x47, 0x03, 0xab, 0x25, 0x3a, 0x01, 0x18, 0xc5, 0x94, 0x24,
  1373  	0x74, 0x40, 0xa2, 0x58, 0x53, 0xa8, 0xe2, 0x0d, 0x8d, 0xf7, 0xbb, 0x03, 0x75, 0xc3, 0x21, 0x59,
  1374  	0x70, 0x96, 0x50, 0xf4, 0x25, 0x54, 0xd3, 0xb5, 0x3e, 0xbe, 0xe6, 0xbb, 0x9d, 0x7c, 0x7e, 0x36,
  1375  	0x28, 0xe3, 0xcc, 0x16, 0x7d, 0x0f, 0xa0, 0xe2, 0xa6, 0x62, 0x42, 0xc2, 0xa4, 0xb5, 0x77, 0xba,
  1376  	0xdf, 0xae, 0xf9, 0x9f, 0xde, 0xeb, 0x69, 0x1c, 0x3a, 0x6b, 0xeb, 0x3e, 0x93, 0x62, 0x85, 0x37,
  1377  	0xdc, 0xdd, 0x6f, 0xe0, 0x71, 0x61, 0x5b, 0x85, 0x76, 0x43, 0x57, 0x9a, 0xd2, 0x21, 0x56, 0x4b,
  1378  	0xd4, 0x84, 0xf2, 0x2d, 0x89, 0x97, 0xd4, 0x5e, 0x82, 0x11, 0xbe, 0xde, 0x7b, 0xee, 0x78, 0x6d,
  1379  	0x40, 0x83, 0x88, 0x05, 0x36, 0x0f, 0xe9, 0xf5, 0x22, 0x28, 0x5d, 0x91, 0x39, 0xb5, 0x10, 0x7a,
  1380  	0xed, 0x0d, 0xe0, 0x38, 0x67, 0x69, 0x83, 0x39, 0x87, 0xca, 0x84, 0x88, 0x90, 0xca, 0xa4, 0xe5,
  1381  	0xe8, 0x48, 0xde, 0x2b, 0x44, 0x62, 0x76, 0x71, 0x6a, 0xe5, 0x5d, 0x02, 0x52, 0x05, 0x71, 0xb1,
  1382  	0xba, 0xe4, 0x61, 0xc4, 0xd2, 0x13, 0x5d, 0xa8, 0x2a, 0x2d, 0x5b, 0x9f, 0x9a, 0xc9, 0xba, 0xd8,
  1383  	0x48, 0x92, 0xbc, 0xe5, 0x22, 0xcd, 0x62, 0x26, 0x7b, 0x67, 0x29, 0xda, 0x84, 0xdf, 0xd0, 0x0c,
  1384  	0xad, 0x09, 0x65, 0x2d, 0x5b, 0x28, 0x23, 0x78, 0x3d, 0xa8, 0xbf, 0x5c, 0xca, 0x59, 0x46, 0xbd,
  1385  	0x09, 0xe5, 0xd7, 0x24, 0x8e, 0x02, 0x6d, 0x55, 0xc5, 0x46, 0x40, 0x27, 0x50, 0x52, 0x88, 0xfa,
  1386  	0xa4, 0x9a, 0x0f, 0x1d, 0xdd, 0x2d, 0x4a, 0x83, 0xb5, 0xde, 0xfb, 0x0c, 0x0e, 0x4c, 0x28, 0xe8,
  1387  	0x11, 0xec, 0x0d, 0x47, 0xf6, 0x88, 0xbd, 0xe1, 0x48, 0xdd, 0xda, 0x88, 0x0b, 0xa9, 0x3d, 0x1b,
  1388  	0x58, 0xaf, 0xbd, 0x5f, 0x1d, 0x38, 0x1a, 0x53, 0x11, 0x91, 0x38, 0x4a, 0x68, 0xd0, 0xe5, 0x4c,
  1389  	0xd2, 0x3b, 0x7d, 0xbf, 0x3d, 0x22, 0x89, 0xf6, 0xad, 0x63, 0xbd, 0x56, 0x6c, 0xc6, 0x5a, 0x69,
  1390  	0x73, 0xa4, 0x05, 0xf4, 0xb1, 0x65, 0xb3, 0xaf, 0xd9, 0x3c, 0x31, 0x6c, 0xc6, 0x51, 0xc8, 0x68,
  1391  	0xb0, 0xe6, 0x84, 0xce, 0xa0, 0x62, 0xf3, 0xa2, 0xeb, 0xf6, 0x3e, 0xc3, 0xd4, 0xc0, 0x9b, 0xc2,
  1392  	0x63, 0x75, 0x4d, 0x91, 0x58, 0xd3, 0xf9, 0xff, 0x0f, 0x69, 0x43, 0x7d, 0x1c, 0x53, 0xba, 0x48,
  1393  	0x13, 0xd2, 0x52, 0xbe, 0x53, 0xce, 0x82, 0x44, 0xc7, 0xec, 0xe0, 0x54, 0xf4, 0xfa, 0x70, 0x34,
  1394  	0x11, 0x51, 0x18, 0x52, 0x81, 0x47, 0xdd, 0xd4, 0xfc, 0x29, 0x1c, 0xbc, 0x9c, 0x66, 0xc3, 0xa5,
  1395  	0x81, 0xad, 0xa4, 0x60, 0xba, 0x7c, 0xc9, 0xa4, 0x4d, 0x4f, 0x03, 0xa7, 0xa2, 0x77, 0x05, 0xe5,
  1396  	0xee, 0x8c, 0x44, 0x6c, 0xe7, 0x64, 0x7a, 0x06, 0x65, 0x35, 0xbd, 0xd2, 0x9e, 0x3b, 0x2e, 0x54,
  1397  	0xaa, 0xda, 0xc3, 0xc6, 0xc2, 0xfb, 0x10, 0xca, 0x1a, 0x5a, 0xa5, 0x45, 0x2f, 0x2c, 0x13, 0x23,
  1398  	0xf8, 0x57, 0x50, 0xeb, 0x4f, 0x67, 0xdc, 0x86, 0x8b, 0xbe, 0x85, 0x92, 0x6a, 0x58, 0xb4, 0xa3,
  1399  	0xff, 0xdd, 0xf7, 0x77, 0x74, 0xb8, 0xff, 0x13, 0x1c, 0x69, 0x3c, 0x29, 0x28, 0x99, 0xa7, 0xa8,
  1400  	0x43, 0xa8, 0x8f, 0x29, 0x0b, 0x26, 0xdc, 0x34, 0xf8, 0x83, 0xd1, 0xdb, 0x8e, 0xff, 0xa7, 0x03,
  1401  	0x95, 0x3e, 0x49, 0x56, 0x3f, 0x2c, 0x12, 0x34, 0x81, 0xda, 0x46, 0x23, 0xa3, 0x8f, 0x0a, 0x9e,
  1402  	0xdb, 0xe3, 0xc0, 0xf5, 0x76, 0x99, 0xd8, 0x66, 0x7a, 0x05, 0xb5, 0x8d, 0xb6, 0xde, 0x42, 0xdd,
  1403  	0x6e, 0xf9, 0x2d, 0xca, 0xb9, 0xde, 0xcc, 0xe0, 0x74, 0xeb, 0xfe, 0x0d, 0xdc, 0x66, 0xcf, 0xef,
  1404  	0x84, 0xf3, 0x7f, 0x73, 0xa0, 0x66, 0xe3, 0x9f, 0xa8, 0x02, 0x7b, 0x0e, 0xa8, 0x3b, 0xa3, 0xd3,
  1405  	0x9b, 0xb4, 0x35, 0x89, 0xae, 0x8f, 0x66, 0xb1, 0x20, 0x54, 0xae, 0xdd, 0x7a, 0xc7, 0xfe, 0x05,
  1406  	0xbe, 0xe6, 0x51, 0x80, 0x7c, 0x9b, 0xea, 0x2d, 0x5b, 0x55, 0x7d, 0xee, 0xbd, 0x5a, 0xd4, 0x06,
  1407  	0x18, 0x47, 0xf3, 0x45, 0x4c, 0xb5, 0x67, 0x0e, 0x2f, 0x8f, 0xee, 0xff, 0x51, 0x82, 0x4a, 0x57,
  1408  	0xde, 0x59, 0x8e, 0x55, 0xf5, 0x1d, 0x70, 0x71, 0x83, 0x4e, 0x0a, 0xb8, 0x85, 0x0e, 0x2e, 0x70,
  1409  	0x7c, 0x05, 0x87, 0xca, 0xb3, 0x47, 0xc7, 0x54, 0xfc, 0xa3, 0xeb, 0x69, 0x61, 0x7f, 0x7b, 0x5a,
  1410  	0xbd, 0x00, 0x50, 0x70, 0xa6, 0x38, 0xdf, 0x8d, 0xca, 0xe7, 0x0e, 0xfa, 0xca, 0x90, 0xb9, 0x66,
  1411  	0x44, 0xac, 0xde, 0x31, 0x8e, 0x3e, 0x1c, 0xab, 0x6e, 0xd4, 0xae, 0x03, 0xc1, 0xe7, 0x0f, 0x64,
  1412  	0x70, 0x01, 0x28, 0x07, 0xf3, 0x10, 0x2a, 0x03, 0x68, 0x2a, 0x0c, 0xc3, 0xe0, 0x3f, 0x70, 0xe9,
  1413  	0x9a, 0x90, 0xd6, 0x38, 0x0f, 0x21, 0xe3, 0x43, 0x59, 0x4f, 0x57, 0x54, 0xac, 0xf9, 0xcd, 0x99,
  1414  	0x5b, 0xa8, 0xac, 0xef, 0xa0, 0xda, 0x95, 0x77, 0xbe, 0xae, 0x2c, 0x95, 0xd0, 0x6c, 0xe6, 0xa2,
  1415  	0x62, 0x01, 0x6c, 0x8d, 0xe3, 0x3c, 0xd2, 0xc5, 0x35, 0x3c, 0x63, 0x54, 0x6e, 0x3e, 0x19, 0xed,
  1416  	0x23, 0x52, 0xbd, 0x1a, 0x15, 0xd6, 0x06, 0xd8, 0x8f, 0xed, 0x7f, 0xfb, 0xb2, 0x7d, 0x73, 0xa0,
  1417  	0x5f, 0x98, 0x5f, 0xfc, 0x15, 0x00, 0x00, 0xff, 0xff, 0x52, 0x3f, 0x79, 0x2a, 0x0c, 0x0b, 0x00,
  1418  	0x00,
  1419  }
  1420  

View as plain text