ServerCallStreamObserver (grpc-stub 1.44.0 API)

java.lang.Object
- io.grpc.stub.CallStreamObserver<RespT>
- - io.grpc.stub.ServerCallStreamObserver<RespT>

All Implemented Interfaces:

StreamObserver<RespT>
```
public abstract class ServerCallStreamObserver<RespT>
extends CallStreamObserver<RespT>
```
A refinement of CallStreamObserver to allows for interaction with call cancellation events on the server side. An instance of this class is obtained by casting the StreamObserver passed as an argument to service implementations.
Like StreamObserver, implementations are not required to be thread-safe; if multiple threads will be writing to an instance concurrently, the application must synchronize its calls.
DO NOT MOCK: The API is too complex to reliably mock. Use InProcessChannelBuilder to create "real" RPCs suitable for testing and interact with the server using a normal client stub.

Constructor Summary

Constructors
Constructor and Description

ServerCallStreamObserver()

Constructors
Constructor and Description
`ServerCallStreamObserver()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`disableAutoRequest()` Swaps to manual flow control where no message will be delivered to `StreamObserver.onNext(Object)` unless it is `request()`ed.
`abstract boolean`	`isCancelled()` Returns `true` when the call is cancelled and the server is encouraged to abort processing to save resources, since the client will not be processing any further methods.
`abstract boolean`	`isReady()` If `true`, indicates that the observer is capable of sending additional messages without requiring excessive buffering internally.
`abstract void`	`request(int count)` Requests the peer to produce `count` more messages to be delivered to the 'inbound' `StreamObserver`.
`abstract void`	`setCompression(String compression)` Sets the compression algorithm to use for the call.
`abstract void`	`setMessageCompression(boolean enable)` Sets message compression for subsequent calls to `StreamObserver.onNext(V)`.
`abstract void`	`setOnCancelHandler(Runnable onCancelHandler)` Sets a `Runnable` to be called if the call is cancelled and the server is encouraged to abort processing to save resources, since the client will not process any further messages.
`void`	`setOnCloseHandler(Runnable onCloseHandler)` Sets a `Runnable` to be executed when the call is closed cleanly from the server's point of view: either `StreamObserver.onCompleted()` or `StreamObserver.onError(Throwable)` has been called, all the messages and trailing metadata have been sent and the stream has been closed.
`abstract void`	`setOnReadyHandler(Runnable onReadyHandler)` Set a `Runnable` that will be executed every time the stream `isReady()` state changes from `false` to `true`.

Methods inherited from class io.grpc.stub.CallStreamObserver
disableAutoInboundFlowControl

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.grpc.stub.StreamObserver
onCompleted, onError, onNext

- Constructor Detail
  - ServerCallStreamObserver
```
public ServerCallStreamObserver()
```
- Method Detail
  - isCancelled
```
public abstract boolean isCancelled()
```
    Returns true when the call is cancelled and the server is encouraged to abort processing to save resources, since the client will not be processing any further methods. Cancellations can be caused by timeouts, explicit cancellation by client, network errors, and similar.
    This method may safely be called concurrently from multiple threads.
  - setOnCancelHandler
```
public abstract void setOnCancelHandler(Runnable onCancelHandler)
```
    Sets a Runnable to be called if the call is 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.
    It is guaranteed that execution of the Runnable is serialized with calls to the 'inbound' StreamObserver. That also means that the callback will be delayed if other callbacks are running; if one of those other callbacks runs for a significant amount of time it can poll isCancelled(), which is not delayed.
    This method may only be called during the initial call to the application, before the service returns its StreamObserver.
    Setting the onCancelHandler will suppress the on-cancel exception thrown by StreamObserver.onNext(V). If the caller is already handling cancellation via polling or cannot substantially benefit from observing cancellation, using a no-op onCancelHandler is useful just to suppress the onNext() exception.
    
    Parameters:
    
    onCancelHandler - to call when client has cancelled the call.
  - setCompression
```
public abstract void setCompression(String compression)
```
    Sets the compression algorithm to use for the call. May only be called before sending any messages. Default gRPC servers support the "gzip" compressor.
    It is safe to call this even if the client does not support the compression format chosen. The implementation will handle negotiation with the client and may fall back to no compression.
    
    Parameters:
    
    compression - the compression algorithm to use.
    
    Throws:
    
    IllegalArgumentException - if the compressor name can not be found.
  - disableAutoRequest
```
public void disableAutoRequest()
```
    Swaps to manual flow control where no message will be delivered to StreamObserver.onNext(Object) unless it is request()ed.
    It may only be called during the initial call to the application, before the service returns its StreamObserver.
    Note that for cases where the message is received before the service handler is invoked, this method will have no effect. This is true for:
    - MethodDescriptor.MethodType.UNARY operations.
    - MethodDescriptor.MethodType.SERVER_STREAMING operations.
  - isReady
```
public abstract boolean isReady()
```
    If true, indicates that the observer is capable of sending additional messages without requiring excessive buffering internally. This value is just a suggestion and the application is free to ignore it, however doing so may result in excessive buffering within the observer.
    If false, the runnable passed to setOnReadyHandler(java.lang.Runnable) will be called after isReady() transitions to true.
    
    Specified by:
    
    isReady in class CallStreamObserver<RespT>
  - setOnReadyHandler
```
public abstract void setOnReadyHandler(Runnable onReadyHandler)
```
    Set a Runnable that will be executed every time the stream isReady() state changes from false to true. While it is not guaranteed that the same thread will always be used to execute the Runnable, it is guaranteed that executions are serialized with calls to the 'inbound' StreamObserver.
    May only be called during the initial call to the application, before the service returns its StreamObserver.
    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 onReadyHandler callback.
    
    Specified by:
    
    setOnReadyHandler in class CallStreamObserver<RespT>
    
    Parameters:
    
    onReadyHandler - to call when peer is ready to receive more messages.
  - request
```
public abstract void request(int count)
```
    Requests the peer to produce count more messages to be delivered to the 'inbound' StreamObserver.
    This method is safe to call from multiple threads without external synchronization.
    
    Specified by:
    
    request in class CallStreamObserver<RespT>
    
    Parameters:
    
    count - more messages
  - setMessageCompression
```
public abstract void setMessageCompression(boolean enable)
```
    Sets message compression for subsequent calls to StreamObserver.onNext(V).
    
    Specified by:
    
    setMessageCompression in class CallStreamObserver<RespT>
    
    Parameters:
    
    enable - whether to enable compression.
  - setOnCloseHandler
```
@ExperimentalApi(value="https://github.com/grpc/grpc-java/issues/8467")
public void setOnCloseHandler(Runnable onCloseHandler)
```
    Sets a Runnable to be executed when the call is closed cleanly from the server's point of view: either StreamObserver.onCompleted() or StreamObserver.onError(Throwable) has been called, all the messages and trailing metadata have been sent and the stream has been closed. Note however that the client still may have not received all the messages due to network delay, client crashes, and cancellation races.
    Exactly one of onCloseHandler and onCancelHandler is guaranteed to be called when the RPC terminates.
    
    It is guaranteed that execution of onCloseHandler is serialized with calls to the 'inbound' StreamObserver. That also means that the callback will be delayed if other callbacks are running.
    
    This method may only be called during the initial call to the application, before the service returns its request observer.
    
    Parameters:
    
    onCloseHandler - to execute when the call has been closed cleanly.

Class ServerCallStreamObserver<RespT>

Constructor Summary

Method Summary

Methods inherited from class io.grpc.stub.CallStreamObserver

Methods inherited from class java.lang.Object

Methods inherited from interface io.grpc.stub.StreamObserver

Constructor Detail

ServerCallStreamObserver

Method Detail

isCancelled

setOnCancelHandler

setCompression

disableAutoRequest

isReady

setOnReadyHandler

request

setMessageCompression

setOnCloseHandler