Operators.lift((sc, sub) -> { scannableRef.set(sc); return sub;
@Test public void eachOperatorTest() { Hooks.onEachOperator(Operators.lift((sc, sub) -> new CoreSubscriber<Object>(){ @Override
@Test public void lastOperatorTest() { Hooks.onLastOperator(Operators.lift((sc, sub) -> new CoreSubscriber<Object>(){ @Override
Operators.lift(sc -> { scannableFilterRef.set(sc); return true;
@Test public void lastOperatorTest() { Hooks.onLastOperator(Operators.lift((sc, sub) -> new CoreSubscriber<Object>(){ @Override
@Test public void eachOperatorTest() { Hooks.onEachOperator(Operators.lift((sc, sub) -> new CoreSubscriber<Object>(){ @Override
@Test public void lastOperatorFilterTest() { Hooks.onLastOperator(Operators.lift(sc -> sc.tags() .anyMatch(t -> t.getT1() .contains("metric")),
@Test public void lastOperatorFilterTest() { Hooks.onLastOperator(Operators.lift(sc -> sc.tags() .anyMatch(t -> t.getT1() .contains("metric")),
private Function<? super Publisher<CoreEvent>, ? extends Publisher<CoreEvent>> doOnNextOrErrorWithContext(Consumer<Context> contextConsumer) { return lift((scannable, subscriber) -> new CoreSubscriber<CoreEvent>() { private Context context = subscriber.currentContext(); @Override public void onNext(CoreEvent event) { contextConsumer.accept(context); subscriber.onNext(event); } @Override public void onError(Throwable throwable) { contextConsumer.accept(context); subscriber.onError(throwable); } @Override public void onComplete() { subscriber.onComplete(); } @Override public Context currentContext() { return context; } @Override public void onSubscribe(Subscription s) { subscriber.onSubscribe(s); } }); }
public static <T> Function<Map<String, String>, Function<? super Publisher<T>, ? extends Publisher<T>>> trace( Tracer tracer, String name, Tag... tags) { return map -> Operators.lift( (scannable, subscriber) -> new SpanSubscriber<T>( subscriber, subscriber.currentContext(), tracer, map, name, tags)); }
@Override public void beforeTestMethod(TestContext testContext) throws Exception { SecurityContext securityContext = TestSecurityContextHolder.getContext(); Hooks.onLastOperator(CONTEXT_OPERATOR_KEY, Operators.lift((s, sub) -> new SecuritySubContext<>(sub, securityContext))); }
public static <T> Function<SpanContext, Function<? super Publisher<T>, ? extends Publisher<T>>> traceAsChild( Tracer tracer, String name, Tag... tags) { return (spanContext) -> { if (spanContext == null) { return Operators.lift( (scannable, subscriber) -> new SpanSubscriber<T>( subscriber, subscriber.currentContext(), tracer, null, name, tags)); } else { return Operators.lift( (scannable, subscriber) -> new SpanSubscriber<T>( subscriber, subscriber.currentContext(), tracer, null, spanContext, name, tags)); } }; } }
@Override public void beforeTestMethod(TestContext testContext) throws Exception { SecurityContext securityContext = TestSecurityContextHolder.getContext(); Hooks.onLastOperator(CONTEXT_OPERATOR_KEY, Operators.lift((s, sub) -> new SecuritySubContext<>(sub, securityContext))); }
@Override public Publisher<TResponse> getReactiveConsumerFromPublisher(ReactiveStreamObserverPublisherClient<TResponse> publisher) { return Flux.from(publisher).transform(Operators.lift(new BackpressureChunkingLifter<TResponse>())); }
@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> 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); } }
/** * Implements a unary -> unary call using {@link Mono} -> {@link Mono}. */ public static <TRequest, TResponse> Mono<TResponse> oneToOne( Mono<TRequest> rxRequest, BiConsumer<TRequest, StreamObserver<TResponse>> delegate) { try { return Mono .<TResponse>create(emitter -> rxRequest.subscribe( request -> delegate.accept(request, new StreamObserver<TResponse>() { @Override public void onNext(TResponse tResponse) { emitter.success(tResponse); } @Override public void onError(Throwable throwable) { emitter.error(throwable); } @Override public void onCompleted() { // Do nothing } }), emitter::error )) .transform(Operators.lift(new SubscribeOnlyOnceLifter<TResponse>())); } catch (Throwable throwable) { return Mono.error(throwable); } }
/** * 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 stream -> unary call as {@link Flux} -> {@link Mono}, where the client transits a stream of * messages. */ public static <TRequest, TResponse> Mono<TResponse> manyToOne( Flux<TRequest> rxRequest, Function<StreamObserver<TResponse>, StreamObserver<TRequest>> delegate) { try { return Mono .<TResponse>create(emitter -> { ReactiveProducerStreamObserver<TRequest, TResponse> reactiveProducerStreamObserver = new ReactiveProducerStreamObserver<>( rxRequest, emitter::success, emitter::error, Runnables.doNothing()); delegate.apply( new CancellableStreamObserver<>(reactiveProducerStreamObserver, reactiveProducerStreamObserver::cancel)); reactiveProducerStreamObserver.rxSubscribe(); }) .transform(Operators.lift(new SubscribeOnlyOnceLifter<TResponse>())); } catch (Throwable throwable) { return Mono.error(throwable); } }
Mono<TResponse> rxResponse = Preconditions.checkNotNull(delegate.apply( Flux.from(streamObserverPublisher) .transform(Operators.<TRequest, TRequest>lift(new BackpressureChunkingLifter<TRequest>())))); rxResponse.subscribe( value -> {