rpc

type Client struct {
	// contains filtered or unexported fields
}

type ClientConnInterface interface {
	// Invoke performs a unary RPC and returns after the response is received
	// into reply.
	Invoke(ctx context.Context, method string, args interface{}, reply interface{}) error
}

type ClientOptions struct {
	CallbackWorkers       int
	WaitReplies           bool
	CallMessageExpiration time.Duration
	CallTimeout           time.Duration
}

type MethodDesc struct {
	MethodName string
	Handler    methodHandler
}

type RabbitMQServer struct {
	// contains filtered or unexported fields
}

type Request struct {
	Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	Method  string `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
	// contains filtered or unexported fields
}

type ServerOptions struct {
	// contains filtered or unexported fields
}

type ServiceDesc struct {
	ServiceName string
	// The pointer to the service interface. Used to check whether the user
	// provided implementation satisfies the interface requirements.
	HandlerType interface{}
	Methods     []MethodDesc
	Metadata    interface{}
}

type ServiceInfo struct {
	// Contains the implementation for the methods in this service.
	ServiceImpl interface{}
	Methods     map[string]*MethodDesc
	Metadata    interface{}
}

type ServiceRegistrar interface {
	// RegisterProtoService registers a service and its implementation to the
	// concrete type implementing this interface.  It may not be called
	// once the server has started serving.
	// desc describes the service and its methods and handlers. impl is the
	// service implementation which is passed to the method handlers.
	RegisterProtoService(desc *ServiceDesc, impl interface{})
}

type UnaryHandler func(ctx context.Context, req interface{}) (interface{}, error)

type UnaryServerInfo struct {
	// Server is the service implementation the user provides. This is read-only.
	Server interface{}
	// FullMethod is the full RPC method string, i.e., /package.service/method.
	FullMethod string
}

type UnaryServerInterceptor func(ctx context.Context, req interface{}, info *UnaryServerInfo, handler UnaryHandler) (resp interface{}, err error)