Failed to receive status rpc error code unavailable desc transport is closing

Code returns the error code for err if it was produced by the rpc system.
Otherwise, it returns codes.Unknown.

Deprecated: use status.Code instead.

ErrorDesc returns the error description of err if it was produced by the rpc system.
Otherwise, it returns err.Error() or empty string when err is nil.

Deprecated: use status.Convert and Message method instead.

Errorf returns an error containing an error code and a description;
Errorf returns nil if c is OK.

Deprecated: use status.Errorf instead.

BackoffConfig defines the parameters for the default gRPC backoff strategy.

Deprecated: use ConnectParams instead. Will be supported throughout 1.x.

type CallOption interface {
	
}

func CallContentSubtype ¶

added in
v1.10.0

func CallContentSubtype(contentSubtype string) CallOption

CallContentSubtype returns a CallOption that will set the content-subtype
for a call. For example, if content-subtype is «json», the Content-Type over
the wire will be «application/grpc+json». The content-subtype is converted
to lowercase before being included in Content-Type. See Content-Type on
https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
more details.

If ForceCodec is not also used, the content-subtype will be used to look up
the Codec to use in the registry controlled by RegisterCodec. See the
documentation on RegisterCodec for details on registration. The lookup of
content-subtype is case-insensitive. If no such Codec is found, the call
will result in an error with code codes.Internal.

If ForceCodec is also used, that Codec will be used for all request and
response messages, with the content-subtype set to the given contentSubtype
here for requests.

ForceCodec returns a CallOption that will set codec to be used for all
request and response messages for a call. The result of calling Name() will
be used as the content-subtype after converting to lowercase, unless
CallContentSubtype is also used.

See Content-Type on
https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
more details. Also see the documentation on RegisterCodec and
CallContentSubtype for more details on the interaction between Codec and
content-subtype.

This function is provided for advanced users; prefer to use only
CallContentSubtype to select a registered codec instead.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

Header returns a CallOptions that retrieves the header metadata
for a unary RPC.

func MaxCallRecvMsgSize(bytes int) CallOption

MaxCallRecvMsgSize returns a CallOption which sets the maximum message size
in bytes the client can receive. If this is not set, gRPC uses the default
4MB.

func MaxCallSendMsgSize(bytes int) CallOption

MaxCallSendMsgSize returns a CallOption which sets the maximum message size
in bytes the client can send. If this is not set, gRPC uses the default
`math.MaxInt32`.

func MaxRetryRPCBufferSize(bytes int) CallOption

MaxRetryRPCBufferSize returns a CallOption that limits the amount of memory
used for buffering this RPC’s requests for retry purposes.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

Peer returns a CallOption that retrieves peer information for a unary RPC.
The peer field will be populated *after* the RPC completes.

PerRPCCredentials returns a CallOption that sets credentials.PerRPCCredentials
for a call.

Trailer returns a CallOptions that retrieves the trailer metadata
for a unary RPC.

UseCompressor returns a CallOption which sets the compressor used when
sending the request. If WithCompressor is also set, UseCompressor has
higher priority.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func WaitForReady(waitForReady bool) CallOption

WaitForReady configures the action to take when an RPC is attempted on broken
connections or unreachable servers. If waitForReady is false and the
connection is in the TRANSIENT_FAILURE state, the RPC will fail
immediately. Otherwise, the RPC client will block the call until a
connection is available (or the call is canceled or times out) and will
retry the call if it fails due to a transient error. gRPC will not retry if
data was written to the wire unless the server indicates it did not process
the data. Please refer to
https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md.

By default, RPCs don’t «wait for ready».

type ClientConn struct {
	
}

Dial creates a client connection to the given target.

DialContext creates a client connection to the given target. By default, it’s
a non-blocking dial (the function won’t wait for connections to be
established, and connecting happens in the background). To make it a blocking
dial, use WithBlock() dial option.

In the non-blocking case, the ctx does not act against the connection. It
only controls the setup steps.

In the blocking case, ctx can be used to cancel or expire the pending
connection. Once this function returns, the cancellation and expiration of
ctx will be noop. Users should call ClientConn.Close to terminate all the
pending operations after this function returns.

The target name syntax is defined in
https://github.com/grpc/grpc/blob/master/doc/naming.md.
e.g. to use dns resolver, a «dns:///» prefix should be applied to the target.

Close tears down the ClientConn and all underlying connections.

func (cc *ClientConn) Connect()

Connect causes all subchannels in the ClientConn to attempt to connect if
the channel is idle. Does not wait for the connection attempts to begin
before returning.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a later
release.

func (cc *ClientConn) GetMethodConfig(method string) MethodConfig

GetMethodConfig gets the method config of the input method.
If there’s an exact match for input method (i.e. /service/method), we return
the corresponding MethodConfig.
If there isn’t an exact match for the input method, we look for the service’s default
config under the service (i.e /service/) and then for the default for all services (empty string).

If there is a default MethodConfig for the service, we return it.
Otherwise, we return an empty MethodConfig.

GetState returns the connectivity.State of ClientConn.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a later
release.

Invoke sends the RPC request on the wire and returns after response is
received. This is typically called by generated code.

All errors returned by Invoke are compatible with the status package.

NewStream creates a new Stream for the client side. This is typically
called by generated code. ctx is used for the lifetime of the stream.

To ensure resources are not leaked due to the stream returned, one of the following
actions must be performed:

1. Call Close on the ClientConn.
2. Cancel the context provided.
3. Call RecvMsg until a non-nil error is returned. A protobuf-generated
   client-streaming RPC, for instance, might use the helper function
   CloseAndRecv (note that CloseSend does not Recv, therefore is not
   guaranteed to release all resources).
4. Receive a non-nil, non-io.EOF error from Header or SendMsg.

If none of the above happen, a goroutine and a context will be leaked, and grpc
will not call the optionally-configured stats handler with a stats.End message.

func (cc *ClientConn) ResetConnectBackoff()

ResetConnectBackoff wakes up all subchannels in transient failure and causes
them to attempt another connection immediately. It also resets the backoff
times used for subsequent attempts regardless of the current state.

In general, this function should not be used. Typical service or network
outages result in a reasonable client reconnection strategy by default.
However, if a previously unavailable network becomes available, this may be
used to trigger an immediate reconnect.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

Target returns the target string of the ClientConn.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

WaitForStateChange waits until the connectivity.State of ClientConn changes from sourceState or
ctx expires. A true value is returned in former case and false in latter.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

NewClientStream is a wrapper for ClientConn.NewStream.

type Codec interface {
	
	Marshal(v interface{}) ([]byte, error)
	
	Unmarshal(data []byte, v interface{}) error
	
	
	String() string
}

Codec defines the interface gRPC uses to encode and decode messages.
Note that implementations of this interface must be thread safe;
a Codec’s methods can be called from concurrent goroutines.

Deprecated: use encoding.Codec instead.

Compressor defines the interface gRPC uses to compress a message.

Deprecated: use package encoding.

func NewGZIPCompressor() Compressor

func NewGZIPCompressorWithLevel(level int) (Compressor, error)

type CompressorCallOption struct {
	CompressorType string
}

type ContentSubtypeCallOption struct {
	ContentSubtype string
}

type CustomCodecCallOption struct {
	Codec Codec
}

Decompressor defines the interface gRPC uses to decompress a message.

Deprecated: use package encoding.

func NewGZIPDecompressor() Decompressor

type DialOption interface {
	
}

func FailOnNonTempDialError(f bool) DialOption

FailOnNonTempDialError returns a DialOption that specifies if gRPC fails on
non-temporary dial errors. If f is true, and dialer returns a non-temporary
error, gRPC will fail the connection to the network address and won’t try to
reconnect. The default value of FailOnNonTempDialError is false.

FailOnNonTempDialError only affects the initial dial, and does not do
anything useful unless you are also using WithBlock().

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

WithAuthority returns a DialOption that specifies the value to be used as the
:authority pseudo-header and as the server name in authentication handshake.

func WithBlock() DialOption

WithBlock returns a DialOption which makes callers of Dial block until the
underlying connection is up. Without this, Dial returns immediately and
connecting the server happens in background.

func WithChainStreamInterceptor(interceptors ...StreamClientInterceptor) DialOption

WithChainStreamInterceptor returns a DialOption that specifies the chained
interceptor for streaming RPCs. The first interceptor will be the outer most,
while the last interceptor will be the inner most wrapper around the real call.
All interceptors added by this method will be chained, and the interceptor
defined by WithStreamInterceptor will always be prepended to the chain.

func WithChainUnaryInterceptor(interceptors ...UnaryClientInterceptor) DialOption

WithChainUnaryInterceptor returns a DialOption that specifies the chained
interceptor for unary RPCs. The first interceptor will be the outer most,
while the last interceptor will be the inner most wrapper around the real call.
All interceptors added by this method will be chained, and the interceptor
defined by WithUnaryInterceptor will always be prepended to the chain.

WithChannelzParentID returns a DialOption that specifies the channelz ID of
current ClientConn’s parent. This function is used in nested channel creation
(e.g. grpclb dial).

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func WithConnectParams(p ConnectParams) DialOption

WithConnectParams configures the ClientConn to use the provided ConnectParams
for creating and maintaining connections to servers.

The backoff configuration specified as part of the ConnectParams overrides
all defaults specified in
https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md. Consider
using the backoff.DefaultConfig as a base, in cases where you want to
override only a subset of the backoff configuration.

WithContextDialer returns a DialOption that sets a dialer to create
connections. If FailOnNonTempDialError() is set to true, and an error is
returned by f, gRPC checks the error’s Temporary() method to decide if it
should try to reconnect to the network address.

WithCredentialsBundle returns a DialOption to set a credentials bundle for
the ClientConn.WithCreds. This should not be used together with
WithTransportCredentials.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func WithDefaultCallOptions(cos ...CallOption) DialOption

WithDefaultCallOptions returns a DialOption which sets the default
CallOptions for calls over the connection.

func WithDefaultServiceConfig(s string) DialOption

WithDefaultServiceConfig returns a DialOption that configures the default
service config, which will be used in cases where:

1. WithDisableServiceConfig is also used, or

2. The name resolver does not provide a service config or provides an
invalid service config.

The parameter s is the JSON representation of the default service config.
For more information about service configs, see:
https://github.com/grpc/grpc/blob/master/doc/service_config.md
For a simple example of usage, see:
examples/features/load_balancing/client/main.go

func WithDisableHealthCheck() DialOption

WithDisableHealthCheck disables the LB channel health checking for all
SubConns of this ClientConn.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func WithDisableRetry() DialOption

WithDisableRetry returns a DialOption that disables retries, even if the
service config enables them. This does not impact transparent retries, which
will happen automatically if no data is written to the wire or if the RPC is
unprocessed by the remote server.

func WithDisableServiceConfig() DialOption

WithDisableServiceConfig returns a DialOption that causes gRPC to ignore any
service config provided by the resolver and provides a hint to the resolver
to not fetch service configs.

Note that this dial option only disables service config from resolver. If
default service config is provided, gRPC will use the default service config.

func WithInitialConnWindowSize(s int32) DialOption

WithInitialConnWindowSize returns a DialOption which sets the value for
initial window size on a connection. The lower bound for window size is 64K
and any value smaller than that will be ignored.

func WithInitialWindowSize(s int32) DialOption

WithInitialWindowSize returns a DialOption which sets the value for initial
window size on a stream. The lower bound for window size is 64K and any value
smaller than that will be ignored.

WithKeepaliveParams returns a DialOption that specifies keepalive parameters
for the client transport.

func WithMaxHeaderListSize(s uint32) DialOption

WithMaxHeaderListSize returns a DialOption that specifies the maximum
(uncompressed) size of header list that the client is prepared to accept.

func WithNoProxy() DialOption

WithNoProxy returns a DialOption which disables the use of proxies for this
ClientConn. This is ignored if WithDialer or WithContextDialer are used.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

WithPerRPCCredentials returns a DialOption which sets credentials and places
auth state on each outbound RPC.

func WithReadBufferSize(s int) DialOption

WithReadBufferSize lets you set the size of read buffer, this determines how
much data can be read at most for each read syscall.

The default value for this buffer is 32KB. Zero or negative values will
disable read buffer for a connection so data framer can access the
underlying conn directly.

WithResolvers allows a list of resolver implementations to be registered
locally with the ClientConn without needing to be globally registered via
resolver.Register. They will be matched against the scheme used for the
current Dial only, and will take precedence over the global registry.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func WithReturnConnectionError() DialOption

WithReturnConnectionError returns a DialOption which makes the client connection
return a string containing both the last connection error that occurred and
the context.DeadlineExceeded error.
Implies WithBlock()

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func WithStatsHandler ¶

added in
v1.2.0

WithStatsHandler returns a DialOption that specifies the stats handler for
all the RPCs and underlying network connections in this ClientConn.

func WithStreamInterceptor(f StreamClientInterceptor) DialOption

WithStreamInterceptor returns a DialOption that specifies the interceptor for
streaming RPCs.

WithTransportCredentials returns a DialOption which configures a connection
level security credentials (e.g., TLS/SSL). This should not be used together
with WithCredentialsBundle.

func WithUnaryInterceptor(f UnaryClientInterceptor) DialOption

WithUnaryInterceptor returns a DialOption that specifies the interceptor for
unary RPCs.

WithUserAgent returns a DialOption that specifies a user agent string for all
the RPCs.

func WithWriteBufferSize(s int) DialOption

WithWriteBufferSize determines how much data can be batched before doing a
write on the wire. The corresponding memory allocation for this buffer will
be twice the size to keep syscalls low. The default value for this buffer is
32KB.

Zero or negative values will disable the write buffer such that each write
will be on underlying connection. Note: A Send call may not directly
translate to a write.

type EmptyCallOption struct{}

type EmptyDialOption struct{}

type EmptyServerOption struct{}

type FailFastCallOption struct {
	FailFast bool
}

type HeaderCallOption struct {
}

type MaxRecvMsgSizeCallOption struct {
	MaxRecvMsgSize int
}

type MaxRetryRPCBufferSizeCallOption struct {
	MaxRetryRPCBufferSize int
}

type MaxSendMsgSizeCallOption struct {
	MaxSendMsgSize int
}

type MethodDesc struct {
	MethodName string
	Handler    methodHandler
}

type MethodInfo struct {
	
	Name string
	
	IsClientStream bool
	
	IsServerStream bool
}

type PeerCallOption struct {
	PeerAddr *peer.Peer
}

type PreparedMsg struct {
	
}

func (p *PreparedMsg) Encode(s Stream, msg interface{}) error

Encode marshalls and compresses the message using the codec and compressor for the stream.

func NewServer(opt ...ServerOption) *Server

NewServer creates a gRPC server which has no service registered and has not
started to accept requests yet.

func (s *Server) GetServiceInfo() map[string]ServiceInfo

GetServiceInfo returns a map from service names to ServiceInfo.
Service names include the package names, in the form of <package>.<service>.

func (s *Server) GracefulStop()

GracefulStop stops the gRPC server gracefully. It stops the server from
accepting new connections and RPCs and blocks until all the pending RPCs are
finished.

func (s *Server) RegisterService(sd *ServiceDesc, ss interface{})

RegisterService registers a service and its implementation to the gRPC
server. It is called from the IDL generated code. This must be called before
invoking Serve. If ss is non-nil (for legacy code), its type is checked to
ensure it implements sd.HandlerType.

Serve accepts incoming connections on the listener lis, creating a new
ServerTransport and service goroutine for each. The service goroutines
read gRPC requests and then call the registered handlers to reply to them.
Serve returns when lis.Accept fails with fatal errors. lis will be closed when
this method returns.
Serve will return a non-nil error unless Stop or GracefulStop is called.

ServeHTTP implements the Go standard library’s http.Handler
interface by responding to the gRPC request r, by looking up
the requested gRPC method in the gRPC server s.

The provided HTTP request must have arrived on an HTTP/2
connection. When using the Go standard library’s server,
practically this means that the Request must also have arrived
over TLS.

To share one port (such as 443 for https) between gRPC and an
existing http.Handler, use a root http.Handler such as:

if r.ProtoMajor == 2 && strings.HasPrefix(
	r.Header.Get("Content-Type"), "application/grpc") {
	grpcServer.ServeHTTP(w, r)
} else {
	yourMux.ServeHTTP(w, r)
}

Note that ServeHTTP uses Go’s HTTP/2 server implementation which is totally
separate from grpc-go’s HTTP/2 server. Performance and features may vary
between the two paths. ServeHTTP does not support some gRPC features
available through grpc-go’s HTTP/2 server.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

Stop stops the gRPC server. It immediately closes all open
connections and listeners.
It cancels all active RPCs on the server side and the corresponding
pending RPCs on the client side will get notified by connection
errors.

type ServerOption interface {
	
}

func ChainStreamInterceptor(interceptors ...StreamServerInterceptor) ServerOption

ChainStreamInterceptor returns a ServerOption that specifies the chained interceptor
for streaming RPCs. The first interceptor will be the outer most,
while the last interceptor will be the inner most wrapper around the real call.
All stream interceptors added by this method will be chained.

func ChainUnaryInterceptor(interceptors ...UnaryServerInterceptor) ServerOption

ChainUnaryInterceptor returns a ServerOption that specifies the chained interceptor
for unary RPCs. The first interceptor will be the outer most,
while the last interceptor will be the inner most wrapper around the real call.
All unary interceptors added by this method will be chained.

ConnectionTimeout returns a ServerOption that sets the timeout for
connection establishment (up to and including HTTP/2 handshaking) for all
new connections. If this is not set, the default is 120 seconds. A zero or
negative value will result in an immediate timeout.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

Creds returns a ServerOption that sets credentials for server connections.

ForceServerCodec returns a ServerOption that sets a codec for message
marshaling and unmarshaling.

This will override any lookups by content-subtype for Codecs registered
with RegisterCodec.

See Content-Type on
https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
more details. Also see the documentation on RegisterCodec and
CallContentSubtype for more details on the interaction between encoding.Codec
and content-subtype.

This function is provided for advanced users; prefer to register codecs
using encoding.RegisterCodec.
The server will automatically use registered codecs based on the incoming
requests’ headers. See also
https://github.com/grpc/grpc-go/blob/master/Documentation/encoding.md#using-a-codec.
Will be supported throughout 1.x.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

HeaderTableSize returns a ServerOption that sets the size of dynamic
header table for stream.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func InTapHandle ¶

added in
v1.0.5

InTapHandle returns a ServerOption that sets the tap handle for all the server
transport to be created. Only one can be installed.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func InitialConnWindowSize(s int32) ServerOption

InitialConnWindowSize returns a ServerOption that sets window size for a connection.
The lower bound for window size is 64K and any value smaller than that will be ignored.

func InitialWindowSize(s int32) ServerOption

InitialWindowSize returns a ServerOption that sets window size for stream.
The lower bound for window size is 64K and any value smaller than that will be ignored.

KeepaliveEnforcementPolicy returns a ServerOption that sets keepalive enforcement policy for the server.

KeepaliveParams returns a ServerOption that sets keepalive and max-age parameters for the server.

func MaxConcurrentStreams(n uint32) ServerOption

MaxConcurrentStreams returns a ServerOption that will apply a limit on the number
of concurrent streams to each ServerTransport.

MaxHeaderListSize returns a ServerOption that sets the max (uncompressed) size
of header list that the server is prepared to accept.

func MaxRecvMsgSize(m int) ServerOption

MaxRecvMsgSize returns a ServerOption to set the max message size in bytes the server can receive.
If this is not set, gRPC uses the default 4MB.

func MaxSendMsgSize(m int) ServerOption

MaxSendMsgSize returns a ServerOption to set the max message size in bytes the server can send.
If this is not set, gRPC uses the default `math.MaxInt32`.

func NumStreamWorkers(numServerWorkers uint32) ServerOption

NumStreamWorkers returns a ServerOption that sets the number of worker
goroutines that should be used to process incoming streams. Setting this to
zero (default) will disable workers and spawn a new goroutine for each
stream.

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

func ReadBufferSize(s int) ServerOption

ReadBufferSize lets you set the size of read buffer, this determines how much
data can be read at most for one read syscall. The default value for this
buffer is 32KB. Zero or negative values will disable read buffer for a
connection so data framer can access the underlying conn directly.

func StatsHandler ¶

added in
v1.2.0

StatsHandler returns a ServerOption that sets the stats handler for the server.

func StreamInterceptor(i StreamServerInterceptor) ServerOption

StreamInterceptor returns a ServerOption that sets the StreamServerInterceptor for the
server. Only one stream interceptor can be installed.

func UnaryInterceptor(i UnaryServerInterceptor) ServerOption

UnaryInterceptor returns a ServerOption that sets the UnaryServerInterceptor for the
server. Only one unary interceptor can be installed. The construction of multiple
interceptors (e.g., chaining) can be implemented at the caller.

func UnknownServiceHandler ¶

added in
v1.2.0

func UnknownServiceHandler(streamHandler StreamHandler) ServerOption

UnknownServiceHandler returns a ServerOption that allows for adding a custom
unknown service handler. The provided method is a bidi-streaming RPC service
handler that will be invoked instead of returning the «unimplemented» gRPC
error whenever a request is received for an unregistered service or method.
The handling function and stream interceptor (if set) have full access to
the ServerStream, including its Context.

func WriteBufferSize(s int) ServerOption

WriteBufferSize determines how much data can be batched before doing a write
on the wire. The corresponding memory allocation for this buffer will be
twice the size to keep syscalls low. The default value for this buffer is
32KB. Zero or negative values will disable the write buffer such that each
write will be on underlying connection.
Note: A Send call may not directly translate to a write.

ServerTransportStreamFromContext returns the ServerTransportStream saved in
ctx. Returns nil if the given context has no stream associated with it
(which implies it is not an RPC invocation context).

Experimental ¶

Notice: This API is EXPERIMENTAL and may be changed or removed in a
later release.

ServiceConfig is provided by the service provider and contains parameters for how
clients that connect to the service should behave.

Deprecated: Users should not use this struct. Service config should be received
through name resolver, as specified here
https://github.com/grpc/grpc/blob/master/doc/service_config.md

type ServiceDesc struct {
	ServiceName string
	
	
	HandlerType interface{}
	Methods     []MethodDesc
	Streams     []StreamDesc
	Metadata    interface{}
}

type ServiceInfo struct {
	Methods []MethodInfo
	
	Metadata interface{}
}

type ServiceRegistrar interface {
	
	
	
	
	
	RegisterService(desc *ServiceDesc, impl interface{})
}

Stream defines the common interface a client or server stream has to satisfy.

Deprecated: See ClientStream and ServerStream documentation instead.

type StreamDesc struct {
	
	
	StreamName string        
	Handler    StreamHandler 

	
	
	
	ServerStreams bool 
	ClientStreams bool 
}

type StreamHandler func(srv interface{}, stream ServerStream) error

type StreamServerInfo struct {
	
	FullMethod string
	
	IsClientStream bool
	
	IsServerStream bool
}

type StreamServerInterceptor func(srv interface{}, ss ServerStream, info *StreamServerInfo, handler StreamHandler) error

type TrailerCallOption struct {
	TrailerAddr *metadata.MD
}

type UnaryServerInfo struct {
	
	Server interface{}
	
	FullMethod string
}

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