Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func CanonicalizeHeaderKey

func CanonicalizeHeaderKey(k string) string

    CanonicalizeHeaderKey canonicalizes the given header key for storage into Headers.

    func DispatchOnewayHandler

    func DispatchOnewayHandler(
    	ctx context.Context,
    	h OnewayHandler,
    	req *Request,
    ) (err error)

      DispatchOnewayHandler calls the oneway handler, recovering from panics as errors

      Deprecated: Use InvokeOnewayHandler instead.

      func DispatchStreamHandler

      func DispatchStreamHandler(
      	h StreamHandler,
      	stream *ServerStream,
      ) (err error)

        DispatchStreamHandler calls the stream handler, recovering from panics as errors.

        Deprecated: Use InvokeStreamHandler instead.

        func DispatchUnaryHandler

        func DispatchUnaryHandler(
        	ctx context.Context,
        	h UnaryHandler,
        	start time.Time,
        	req *Request,
        	resq ResponseWriter,
        ) (err error)

          DispatchUnaryHandler calls the handler h, recovering panics and timeout errors, converting them to yarpc errors. All other errors are passed trough.

          Deprecated: Use InvokeUnaryHandler instead.

          func InboundBadRequestError

          func InboundBadRequestError(err error) error

            InboundBadRequestError builds an error which indicates that an inbound cannot process a request because it is a bad request.

            IsBadRequestError returns true for these errors.

            Deprecated: use yarpcerrors.Newf with yarpcerrors.CodeInvalidArgument instead.

            func InvokeOnewayHandler

            func InvokeOnewayHandler(
            	i OnewayInvokeRequest,
            ) (err error)

              InvokeOnewayHandler calls the oneway handler, recovering from panics as errors.

              func InvokeStreamHandler

              func InvokeStreamHandler(
              	i StreamInvokeRequest,
              ) (err error)

                InvokeStreamHandler calls the stream handler, recovering from panics as errors.

                func InvokeUnaryHandler

                func InvokeUnaryHandler(
                	i UnaryInvokeRequest,
                ) (err error)

                  InvokeUnaryHandler calls the handler h, recovering panics and timeout errors, converting them to YARPC errors. All other errors are passed through.

                  func IsBadRequestError

                  func IsBadRequestError(err error) bool

                    IsBadRequestError returns true if the request could not be processed because it was invalid.

                    Deprecated: use yarpcerrors.FromError(err).Code() == yarpcerrors.CodeInvalidArgument instead.

                    func IsTimeoutError

                    func IsTimeoutError(err error) bool

                      IsTimeoutError return true if the given error is a TimeoutError.

                      Deprecated: use yarpcerrors.FromError(err).Code() == yarpcerrors.CodeDeadlineExceeded instead.

                      func IsUnexpectedError

                      func IsUnexpectedError(err error) bool

                        IsUnexpectedError returns true if the server panicked or failed to process the request with an unhandled error.

                        Deprecated: use yarpcerrors.FromError(err).Code() == yarpcerrors.CodeInternal instead.

                        func IsUnrecognizedProcedureError

                        func IsUnrecognizedProcedureError(err error) bool

                          IsUnrecognizedProcedureError returns true for errors returned by Router.Choose if the router cannot find a handler for the request.

                          Deprecated: use yarpcerrors.FromError(err).Code() == yarpcerrors.CodeUnimplemented instead.

                          func SendStreamHeaders

                          func SendStreamHeaders(s Stream, headers Headers) error

                            SendStreamHeaders conditionally type asserts a Stream to a StreamHeadersSender to send the provided headers.

                            func UnrecognizedProcedureError

                            func UnrecognizedProcedureError(req *Request) error

                              UnrecognizedProcedureError returns an error for the given request, such that IsUnrecognizedProcedureError can distinguish it from other errors coming out of router.Choose.

                              Deprecated: use yarpcerrors.Newf with yarpcerrors.CodeUnimplemented instead.

                              func UpdateSpanWithErr

                              func UpdateSpanWithErr(span opentracing.Span, err error) error

                                UpdateSpanWithErr sets the error tag on a span, if an error is given. Returns the given error

                                func ValidateRequest

                                func ValidateRequest(req *Request) error

                                  ValidateRequest validates the given request. An error is returned if the request is invalid.

                                  Inbound transport implementations may use this to validate requests before handling them. Outbound implementations don't need to validate requests; they are always validated before the outbound is called.

                                  func ValidateRequestContext

                                  func ValidateRequestContext(ctx context.Context) error

                                    ValidateRequestContext validates that a context for a request is valid and contains all required information, and returns a YARPC error with code yarpcerrors.CodeInvalidArgument otherwise.

                                    func ValidateUnaryContext

                                    func ValidateUnaryContext(ctx context.Context) error

                                      ValidateUnaryContext validates that a context for a unary request is valid and contains all required information, and returns a YARPC error with code yarpcerrors.CodeInvalidArgument otherwise.

                                      Deprecated: Use ValidateRequestContext instead.

                                      Types

                                      type Ack

                                      type Ack interface {
                                      	fmt.Stringer
                                      }

                                        Ack represents an acknowledgement from a oneway request.

                                        type ApplicationErrorMeta

                                        type ApplicationErrorMeta struct {
                                        	Code    *yarpcerrors.Code
                                        	Name    string
                                        	Details string
                                        }

                                          ApplicationErrorMeta contains additional information to describe the application error, using an error name, code and details string.

                                          Fields are optional for backwards-compatibility and may not be present in all responses.

                                          type ApplicationErrorMetaSetter

                                          type ApplicationErrorMetaSetter interface {
                                          	// SetApplicationErrorMeta specifies the name of the application error, if any.
                                          	// If called, this MUST be called before any invocation of Write().
                                          	SetApplicationErrorMeta(*ApplicationErrorMeta)
                                          }

                                            ApplicationErrorMetaSetter enables setting the name of an application error, surfacing it in metrics.

                                            Conditionally upcast a ResponseWriter to access the functionality.

                                            type ClientConfig

                                            type ClientConfig interface {
                                            	// Name of the service making the request.
                                            	Caller() string
                                            
                                            	// Name of the service to which the request is being made.
                                            	Service() string
                                            
                                            	// Returns an outbound to send the request through or panics if there is no
                                            	// outbound for this service
                                            	//
                                            	// MAY be called multiple times for a request. The returned outbound MUST
                                            	// have already been started.
                                            	GetUnaryOutbound() UnaryOutbound
                                            	GetOnewayOutbound() OnewayOutbound
                                            }

                                              A ClientConfig is a stream of communication between a single caller-service pair.

                                              type ClientConfigProvider

                                              type ClientConfigProvider interface {
                                              	// Retrieves a new ClientConfig that will make requests to the given service.
                                              	//
                                              	// This MAY panic if the given service is unknown.
                                              	ClientConfig(service string) ClientConfig
                                              }

                                                ClientConfigProvider builds ClientConfigs from the current service to other services.

                                                type ClientStream

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

                                                  ClientStream represents the Client API of interacting with a Stream.

                                                  func NewClientStream

                                                  func NewClientStream(s StreamCloser, options ...ClientStreamOption) (*ClientStream, error)

                                                    NewClientStream will create a new ClientStream. The StreamCloser can implement StreamMessageReader if the underlying stream supports stream headers.

                                                    func (*ClientStream) Close

                                                    func (s *ClientStream) Close(ctx context.Context) error

                                                      Close will close the connection. It blocks until the server has acknowledged the close. In certain implementations, the timeout on the context will be used to timeout the request. If the server timed out the connection will be forced closed by the client.

                                                      func (*ClientStream) Context

                                                      func (s *ClientStream) Context() context.Context

                                                        Context returns the context for the stream.

                                                        func (*ClientStream) Headers

                                                        func (s *ClientStream) Headers() (Headers, error)

                                                          Headers returns the initial stream response headers received from the server if there are any. It blocks if the headers are not available.

                                                          func (*ClientStream) ReceiveMessage

                                                          func (s *ClientStream) ReceiveMessage(ctx context.Context) (*StreamMessage, error)

                                                            ReceiveMessage blocks until a message is received from the connection. It returns an io.Reader with the contents of the message.

                                                            func (*ClientStream) Request

                                                            func (s *ClientStream) Request() *StreamRequest

                                                              Request contains all the metadata about the request.

                                                              func (*ClientStream) SendMessage

                                                              func (s *ClientStream) SendMessage(ctx context.Context, msg *StreamMessage) error

                                                                SendMessage sends a request over the stream. It blocks until the message has been sent. In certain implementations, the timeout on the context will be used to timeout the request.

                                                                type ClientStreamOption

                                                                type ClientStreamOption interface {
                                                                	// contains filtered or unexported methods
                                                                }

                                                                  ClientStreamOption is an option for configuring a client stream. There are no current ClientStreamOptions implemented.

                                                                  type Compressor

                                                                  type Compressor interface {
                                                                  	Name() string
                                                                  	Compress(w io.Writer) (io.WriteCloser, error)
                                                                  	Decompress(r io.Reader) (io.ReadCloser, error)
                                                                  }

                                                                    Compressor represents a compression strategy and supports creating new compression and decompression streams for that strategy.

                                                                    This interface is equivalent to the compressor API proposed by grpc-go. https://godoc.org/google.golang.org/grpc/encoding#Compressor

                                                                    type CreateOpenTracingSpan

                                                                    type CreateOpenTracingSpan struct {
                                                                    	Tracer        opentracing.Tracer
                                                                    	TransportName string
                                                                    	StartTime     time.Time
                                                                    	ExtraTags     opentracing.Tags
                                                                    }

                                                                      CreateOpenTracingSpan creates a new context with a started span

                                                                      func (*CreateOpenTracingSpan) Do

                                                                      func (c *CreateOpenTracingSpan) Do(
                                                                      	ctx context.Context,
                                                                      	req *Request,
                                                                      ) (context.Context, opentracing.Span)

                                                                        Do creates a new context that has a reference to the started span. This should be called before a Outbound makes a call

                                                                        type Encoding

                                                                        type Encoding string

                                                                          Encoding represents an encoding format for requests.

                                                                          type ExtractOpenTracingSpan

                                                                          type ExtractOpenTracingSpan struct {
                                                                          	ParentSpanContext opentracing.SpanContext
                                                                          	Tracer            opentracing.Tracer
                                                                          	TransportName     string
                                                                          	StartTime         time.Time
                                                                          	ExtraTags         opentracing.Tags
                                                                          }

                                                                            ExtractOpenTracingSpan derives a context and associated span

                                                                            func (*ExtractOpenTracingSpan) Do

                                                                            func (e *ExtractOpenTracingSpan) Do(
                                                                            	ctx context.Context,
                                                                            	req *Request,
                                                                            ) (context.Context, opentracing.Span)

                                                                              Do derives a new context from SpanContext. The created context has a reference to the started span. parentSpanCtx may be nil. This should be called before a Inbound handles a request

                                                                              type HandlerSpec

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

                                                                                HandlerSpec holds a handler and its Type one handler will be set, the other nil

                                                                                func NewOnewayHandlerSpec

                                                                                func NewOnewayHandlerSpec(handler OnewayHandler) HandlerSpec

                                                                                  NewOnewayHandlerSpec returns an new HandlerSpec with a OnewayHandler

                                                                                  func NewStreamHandlerSpec

                                                                                  func NewStreamHandlerSpec(handler StreamHandler) HandlerSpec

                                                                                    NewStreamHandlerSpec returns an new HandlerSpec with a StreamHandler

                                                                                    func NewUnaryHandlerSpec

                                                                                    func NewUnaryHandlerSpec(handler UnaryHandler) HandlerSpec

                                                                                      NewUnaryHandlerSpec returns an new HandlerSpec with a UnaryHandler

                                                                                      func (HandlerSpec) MarshalLogObject

                                                                                      func (h HandlerSpec) MarshalLogObject(enc zapcore.ObjectEncoder) error

                                                                                        MarshalLogObject implements zap.ObjectMarshaler.

                                                                                        func (HandlerSpec) Oneway

                                                                                        func (h HandlerSpec) Oneway() OnewayHandler

                                                                                          Oneway returns the Oneway Handler or nil

                                                                                          func (HandlerSpec) Stream

                                                                                          func (h HandlerSpec) Stream() StreamHandler

                                                                                            Stream returns the Stream Handler or nil

                                                                                            func (HandlerSpec) Type

                                                                                            func (h HandlerSpec) Type() Type

                                                                                              Type returns the associated handler's type

                                                                                              func (HandlerSpec) Unary

                                                                                              func (h HandlerSpec) Unary() UnaryHandler

                                                                                                Unary returns the Unary Handler or nil

                                                                                                type Headers

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

                                                                                                  Headers is the transport-level representation of application headers.

                                                                                                  var headers transport.Headers
                                                                                                  headers = headers.With("foo", "bar")
                                                                                                  headers = headers.With("baz", "qux")
                                                                                                  

                                                                                                  func HeadersFromMap

                                                                                                  func HeadersFromMap(m map[string]string) Headers

                                                                                                    HeadersFromMap builds a new Headers object from the given map of header key-value pairs.

                                                                                                    func NewHeaders

                                                                                                    func NewHeaders() Headers

                                                                                                      NewHeaders builds a new Headers object.

                                                                                                      func NewHeadersWithCapacity

                                                                                                      func NewHeadersWithCapacity(capacity int) Headers

                                                                                                        NewHeadersWithCapacity allocates a new Headers object with the given capacity. A capacity of zero or less is ignored.

                                                                                                        func ReadStreamHeaders

                                                                                                        func ReadStreamHeaders(s Stream) (Headers, error)

                                                                                                          ReadStreamHeaders conditionally type asserts a Stream to a StreamHeadersReader to read the received headers.

                                                                                                          func (Headers) Del

                                                                                                          func (h Headers) Del(k string)

                                                                                                            Del deletes the header with the given name from the Headers map.

                                                                                                            This is a no-op if the key does not exist.

                                                                                                            func (Headers) Get

                                                                                                            func (h Headers) Get(k string) (string, bool)

                                                                                                              Get retrieves the value associated with the given header name.

                                                                                                              func (Headers) Items

                                                                                                              func (h Headers) Items() map[string]string

                                                                                                                Items returns the underlying map for this Headers object. The returned map MUST NOT be changed. Doing so will result in undefined behavior.

                                                                                                                Keys in the map are normalized using CanonicalizeHeaderKey.

                                                                                                                func (Headers) Len

                                                                                                                func (h Headers) Len() int

                                                                                                                  Len returns the number of headers defined on this object.

                                                                                                                  func (Headers) OriginalItems

                                                                                                                  func (h Headers) OriginalItems() map[string]string

                                                                                                                    OriginalItems returns the non-canonicalized version of the underlying map for this Headers object. The returned map MUST NOT be changed. Doing so will result in undefined behavior.

                                                                                                                    func (Headers) With

                                                                                                                    func (h Headers) With(k, v string) Headers

                                                                                                                      With returns a Headers object with the given key-value pair added to it.

                                                                                                                      The returned object MAY not point to the same Headers underlying data store as the original Headers so the returned Headers MUST always be used instead of the original object.

                                                                                                                      headers = headers.With("foo", "bar").With("baz", "qux")
                                                                                                                      

                                                                                                                      type Inbound

                                                                                                                      type Inbound interface {
                                                                                                                      	Lifecycle
                                                                                                                      
                                                                                                                      	// SetRouter configures the inbound to dispatch requests through a
                                                                                                                      	// router, typically called by a Dispatcher with its RouteTable of handled
                                                                                                                      	// procedures.
                                                                                                                      	// Inbound.Start MAY panic if SetRouter was not called.
                                                                                                                      	SetRouter(Router)
                                                                                                                      
                                                                                                                      	// Transport returns any transports that the inbound uses, so they can be
                                                                                                                      	// collected for lifecycle management, typically by a Dispatcher.
                                                                                                                      	// An inbound may submit zero or more transports.
                                                                                                                      	Transports() []Transport
                                                                                                                      }

                                                                                                                        Inbound is a transport that knows how to receive requests for procedure calls.

                                                                                                                        type Lifecycle

                                                                                                                        type Lifecycle interface {
                                                                                                                        	// Start the lifecycle object, returns an error if it cannot be started.
                                                                                                                        	// Start MUST be idempotent.
                                                                                                                        	Start() error
                                                                                                                        
                                                                                                                        	// Stop the lifecycle object, returns an error if it cannot be stopped.
                                                                                                                        	// Stop MUST be idempotent.
                                                                                                                        	Stop() error
                                                                                                                        
                                                                                                                        	// IsRunning returns whether the Lifecycle is currently running.
                                                                                                                        	//
                                                                                                                        	// This function exists for introspection purposes only. It should not be
                                                                                                                        	// used to assert the state of the lifecycle.
                                                                                                                        	IsRunning() bool
                                                                                                                        }

                                                                                                                          Lifecycle objects are used to define a common Start/Stop functionality across different transport objects.

                                                                                                                          type Namer

                                                                                                                          type Namer interface {
                                                                                                                          	TransportName() string
                                                                                                                          }

                                                                                                                            Namer is an additional interface that Outbounds may implement in order properly set the transport.Request#Transport field.

                                                                                                                            This interface is not embeded into Outbound to preserve backwards compatiblity.

                                                                                                                            type OnewayHandler

                                                                                                                            type OnewayHandler interface {
                                                                                                                            	// Handle the given oneway request
                                                                                                                            	//
                                                                                                                            	// An error may be returned in case of failures.
                                                                                                                            	HandleOneway(ctx context.Context, req *Request) error
                                                                                                                            }

                                                                                                                              OnewayHandler handles a single, transport-level, oneway request.

                                                                                                                              type OnewayInvokeRequest

                                                                                                                              type OnewayInvokeRequest struct {
                                                                                                                              	Context context.Context
                                                                                                                              	Request *Request
                                                                                                                              	Handler OnewayHandler
                                                                                                                              	Logger  *zap.Logger // optional
                                                                                                                              }

                                                                                                                                OnewayInvokeRequest encapsulates arguments to invoke a unary handler.

                                                                                                                                type OnewayOutbound

                                                                                                                                type OnewayOutbound interface {
                                                                                                                                	Outbound
                                                                                                                                
                                                                                                                                	// CallOneway sends the given request through this transport and returns an
                                                                                                                                	// ack.
                                                                                                                                	//
                                                                                                                                	// This MUST NOT be called before Start() has been called successfully. This
                                                                                                                                	// MAY panic if called without calling Start(). This MUST be safe to call
                                                                                                                                	// concurrently.
                                                                                                                                	CallOneway(ctx context.Context, request *Request) (Ack, error)
                                                                                                                                }

                                                                                                                                  OnewayOutbound is a transport that knows how to send oneway requests for procedure calls.

                                                                                                                                  type Outbound

                                                                                                                                  type Outbound interface {
                                                                                                                                  	Lifecycle
                                                                                                                                  
                                                                                                                                  	// Transports returns the transports that used by this outbound, so they
                                                                                                                                  	// can be collected for lifecycle management, typically by a Dispatcher.
                                                                                                                                  	//
                                                                                                                                  	// Though most outbounds only use a single transport, composite outbounds
                                                                                                                                  	// may use multiple transport protocols, particularly for shadowing traffic
                                                                                                                                  	// across multiple transport protocols during a transport protocol
                                                                                                                                  	// migration.
                                                                                                                                  	Transports() []Transport
                                                                                                                                  }

                                                                                                                                    Outbound is the common interface for all outbounds.

                                                                                                                                    Outbounds should also implement the Namer interface so that YARPC can properly update the Request.Transport field.

                                                                                                                                    type OutboundConfig

                                                                                                                                    type OutboundConfig struct {
                                                                                                                                    	CallerName string
                                                                                                                                    	Outbounds  Outbounds
                                                                                                                                    }

                                                                                                                                      OutboundConfig is a configuration for how to call into another service. It is used in conjunction with an encoding to send a request through one of the outbounds.

                                                                                                                                      func (*OutboundConfig) Caller

                                                                                                                                      func (o *OutboundConfig) Caller() string

                                                                                                                                        Caller is the name of the service making the request.

                                                                                                                                        Implements ClientConfig#Caller (for backwards compatibility).

                                                                                                                                        func (*OutboundConfig) GetOnewayOutbound

                                                                                                                                        func (o *OutboundConfig) GetOnewayOutbound() OnewayOutbound

                                                                                                                                          GetOnewayOutbound returns an outbound to send the request through or panics if there is no oneway outbound for this service.

                                                                                                                                          Implements ClientConfig#GetOnewayOutbound.

                                                                                                                                          func (*OutboundConfig) GetUnaryOutbound

                                                                                                                                          func (o *OutboundConfig) GetUnaryOutbound() UnaryOutbound

                                                                                                                                            GetUnaryOutbound returns an outbound to send the request through or panics if there is no unary outbound for this service.

                                                                                                                                            Implements ClientConfig#GetUnaryOutbound.

                                                                                                                                            func (*OutboundConfig) Service

                                                                                                                                            func (o *OutboundConfig) Service() string

                                                                                                                                              Service is the name of the service to which the request is being made.

                                                                                                                                              Implements ClientConfig#Service (for backwards compatibility).

                                                                                                                                              type Outbounds

                                                                                                                                              type Outbounds struct {
                                                                                                                                              	ServiceName string
                                                                                                                                              
                                                                                                                                              	// If set, this is the unary outbound which sends a request and waits for
                                                                                                                                              	// the response.
                                                                                                                                              	Unary UnaryOutbound
                                                                                                                                              
                                                                                                                                              	// If set, this is the oneway outbound which sends the request and
                                                                                                                                              	// continues once the message has been delivered.
                                                                                                                                              	Oneway OnewayOutbound
                                                                                                                                              
                                                                                                                                              	// If set, this is the stream outbound which creates a ClientStream that can
                                                                                                                                              	// be used to continuously send/recv requests over the connection.
                                                                                                                                              	Stream StreamOutbound
                                                                                                                                              }

                                                                                                                                                Outbounds encapsulates the outbound specification for a service.

                                                                                                                                                This includes the service name that will be used for outbound requests as well as the Outbound that will be used to transport the request. The outbound will be one of Unary and Oneway.

                                                                                                                                                type Procedure

                                                                                                                                                type Procedure struct {
                                                                                                                                                	// Name of the procedure.
                                                                                                                                                	Name string
                                                                                                                                                
                                                                                                                                                	// Service or empty to use the default service name.
                                                                                                                                                	Service string
                                                                                                                                                
                                                                                                                                                	// HandlerSpec specifying which handler and rpc type.
                                                                                                                                                	HandlerSpec HandlerSpec
                                                                                                                                                
                                                                                                                                                	// Encoding of the handler (optional) used for introspection and routing
                                                                                                                                                	// (if present).
                                                                                                                                                	Encoding Encoding
                                                                                                                                                
                                                                                                                                                	// Signature of the handler, for introspection. This should be a snippet of
                                                                                                                                                	// Go code representing the function definition.
                                                                                                                                                	Signature string
                                                                                                                                                }

                                                                                                                                                  Procedure specifies a single handler registered in the RouteTable.

                                                                                                                                                  func (Procedure) Less

                                                                                                                                                  func (p Procedure) Less(o Procedure) bool

                                                                                                                                                    Less orders procedures lexicographically on (Service, Name, Encoding).

                                                                                                                                                    func (Procedure) MarshalLogObject

                                                                                                                                                    func (p Procedure) MarshalLogObject(enc zapcore.ObjectEncoder) error

                                                                                                                                                      MarshalLogObject implements zap.ObjectMarshaler.

                                                                                                                                                      type Request

                                                                                                                                                      type Request struct {
                                                                                                                                                      	// Name of the service making the request.
                                                                                                                                                      	Caller string
                                                                                                                                                      
                                                                                                                                                      	// Name of the service to which the request is being made.
                                                                                                                                                      	// The service refers to the canonical traffic group for the service.
                                                                                                                                                      	Service string
                                                                                                                                                      
                                                                                                                                                      	// Name of the transport used for the call.
                                                                                                                                                      	Transport string
                                                                                                                                                      
                                                                                                                                                      	// Name of the encoding used for the request body.
                                                                                                                                                      	Encoding Encoding
                                                                                                                                                      
                                                                                                                                                      	// Name of the procedure being called.
                                                                                                                                                      	Procedure string
                                                                                                                                                      
                                                                                                                                                      	// Headers for the request.
                                                                                                                                                      	Headers Headers
                                                                                                                                                      
                                                                                                                                                      	// ShardKey is an opaque string that is meaningful to the destined service
                                                                                                                                                      	// for how to relay a request within a cluster to the shard that owns the
                                                                                                                                                      	// key.
                                                                                                                                                      	ShardKey string
                                                                                                                                                      
                                                                                                                                                      	// RoutingKey refers to a traffic group for the destined service, and when
                                                                                                                                                      	// present may override the service name for purposes of routing.
                                                                                                                                                      	RoutingKey string
                                                                                                                                                      
                                                                                                                                                      	// RoutingDelegate refers to the traffic group for a service that proxies
                                                                                                                                                      	// for the destined service for routing purposes. The routing delegate may
                                                                                                                                                      	// override the routing key and service.
                                                                                                                                                      	RoutingDelegate string
                                                                                                                                                      
                                                                                                                                                      	// Request payload.
                                                                                                                                                      	Body io.Reader
                                                                                                                                                      
                                                                                                                                                      	// Request payload size before any compression applied by the protocol
                                                                                                                                                      	// When using the HTTP transport, this value is set from the HTTP header
                                                                                                                                                      	// content-length. It should be noted that this value is set manually and
                                                                                                                                                      	// will not be updated automatically if the body is being modified
                                                                                                                                                      	BodySize int
                                                                                                                                                      }

                                                                                                                                                        Request is the low level request representation.

                                                                                                                                                        func (*Request) MarshalLogObject

                                                                                                                                                        func (r *Request) MarshalLogObject(enc zapcore.ObjectEncoder) error

                                                                                                                                                          MarshalLogObject implements zap.ObjectMarshaler.

                                                                                                                                                          func (*Request) ToRequestMeta

                                                                                                                                                          func (r *Request) ToRequestMeta() *RequestMeta

                                                                                                                                                            ToRequestMeta converts a Request into a RequestMeta.

                                                                                                                                                            type RequestMeta

                                                                                                                                                            type RequestMeta struct {
                                                                                                                                                            	// Name of the service making the request.
                                                                                                                                                            	Caller string
                                                                                                                                                            
                                                                                                                                                            	// Name of the service to which the request is being made.
                                                                                                                                                            	// The service refers to the canonical traffic group for the service.
                                                                                                                                                            	Service string
                                                                                                                                                            
                                                                                                                                                            	// Name of the transport used for the call.
                                                                                                                                                            	Transport string
                                                                                                                                                            
                                                                                                                                                            	// Name of the encoding used for the request body.
                                                                                                                                                            	Encoding Encoding
                                                                                                                                                            
                                                                                                                                                            	// Name of the procedure being called.
                                                                                                                                                            	Procedure string
                                                                                                                                                            
                                                                                                                                                            	// Headers for the request.
                                                                                                                                                            	Headers Headers
                                                                                                                                                            
                                                                                                                                                            	// ShardKey is an opaque string that is meaningful to the destined service
                                                                                                                                                            	// for how to relay a request within a cluster to the shard that owns the
                                                                                                                                                            	// key.
                                                                                                                                                            	ShardKey string
                                                                                                                                                            
                                                                                                                                                            	// RoutingKey refers to a traffic group for the destined service, and when
                                                                                                                                                            	// present may override the service name for purposes of routing.
                                                                                                                                                            	RoutingKey string
                                                                                                                                                            
                                                                                                                                                            	// RoutingDelegate refers to the traffic group for a service that proxies
                                                                                                                                                            	// for the destined service for routing purposes. The routing delegate may
                                                                                                                                                            	// override the routing key and service.
                                                                                                                                                            	RoutingDelegate string
                                                                                                                                                            }

                                                                                                                                                              RequestMeta is the low level request metadata representation. It does not include any "body" information, and should only be used for information about a connection's metadata.

                                                                                                                                                              func (*RequestMeta) ToRequest

                                                                                                                                                              func (r *RequestMeta) ToRequest() *Request

                                                                                                                                                                ToRequest converts a RequestMeta into a Request.

                                                                                                                                                                type Response

                                                                                                                                                                type Response struct {
                                                                                                                                                                	Headers Headers
                                                                                                                                                                	Body    io.ReadCloser
                                                                                                                                                                	// Response payload size before any compression applied by the protocol
                                                                                                                                                                	// When using the HTTP transport, this value is set from the HTTP header
                                                                                                                                                                	// content-length. It should be noted that this value is set manually and
                                                                                                                                                                	// will not be updated automatically if the body is being modified
                                                                                                                                                                	BodySize int
                                                                                                                                                                
                                                                                                                                                                	ApplicationError bool
                                                                                                                                                                	// ApplicationErrorMeta adds information about the application error.
                                                                                                                                                                	// This field will only be set if `ApplicationError` is true.
                                                                                                                                                                	ApplicationErrorMeta *ApplicationErrorMeta
                                                                                                                                                                }

                                                                                                                                                                  Response is the low level response representation.

                                                                                                                                                                  type ResponseWriter

                                                                                                                                                                  type ResponseWriter interface {
                                                                                                                                                                  	io.Writer
                                                                                                                                                                  
                                                                                                                                                                  	// AddHeaders adds the given headers to the response. If called, this MUST
                                                                                                                                                                  	// be called before any invocation of Write().
                                                                                                                                                                  	//
                                                                                                                                                                  	// This MUST NOT panic if Headers is nil.
                                                                                                                                                                  	AddHeaders(Headers)
                                                                                                                                                                  
                                                                                                                                                                  	// SetApplicationError specifies that this response contains an
                                                                                                                                                                  	// application error. If called, this MUST be called before any invocation
                                                                                                                                                                  	// of Write().
                                                                                                                                                                  	SetApplicationError()
                                                                                                                                                                  }

                                                                                                                                                                    ResponseWriter allows Handlers to write responses in a streaming fashion.

                                                                                                                                                                    Functions on ResponseWriter are not thread-safe.

                                                                                                                                                                    type RouteTable

                                                                                                                                                                    type RouteTable interface {
                                                                                                                                                                    	Router
                                                                                                                                                                    
                                                                                                                                                                    	// Registers zero or more procedures with the route table.
                                                                                                                                                                    	Register([]Procedure)
                                                                                                                                                                    }

                                                                                                                                                                      RouteTable is an mutable interface for a Router that allows Registering new Procedures

                                                                                                                                                                      type Router

                                                                                                                                                                      type Router interface {
                                                                                                                                                                      	// Procedures returns a list of procedures that
                                                                                                                                                                      	// have been registered so far.
                                                                                                                                                                      	Procedures() []Procedure
                                                                                                                                                                      
                                                                                                                                                                      	// Choose decides a handler based on a context and transport request
                                                                                                                                                                      	// metadata, or returns an UnrecognizedProcedureError if no handler exists
                                                                                                                                                                      	// for the request.  This is the interface for use in inbound transports to
                                                                                                                                                                      	// select a handler for a request.
                                                                                                                                                                      	Choose(ctx context.Context, req *Request) (HandlerSpec, error)
                                                                                                                                                                      }

                                                                                                                                                                        Router maintains and provides access to a collection of procedures

                                                                                                                                                                        type ServerStream

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

                                                                                                                                                                          ServerStream represents the Server API of interacting with a Stream.

                                                                                                                                                                          func NewServerStream

                                                                                                                                                                          func NewServerStream(s Stream, options ...ServerStreamOption) (*ServerStream, error)

                                                                                                                                                                            NewServerStream will create a new ServerStream. The Stream can implement StreamHeadersSender if the underlying transport supports stream headers.

                                                                                                                                                                            func (*ServerStream) Context

                                                                                                                                                                            func (s *ServerStream) Context() context.Context

                                                                                                                                                                              Context returns the context for the stream.

                                                                                                                                                                              func (*ServerStream) ReceiveMessage

                                                                                                                                                                              func (s *ServerStream) ReceiveMessage(ctx context.Context) (*StreamMessage, error)

                                                                                                                                                                                ReceiveMessage blocks until a message is received from the connection. It returns an io.Reader with the contents of the message.

                                                                                                                                                                                func (*ServerStream) Request

                                                                                                                                                                                func (s *ServerStream) Request() *StreamRequest

                                                                                                                                                                                  Request contains all the metadata about the request.

                                                                                                                                                                                  func (*ServerStream) SendHeaders

                                                                                                                                                                                  func (s *ServerStream) SendHeaders(headers Headers) error

                                                                                                                                                                                    SendHeaders sends the one-time response headers to an initial stream connect. It fails if called multiple times.

                                                                                                                                                                                    func (*ServerStream) SendMessage

                                                                                                                                                                                    func (s *ServerStream) SendMessage(ctx context.Context, msg *StreamMessage) error

                                                                                                                                                                                      SendMessage sends a request over the stream. It blocks until the message has been sent. In certain implementations, the timeout on the context will be used to timeout the request.

                                                                                                                                                                                      type ServerStreamOption

                                                                                                                                                                                      type ServerStreamOption interface {
                                                                                                                                                                                      	// contains filtered or unexported methods
                                                                                                                                                                                      }

                                                                                                                                                                                        ServerStreamOption are options to configure a ServerStream. There are no current ServerStreamOptions implemented.

                                                                                                                                                                                        type Stream

                                                                                                                                                                                        type Stream interface {
                                                                                                                                                                                        	// Context returns the context for the stream.
                                                                                                                                                                                        	Context() context.Context
                                                                                                                                                                                        
                                                                                                                                                                                        	// Request contains all the metadata about the request.
                                                                                                                                                                                        	Request() *StreamRequest
                                                                                                                                                                                        
                                                                                                                                                                                        	// SendMessage sends a request over the stream. It blocks until the message
                                                                                                                                                                                        	// has been sent.  In certain implementations, the timeout on the context
                                                                                                                                                                                        	// will be used to timeout the request.
                                                                                                                                                                                        	SendMessage(context.Context, *StreamMessage) error
                                                                                                                                                                                        
                                                                                                                                                                                        	// ReceiveMessage blocks until a message is received from the connection. It
                                                                                                                                                                                        	// returns an io.Reader with the contents of the message.
                                                                                                                                                                                        	ReceiveMessage(context.Context) (*StreamMessage, error)
                                                                                                                                                                                        }

                                                                                                                                                                                          Stream is an interface for interacting with a stream.

                                                                                                                                                                                          type StreamCloser

                                                                                                                                                                                          type StreamCloser interface {
                                                                                                                                                                                          	Stream
                                                                                                                                                                                          
                                                                                                                                                                                          	// Close will close the connection. It blocks until the server has
                                                                                                                                                                                          	// acknowledged the close. The provided context controls the timeout for
                                                                                                                                                                                          	// this operation if the implementation supports it. If the server timed out
                                                                                                                                                                                          	// the connection will be forced closed by the client.
                                                                                                                                                                                          	Close(context.Context) error
                                                                                                                                                                                          }

                                                                                                                                                                                            StreamCloser represents an API of interacting with a Stream that is closable.

                                                                                                                                                                                            type StreamHandler

                                                                                                                                                                                            type StreamHandler interface {
                                                                                                                                                                                            	// Handle the given stream connection.  The stream will close when the
                                                                                                                                                                                            	// function returns.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// An error may be returned in case of failures.
                                                                                                                                                                                            	HandleStream(stream *ServerStream) error
                                                                                                                                                                                            }

                                                                                                                                                                                              StreamHandler handles a stream connection request.

                                                                                                                                                                                              type StreamHeadersReader

                                                                                                                                                                                              type StreamHeadersReader interface {
                                                                                                                                                                                              	Headers() (Headers, error)
                                                                                                                                                                                              }

                                                                                                                                                                                                StreamHeadersReader is the interface for reading stream headers.

                                                                                                                                                                                                type StreamHeadersSender

                                                                                                                                                                                                type StreamHeadersSender interface {
                                                                                                                                                                                                	SendHeaders(headers Headers) error
                                                                                                                                                                                                }

                                                                                                                                                                                                  StreamHeadersSender is the interface for sending stream headers.

                                                                                                                                                                                                  type StreamInvokeRequest

                                                                                                                                                                                                  type StreamInvokeRequest struct {
                                                                                                                                                                                                  	Stream  *ServerStream
                                                                                                                                                                                                  	Handler StreamHandler
                                                                                                                                                                                                  	Logger  *zap.Logger // optional
                                                                                                                                                                                                  }

                                                                                                                                                                                                    StreamInvokeRequest encapsulates arguments to invoke a unary handler.

                                                                                                                                                                                                    type StreamMessage

                                                                                                                                                                                                    type StreamMessage struct {
                                                                                                                                                                                                    	Body     io.ReadCloser
                                                                                                                                                                                                    	BodySize int
                                                                                                                                                                                                    }

                                                                                                                                                                                                      StreamMessage represents information that can be read off of an individual message in the stream.

                                                                                                                                                                                                      type StreamOutbound

                                                                                                                                                                                                      type StreamOutbound interface {
                                                                                                                                                                                                      	Outbound
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// CallStream creates a stream connection based on the metadata in the
                                                                                                                                                                                                      	// request passed in.  If there is a timeout on the context, this timeout
                                                                                                                                                                                                      	// is for establishing a connection, and not for the lifetime of the stream.
                                                                                                                                                                                                      	CallStream(ctx context.Context, request *StreamRequest) (*ClientStream, error)
                                                                                                                                                                                                      }

                                                                                                                                                                                                        StreamOutbound is a transport that knows how to send stream requests for procedure calls.

                                                                                                                                                                                                        type StreamRequest

                                                                                                                                                                                                        type StreamRequest struct {
                                                                                                                                                                                                        	Meta *RequestMeta
                                                                                                                                                                                                        }

                                                                                                                                                                                                          StreamRequest represents a streaming request. It contains basic stream metadata.

                                                                                                                                                                                                          type Transport

                                                                                                                                                                                                          type Transport interface {
                                                                                                                                                                                                          	Lifecycle
                                                                                                                                                                                                          }

                                                                                                                                                                                                            Transport is the interface needed by a Dispatcher to manage the life cycle of a transport.

                                                                                                                                                                                                            type Type

                                                                                                                                                                                                            type Type int

                                                                                                                                                                                                              Type is an enum of RPC types

                                                                                                                                                                                                              const (
                                                                                                                                                                                                              	// Unary types are traditional request/response RPCs
                                                                                                                                                                                                              	Unary Type = iota + 1
                                                                                                                                                                                                              	// Oneway types are fire and forget RPCs (no response)
                                                                                                                                                                                                              	Oneway
                                                                                                                                                                                                              	// Streaming types are Stream based RPCs (bidirectional messages over long
                                                                                                                                                                                                              	// lived connections)
                                                                                                                                                                                                              	Streaming
                                                                                                                                                                                                              )

                                                                                                                                                                                                              func (Type) String

                                                                                                                                                                                                              func (i Type) String() string

                                                                                                                                                                                                              type UnaryHandler

                                                                                                                                                                                                              type UnaryHandler interface {
                                                                                                                                                                                                              	// Handle the given request, writing the response to the given
                                                                                                                                                                                                              	// ResponseWriter.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// An error may be returned in case of failures. BadRequestError must be
                                                                                                                                                                                                              	// returned for invalid requests. All other failures are treated as
                                                                                                                                                                                                              	// UnexpectedErrors.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// Handlers MUST NOT retain references to the ResponseWriter.
                                                                                                                                                                                                              	Handle(ctx context.Context, req *Request, resw ResponseWriter) error
                                                                                                                                                                                                              }

                                                                                                                                                                                                                UnaryHandler handles a single, transport-level, unary request.

                                                                                                                                                                                                                type UnaryInvokeRequest

                                                                                                                                                                                                                type UnaryInvokeRequest struct {
                                                                                                                                                                                                                	Context        context.Context
                                                                                                                                                                                                                	StartTime      time.Time
                                                                                                                                                                                                                	Request        *Request
                                                                                                                                                                                                                	ResponseWriter ResponseWriter
                                                                                                                                                                                                                	Handler        UnaryHandler
                                                                                                                                                                                                                	Logger         *zap.Logger // optional
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  UnaryInvokeRequest encapsulates arguments to invoke a unary handler.

                                                                                                                                                                                                                  type UnaryOutbound

                                                                                                                                                                                                                  type UnaryOutbound interface {
                                                                                                                                                                                                                  	Outbound
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Call sends the given request through this transport and returns its
                                                                                                                                                                                                                  	// response.
                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                  	// This MUST NOT be called before Start() has been called successfully. This
                                                                                                                                                                                                                  	// MAY panic if called without calling Start(). This MUST be safe to call
                                                                                                                                                                                                                  	// concurrently.
                                                                                                                                                                                                                  	Call(ctx context.Context, request *Request) (*Response, error)
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    UnaryOutbound is a transport that knows how to send unary requests for procedure calls.

                                                                                                                                                                                                                    Directories

                                                                                                                                                                                                                    Path Synopsis
                                                                                                                                                                                                                    Package transporttest is a generated GoMock package.
                                                                                                                                                                                                                    Package transporttest is a generated GoMock package.