Java ServerCallStreamObserver类代码示例

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
/**
 * Implements a unary -> stream call as {@link Single} -> {@link Flowable}, where the server responds with a
 * stream of messages.
 */
public static <TRequest, TResponse> void oneToMany(
        TRequest request, StreamObserver<TResponse> responseObserver,
        Function<Single<TRequest>, Flowable<TResponse>> delegate) {
    try {
        Single<TRequest> rxRequest = Single.just(request);

        Flowable<TResponse> rxResponse = Preconditions.checkNotNull(delegate.apply(rxRequest));
        rxResponse.subscribe(new ReactivePublisherBackpressureOnReadyHandler<TResponse>(
                (ServerCallStreamObserver<TResponse>) responseObserver));
    } catch (Throwable throwable) {
        responseObserver.onError(prepareError(throwable));
    }
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
public ReactivePublisherBackpressureOnReadyHandler(ServerCallStreamObserver<T> requestStream) {
    this.requestStream = Preconditions.checkNotNull(requestStream);
    requestStream.setOnReadyHandler(this);
    requestStream.setOnCancelHandler(new Runnable() {
        @Override
        public void run() {
            subscription.cancel();
        }
    });
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
/**
 * Implements a unary -> stream call as {@link Mono} -> {@link Flux}, where the server responds with a
 * stream of messages.
 */
public static <TRequest, TResponse> void oneToMany(
        TRequest request, StreamObserver<TResponse> responseObserver,
        Function<Mono<TRequest>, Flux<TResponse>> delegate) {
    try {
        Mono<TRequest> rxRequest = Mono.just(request);

        Flux<TResponse> rxResponse = Preconditions.checkNotNull(delegate.apply(rxRequest));
        rxResponse.subscribe(new ReactivePublisherBackpressureOnReadyHandler<>(
                (ServerCallStreamObserver<TResponse>) responseObserver));
    } catch (Throwable throwable) {
        responseObserver.onError(prepareError(throwable));
    }
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
BlockingStreamObserver(String id, ServerCallStreamObserver<T> delegate) {
    this.id = id;
    this.delegate = delegate;
    this.delegate.setOnReadyHandler(this::wakeup);
    this.delegate.setOnCancelHandler(this::wakeup);
    delegate.setCompression("gzip");
    delegate.setMessageCompression(true);
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public void subscribe(@NonNull MSG_SubscriptionRequest request,
        @NonNull StreamObserver<MSG_Notification> responseObserver) {
    SubscriptionRequestTO req = converter.fromProto(request);
    resetDebugInfo(req);

    BlockingStreamObserver<MSG_Notification> resp = new BlockingStreamObserver<>(req.toString(),
            (ServerCallStreamObserver) responseObserver);

    final boolean idOnly = req.idOnly();

    store.subscribe(req, new GrpcObserverAdapter(req.toString(), resp, f -> idOnly ? converter
            .createNotificationFor(f.id()) : converter.createNotificationFor(f)));
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Test
public void testFetchById() throws Exception {
    UUID id = UUID.randomUUID();
    uut.fetchById(protoConverter.toProto(id), mock(ServerCallStreamObserver.class));

    verify(backend).fetchById(eq(id));
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Test
public void testSubscribeFacts() throws Exception {
    SubscriptionRequest req = SubscriptionRequest.catchup(FactSpec.forMark()).fromNowOn();
    when(backend.subscribe(this.reqCaptor.capture(), any())).thenReturn(null);
    uut.subscribe(new ProtoConverter().toProto(SubscriptionRequestTO.forFacts(req)), mock(
            ServerCallStreamObserver.class));

    verify(backend).subscribe(any(), any());
    assertFalse(reqCaptor.getValue().idOnly());

}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Test
public void testSubscribeIds() throws Exception {
    SubscriptionRequest req = SubscriptionRequest.catchup(FactSpec.forMark()).fromNowOn();
    when(backend.subscribe(this.reqCaptor.capture(), any())).thenReturn(null);
    uut.subscribe(new ProtoConverter().toProto(SubscriptionRequestTO.forIds(req)), mock(
            ServerCallStreamObserver.class));

    verify(backend).subscribe(any(), any());
    assertTrue(reqCaptor.getValue().idOnly());

}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public void watch(Request req, StreamObserver<Result> responseObserver) {
    logger.info("Start watching: " + req.getQuery());

    int responseNo = 0;
    final ServerCallStreamObserver responseObserver2 = (ServerCallStreamObserver) responseObserver;
    while (!responseObserver2.isCancelled()) {
        sleepUpToMiilis(1000);
        responseObserver.onNext(Result.newBuilder().setTitle(format("result %d for [%s] from backend %d", responseNo++, req.getQuery(), id)).build());
    }

    responseObserver2.setOnCancelHandler(() -> logger.warning("Request canceled!"));
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public void staticUnaryCallSetsMessageCompression(SimpleRequest request,
                                                  StreamObserver<SimpleResponse> responseObserver) {
    if (!request.equals(REQUEST_MESSAGE)) {
        responseObserver.onError(new IllegalArgumentException("Unexpected request: " + request));
        return;
    }
    ServerCallStreamObserver<SimpleResponse> callObserver =
            (ServerCallStreamObserver<SimpleResponse>) responseObserver;
    callObserver.setCompression("gzip");
    callObserver.setMessageCompression(true);
    responseObserver.onNext(RESPONSE_MESSAGE);
    responseObserver.onCompleted();
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@VisibleForTesting
GrpcSink(
    final String rpcCommandName,
    ServerCallStreamObserver<RunResponse> observer,
    ExecutorService executor) {
  // This queue is intentionally unbounded: we always act on it fairly quickly so filling up
  // RAM is not a concern but we don't want to block in the gRPC cancel/onready handlers.
  this.actionQueue = new LinkedBlockingQueue<>();
  this.exchanger = new Exchanger<>();
  this.observer = observer;
  this.observer.setOnCancelHandler(
      () -> {
        Thread commandThread = GrpcSink.this.commandThread.get();
        if (commandThread != null) {
          logger.info(
              String.format(
                  "Interrupting thread %s due to the streaming %s call being cancelled "
                      + "(likely client hang up or explicit gRPC-level cancellation)",
                  commandThread.getName(), rpcCommandName));
          commandThread.interrupt();
        }

        actionQueue.offer(SinkThreadAction.DISCONNECT);
      });
  this.observer.setOnReadyHandler(() -> actionQueue.offer(SinkThreadAction.READY));
  this.future = executor.submit(GrpcSink.this::call);
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public StreamObserver<ServerReflectionRequest> serverReflectionInfo(
    final StreamObserver<ServerReflectionResponse> responseObserver) {
  final ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver =
      (ServerCallStreamObserver<ServerReflectionResponse>) responseObserver;
  ProtoReflectionStreamObserver requestObserver =
      new ProtoReflectionStreamObserver(updateIndexIfNecessary(), serverCallStreamObserver);
  serverCallStreamObserver.setOnReadyHandler(requestObserver);
  serverCallStreamObserver.disableAutoInboundFlowControl();
  serverCallStreamObserver.request(1);
  return requestObserver;
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public StreamObserver<Messages.SimpleRequest> streamingCall(
    final StreamObserver<Messages.SimpleResponse> observer) {
  final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
      (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
  // TODO(spencerfang): flow control to stop reading when !responseObserver.isReady
  return new StreamObserver<Messages.SimpleRequest>() {
    @Override
    public void onNext(Messages.SimpleRequest value) {
      if (shutdown.get()) {
        responseObserver.onCompleted();
        return;
      }
      responseObserver.onNext(Utils.makeResponse(value));
    }

    @Override
    public void onError(Throwable t) {
      // other side closed with non OK
      responseObserver.onError(t);
    }

    @Override
    public void onCompleted() {
      // other side closed with OK
      responseObserver.onCompleted();
    }
  };
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public void streamingFromServer(
    final Messages.SimpleRequest request,
    final StreamObserver<Messages.SimpleResponse> observer) {
  // send forever, until the client cancels or we shut down
  final Messages.SimpleResponse response = Utils.makeResponse(request);
  final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
      (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
  // If the client cancels, copyWithFlowControl takes care of calling
  // responseObserver.onCompleted() for us
  StreamObservers.copyWithFlowControl(
      new Iterator<Messages.SimpleResponse>() {
        @Override
        public boolean hasNext() {
          return !shutdown.get() && !responseObserver.isCancelled();
        }

        @Override
        public Messages.SimpleResponse next() {
          return response;
        }

        @Override
        public void remove() {
          throw new UnsupportedOperationException();
        }
      },
      responseObserver);
}
 

import io.grpc.stub.ServerCallStreamObserver; //导入依赖的package包/类
@Override
public void subscribe(Subscriber<? super T> subscriber) {
    Preconditions.checkNotNull(subscriber);
    subscriber.onSubscribe(new Subscription() {
        private static final int MAX_REQUEST_RETRIES = 20;

        @Override
        public void request(long l) {
            // Some Reactive Streams implementations use Long.MAX_VALUE to indicate "all messages"; gRPC uses Integer.MAX_VALUE.
            int i = (int) Math.min(l, Integer.MAX_VALUE);

            // Very rarely, request() gets called before the client has finished setting up its stream. If this
            // happens, wait momentarily and try again.
            for (int j = 0; j < MAX_REQUEST_RETRIES; j++) {
                try {
                    callStreamObserver.request(i);
                    break;
                } catch (IllegalStateException ex) {
                    if (j == MAX_REQUEST_RETRIES - 1) {
                        throw ex;
                    }
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        // no-op
                    }
                }
            }
        }

        @Override
        public void cancel() {
            // Don't cancel twice if the server is already canceled
            if (callStreamObserver instanceof ServerCallStreamObserver && ((ServerCallStreamObserver) callStreamObserver).isCancelled()) {
                return;
            }

            isCanceled = true;
            if (callStreamObserver instanceof ClientCallStreamObserver) {
                ((ClientCallStreamObserver) callStreamObserver).cancel("Client canceled request", null);
            } else {
                callStreamObserver.onError(Status.CANCELLED.withDescription("Server canceled request").asRuntimeException());
            }
        }
    });
    this.subscriber = subscriber;

    subscribed.countDown();
}