/** * <pre> * Sends a greeting * <pre> */ public reactor.core.publisher.Mono<com.salesforce.servicelibs.reactivegrpc.HelloResponse> sayHello(reactor.core.publisher.Mono<com.salesforce.servicelibs.reactivegrpc.HelloRequest> reactorRequest) { return com.salesforce.reactorgrpc.stub.ClientCalls.oneToOne(reactorRequest, delegateStub::sayHello); }
@Override public CoreSubscriber<? super T> apply(Scannable scannable, CoreSubscriber<? super T> downstream) { Subscriber<? super T> delegate = apply(downstream);
@java.lang.Override @java.lang.SuppressWarnings("unchecked") public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) { switch (methodId) { case METHODID_SAY_HELLO: com.salesforce.reactorgrpc.stub.ServerCalls.oneToOne((com.salesforce.servicelibs.reactivegrpc.HelloRequest) request, (io.grpc.stub.StreamObserver<com.salesforce.servicelibs.reactivegrpc.HelloResponse>) responseObserver, serviceImpl::sayHello); break; default: throw new java.lang.AssertionError(); } }
/** * Implements a bidirectional stream -> stream call as {@link Flux} -> {@link Flux}, where both the client * and the server independently stream to each other. */ public static <TRequest, TResponse> Flux<TResponse> manyToMany( Flux<TRequest> rxRequest, Function<StreamObserver<TResponse>, StreamObserver<TRequest>> delegate) { try { ReactorProducerConsumerStreamObserver<TRequest, TResponse> consumerStreamObserver = new ReactorProducerConsumerStreamObserver<>(rxRequest); delegate.apply(new CancellableStreamObserver<>(consumerStreamObserver, consumerStreamObserver::cancel)); consumerStreamObserver.rxSubscribe(); return ((Flux<TResponse>) consumerStreamObserver.getRxConsumer()) .transform(Operators.lift(new SubscribeOnlyOnceLifter<TResponse>())); } catch (Throwable throwable) { return Flux.error(throwable); } } }
/** * Implements a unary -> stream call as {@link Mono} -> {@link Flux}, where the server responds with a * stream of messages. */ public static <TRequest, TResponse> Flux<TResponse> oneToMany( Mono<TRequest> rxRequest, BiConsumer<TRequest, StreamObserver<TResponse>> delegate) { try { ReactorConsumerStreamObserver<TRequest, TResponse> consumerStreamObserver = new ReactorConsumerStreamObserver<>(); rxRequest.subscribe(request -> delegate.accept(request, consumerStreamObserver)); return ((Flux<TResponse>) consumerStreamObserver.getRxConsumer()) .transform(Operators.lift(new SubscribeOnlyOnceLifter<TResponse>())); } catch (Throwable throwable) { return Flux.error(throwable); } }
Mono<TResponse> rxResponse = Preconditions.checkNotNull(delegate.apply( Flux.from(streamObserverPublisher) .transform(Operators.<TRequest, TRequest>lift(new BackpressureChunkingLifter<TRequest>())))); rxResponse.subscribe( value -> { responseObserver.onError(prepareError(throwable)); responseObserver.onError(prepareError(throwable));
@Override public Publisher<TResponse> getReactiveConsumerFromPublisher(ReactiveStreamObserverPublisherClient<TResponse> publisher) { return Flux.from(publisher).transform(Operators.lift(new BackpressureChunkingLifter<TResponse>())); }
/** * 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)); } }
Flux<TResponse> rxResponse = Preconditions.checkNotNull(delegate.apply( Flux.from(streamObserverPublisher) .transform(Operators.<TRequest, TRequest>lift(new BackpressureChunkingLifter<TRequest>())))); Subscriber<TResponse> subscriber = new ReactivePublisherBackpressureOnReadyHandlerServer<>( (ServerCallStreamObserver<TResponse>) responseObserver); ); } catch (Throwable throwable) { responseObserver.onError(prepareError(throwable));
/** * <pre> * Sends a greeting * <pre> */ public reactor.core.publisher.Mono<com.salesforce.servicelibs.reactivegrpc.HelloResponse> sayHello(com.salesforce.servicelibs.reactivegrpc.HelloRequest reactorRequest) { return com.salesforce.reactorgrpc.stub.ClientCalls.oneToOne(reactor.core.publisher.Mono.just(reactorRequest), delegateStub::sayHello); }
@Override public Publisher<TResponse> getReactiveConsumerFromPublisher(ReactiveStreamObserverPublisherClient<TResponse> publisher) { return Flux.from(publisher).transform(Operators.lift(new BackpressureChunkingLifter<TResponse>())); }
/** * 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 ReactivePublisherBackpressureOnReadyHandlerServer<>( (ServerCallStreamObserver<TResponse>) responseObserver)); } catch (Throwable throwable) { responseObserver.onError(prepareError(throwable)); } }