Package io.grpc

Class Contexts.ContextualizedServerCallListener<ReqT>

java.lang.Object

io.grpc.ServerCall.Listener<ReqT>

io.grpc.PartialForwardingServerCallListener<ReqT>

io.grpc.ForwardingServerCallListener<ReqT>

io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>

io.grpc.Contexts.ContextualizedServerCallListener<ReqT>

Enclosing class:

Contexts

private static class Contexts.ContextualizedServerCallListener<ReqT>
extends ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>

Implementation of ForwardingServerCallListener that attaches a context before dispatching calls to the delegate and detaches them after the call completes.

Nested Class Summary

Nested classes/interfaces inherited from class io.grpc.ForwardingServerCallListener

ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>

Field Summary

Fields

Modifier and Type	Field	Description
private Context	context

Constructor Summary

Constructors

Constructor	Description
ContextualizedServerCallListener(ServerCall.Listener<ReqT> delegate, Context context)

Method Summary

Modifier and Type	Method	Description
void	onCancel()	The call was cancelled and the server is encouraged to abort processing to save resources, since the client will not process any further messages.
void	onComplete()	The call is considered complete and ServerCall.Listener.onCancel() is guaranteed not to be called.
void	onHalfClose()	The client completed all message sending.
void	onMessage(ReqT message)	A request message has been received.
void	onReady()	This indicates that the call may now be capable of sending additional messages (via ServerCall.sendMessage(RespT)) without requiring excessive buffering internally.

Methods inherited from class io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener

delegate

Methods inherited from class io.grpc.PartialForwardingServerCallListener

toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

context

private final Context context

Constructor Detail

ContextualizedServerCallListener

public ContextualizedServerCallListener(ServerCall.Listener<ReqT> delegate,
                                        Context context)

Method Detail

onMessage

public void onMessage(ReqT message)

Description copied from class: ServerCall.Listener

A request message has been received. For streaming calls, there may be zero or more request messages.

Overrides:

onMessage in class ForwardingServerCallListener<ReqT>

Parameters:

message - a received request message.

onHalfClose

public void onHalfClose()

Description copied from class: ServerCall.Listener

The client completed all message sending. However, the call may still be cancelled.

Overrides:

onHalfClose in class PartialForwardingServerCallListener<ReqT>

onCancel

public void onCancel()

Description copied from class: ServerCall.Listener

The call was cancelled and the server is encouraged to abort processing to save resources, since the client will not process any further messages. Cancellations can be caused by timeouts, explicit cancellation by the client, network errors, etc.

There will be no further callbacks for the call.

Overrides:

onCancel in class PartialForwardingServerCallListener<ReqT>

onComplete

public void onComplete()

Description copied from class: ServerCall.Listener

The call is considered complete and ServerCall.Listener.onCancel() is guaranteed not to be called. However, the client is not guaranteed to have received all messages.

There will be no further callbacks for the call.

Overrides:

onComplete in class PartialForwardingServerCallListener<ReqT>

onReady

public void onReady()

Description copied from class: ServerCall.Listener

This indicates that the call may now be capable of sending additional messages (via ServerCall.sendMessage(RespT)) without requiring excessive buffering internally. This event is just a suggestion and the application is free to ignore it, however doing so may result in excessive buffering within the call.

Because there is a processing delay to deliver this notification, it is possible for concurrent writes to cause isReady() == false within this callback. Handle "spurious" notifications by checking isReady()'s current value instead of assuming it is now true. If isReady() == false the normal expectations apply, so there would be another onReady() callback.

Overrides:

onReady in class PartialForwardingServerCallListener<ReqT>