@Override public StreamObserver<alluxio.grpc.WriteRequest> writeBlock( final StreamObserver<WriteResponse> responseObserver) { DelegationWriteHandler handler = new DelegationWriteHandler(mWorkerProcess, responseObserver); ServerCallStreamObserver<WriteResponse> serverResponseObserver = (ServerCallStreamObserver<WriteResponse>) responseObserver; serverResponseObserver.setOnCancelHandler(handler::onCancel); return handler; }
final ServerCallStreamObserver<SimpleResponse> responseObserver = (ServerCallStreamObserver<SimpleResponse>) rawResponseObserver; responseObserver.setOnReadyHandler(() -> { if (numResponses.get() < TOTAL_NUM_MESSAGES && !done.get()) { numResponses.incrementAndGet(); responseObserver.onNext(RESPONSE); if (responseObserver.isReady()) { numResponses.incrementAndGet(); responseObserver.onNext(RESPONSE); } else { break;
@Override public StreamObserver<SimpleRequest> serverBackPressure( StreamObserver<SimpleResponse> rawResponseObserver) { final ServerCallStreamObserver<SimpleResponse> responseObserver = (ServerCallStreamObserver<SimpleResponse>) rawResponseObserver; responseObserver.disableAutoInboundFlowControl(); final AtomicInteger numRequests = new AtomicInteger(); responseObserver.request(1); return new StreamObserver<SimpleRequest>() { @Override public void onNext(SimpleRequest value) { if (numRequests.incrementAndGet() < CAPPED_NUM_MESSAGES) { responseObserver.request(1); } else { for (int i = 0; i < TOTAL_NUM_MESSAGES; i++) { responseObserver.onNext(SimpleResponse.getDefaultInstance()); } responseObserver.onCompleted(); } } @Override public void onError(Throwable t) { } @Override public void onCompleted() { } }; }
@Override public void onNext(SimpleRequest value) { if (numRequests.incrementAndGet() < CAPPED_NUM_MESSAGES) { responseObserver.request(1); } else { for (int i = 0; i < TOTAL_NUM_MESSAGES; i++) { responseObserver.onNext(SimpleResponse.getDefaultInstance()); } responseObserver.onCompleted(); } }
@Override public void accept(TResponse value) { // Don't try to respond if the server has already canceled the request if (responseObserver instanceof ServerCallStreamObserver && ((ServerCallStreamObserver) responseObserver).isCancelled()) { return; } responseObserver.onNext(value); responseObserver.onCompleted(); } },
@Override public StreamObserver<ReadRequest> readBlock(StreamObserver<ReadResponse> responseObserver) { BlockReadHandler readHandler = new BlockReadHandler(GrpcExecutors.BLOCK_READER_EXECUTOR, mWorkerProcess.getWorker(BlockWorker.class), responseObserver); ServerCallStreamObserver<ReadResponse> serverCallStreamObserver = (ServerCallStreamObserver<ReadResponse>) responseObserver; serverCallStreamObserver.setOnReadyHandler(readHandler::onReady); return readHandler; }
obs.setCompression("gzip"); break; case NONE: obs.setCompression("identity"); break; case UNRECOGNIZED: obs.onError(Status.INVALID_ARGUMENT .withDescription("Unknown: " + req.getResponseCompression()) .asRuntimeException()); obs.onError(Status.UNIMPLEMENTED .withDescription("compression not supported.") .withCause(e) obs.onError(Status.fromCodeValue(req.getResponseStatus().getCode()) .withDescription(req.getResponseStatus().getMessage()) .asRuntimeException());
@Override public void onCompleted() { done.set(true); assertThat(numRequests).hasValue(TOTAL_NUM_MESSAGES); assertThat(numResponses).hasValueBetween(CAPPED_NUM_MESSAGES, CAPPED_NUM_MESSAGES + 2); responseObserver.onCompleted(); } };
@Override public void onNext(T value) { synchronized (lock) { // in theory we could implement ServerCallStreamObserver and expose isCancelled to our client, // but for current purposes we only need the StreamObserver API, so treat a cancelled observer // as something we just want to un-block from and return, and we'll trust the rest of our session // to shutdown accordingly. if (delegate instanceof ServerCallStreamObserver && ((ServerCallStreamObserver<T>) delegate).isCancelled()) { return; } while (!delegate.isReady()) { try { lock.wait(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } } delegate.onNext(value); }
@Override public StreamObserver<CreateLocalBlockRequest> createLocalBlock( StreamObserver<CreateLocalBlockResponse> responseObserver) { ShortCircuitBlockWriteHandler handler = new ShortCircuitBlockWriteHandler( mWorkerProcess.getWorker(BlockWorker.class), responseObserver); ServerCallStreamObserver<CreateLocalBlockResponse> serverCallStreamObserver = (ServerCallStreamObserver<CreateLocalBlockResponse>) responseObserver; serverCallStreamObserver.setOnCancelHandler(handler::onCancel); return handler; }
/** * Implements a unary -> unary call using {@link Mono} -> {@link Mono}. */ public static <TRequest, TResponse> void oneToOne( TRequest request, StreamObserver<TResponse> responseObserver, Function<Mono<TRequest>, Mono<TResponse>> delegate) { try { Mono<TRequest> rxRequest = Mono.just(request); Mono<TResponse> rxResponse = Preconditions.checkNotNull(delegate.apply(rxRequest)); rxResponse.subscribe( value -> { // Don't try to respond if the server has already canceled the request if (responseObserver instanceof ServerCallStreamObserver && ((ServerCallStreamObserver) responseObserver).isCancelled()) { return; } responseObserver.onNext(value); responseObserver.onCompleted(); }, throwable -> responseObserver.onError(prepareError(throwable))); } catch (Throwable throwable) { responseObserver.onError(prepareError(throwable)); } }
@Override public void streamClientCancelsBeforeResponseClosedCancels( SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) { ((ServerCallStreamObserver<?>) responseObserver).setOnCancelHandler(() -> COMPLETED.set(true)); responseObserver.onNext(SimpleResponse.getDefaultInstance()); } }
BlockingStreamObserver(CallStreamObserver<T> delegate) { this.delegate = delegate; final Runnable notifyAll = () -> { synchronized (lock) { lock.notifyAll(); // wake up our thread } }; this.delegate.setOnReadyHandler(notifyAll); if (delegate instanceof ServerCallStreamObserver) { ((ServerCallStreamObserver<T>) delegate).setOnCancelHandler(notifyAll); } }
private StreamObserver<DiscoveryRequest> createRequestHandler( StreamObserver<DiscoveryResponse> responseObserver, boolean ads, String defaultTypeUrl) { long streamId = streamCount.getAndIncrement(); Executor executor = executorGroup.next(); LOGGER.info("[{}] open stream from {}", streamId, defaultTypeUrl); callbacks.forEach(cb -> cb.onStreamOpen(streamId, defaultTypeUrl)); final DiscoveryRequestStreamObserver requestStreamObserver = new DiscoveryRequestStreamObserver(defaultTypeUrl, responseObserver, streamId, ads, executor); if (responseObserver instanceof ServerCallStreamObserver) { ((ServerCallStreamObserver) responseObserver).setOnCancelHandler(requestStreamObserver::onCancelled); } return requestStreamObserver; }