private void handleError(int streamId, Throwable t) { errorConsumer.accept(t); sendProcessor.onNext(Frame.Error.from(streamId, t)); }
private void handleChannel(int streamId, Payload payload, int initialRequestN) { UnicastProcessor<Payload> frames = UnicastProcessor.create(); channelProcessors.put(streamId, frames); Flux<Payload> payloads = frames .doOnCancel(() -> sendProcessor.onNext(Frame.Cancel.from(streamId))) .doOnError(t -> sendProcessor.onNext(Frame.Error.from(streamId, t))) .doOnRequest(l -> sendProcessor.onNext(Frame.RequestN.from(streamId, l))) .doFinally(signalType -> channelProcessors.remove(streamId)); // not chained, as the payload should be enqueued in the Unicast processor before this method // returns // and any later payload can be processed frames.onNext(payload); handleStream(streamId, requestChannel(payloads), initialRequestN); }
private Mono<Payload> handleRequestResponse(final Payload payload) { return lifecycle .active() .then( Mono.defer( () -> { int streamId = streamIdSupplier.nextStreamId(); final Frame requestFrame = Frame.Request.from(streamId, FrameType.REQUEST_RESPONSE, payload, 1); payload.release(); UnicastMonoProcessor<Payload> receiver = UnicastMonoProcessor.create(); receivers.put(streamId, receiver); sendProcessor.onNext(requestFrame); return receiver .doOnError(t -> sendProcessor.onNext(Frame.Error.from(streamId, t))) .doFinally( s -> { if (s == SignalType.CANCEL) { sendProcessor.onNext(Frame.Cancel.from(streamId)); } receivers.remove(streamId); }); })); }
private void handleStream(int streamId, Flux<Payload> response, int initialRequestN) { response .transform( frameFlux -> { LimitableRequestPublisher<Payload> payloads = LimitableRequestPublisher.wrap(frameFlux); sendingSubscriptions.put(streamId, payloads); payloads.increaseRequestLimit(initialRequestN); return payloads; }) .doFinally(signalType -> sendingSubscriptions.remove(streamId)) .subscribe( payload -> { final Frame frame = Frame.PayloadFrame.from(streamId, FrameType.NEXT, payload); payload.release(); sendProcessor.onNext(frame); }, t -> handleError(streamId, t), () -> { final Frame frame = Frame.PayloadFrame.from(streamId, FrameType.COMPLETE); sendProcessor.onNext(frame); }); }
private Mono<Void> handleMetadataPush(Payload payload) { return lifecycle .active() .then( Mono.fromRunnable( () -> { final Frame requestFrame = Frame.Request.from(0, FrameType.METADATA_PUSH, payload, 1); payload.release(); sendProcessor.onNext(requestFrame); })); }
public void testOnNextAfterSubscribeN(int n) throws Exception { CountDownLatch latch = new CountDownLatch(n); UnboundedProcessor<Payload> processor = new UnboundedProcessor<>(); processor.log().doOnNext(integer -> latch.countDown()).subscribe(); for (int i = 0; i < n; i++) { System.out.println("onNexting -> " + i); processor.onNext(EmptyPayload.INSTANCE); } processor.drain(); latch.await(); } }
private Mono<Void> handleFireAndForget(Payload payload) { return lifecycle .active() .then( Mono.fromRunnable( () -> { final int streamId = streamIdSupplier.nextStreamId(); final Frame requestFrame = Frame.Request.from(streamId, FrameType.REQUEST_FNF, payload, 1); payload.release(); sendProcessor.onNext(requestFrame); })); }
public void testOnNextBeforeSubscribeN(int n) { UnboundedProcessor<Payload> processor = new UnboundedProcessor<>(); for (int i = 0; i < n; i++) { processor.onNext(EmptyPayload.INSTANCE); } processor.onComplete(); long count = processor.count().block(); Assert.assertEquals(n, count); }
streamId, FrameType.REQUEST_STREAM, payload, n); payload.release(); sendProcessor.onNext(requestFrame); } else if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.RequestN.from(streamId, n)); t -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Error.from(streamId, t)); () -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Cancel.from(streamId));
() -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext( Frame.PayloadFrame.from( streamId, FrameType.COMPLETE)); } else { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.RequestN.from(streamId, n)); t -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Error.from(streamId, t)); () -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Cancel.from(streamId));
private void handleError(int streamId, Throwable t) { errorConsumer.accept(t); sendProcessor.onNext(Frame.Error.from(streamId, t)); }
private Mono<Payload> handleRequestResponse(final Payload payload) { return lifecycle .active() .then( Mono.defer( () -> { int streamId = streamIdSupplier.nextStreamId(); final Frame requestFrame = Frame.Request.from(streamId, FrameType.REQUEST_RESPONSE, payload, 1); payload.release(); UnicastMonoProcessor<Payload> receiver = UnicastMonoProcessor.create(); receivers.put(streamId, receiver); sendProcessor.onNext(requestFrame); return receiver .doOnError(t -> sendProcessor.onNext(Frame.Error.from(streamId, t))) .doFinally( s -> { if (s == SignalType.CANCEL) { sendProcessor.onNext(Frame.Cancel.from(streamId)); } receivers.remove(streamId); }); })); }
private void handleChannel(int streamId, Payload payload, int initialRequestN) { UnicastProcessor<Payload> frames = UnicastProcessor.create(); channelProcessors.put(streamId, frames); Flux<Payload> payloads = frames .doOnCancel(() -> sendProcessor.onNext(Frame.Cancel.from(streamId))) .doOnError(t -> sendProcessor.onNext(Frame.Error.from(streamId, t))) .doOnRequest(l -> sendProcessor.onNext(Frame.RequestN.from(streamId, l))) .doFinally(signalType -> channelProcessors.remove(streamId)); // not chained, as the payload should be enqueued in the Unicast processor before this method // returns // and any later payload can be processed frames.onNext(payload); if (responderRSocket != null) { handleStream(streamId, requestChannel(payload, payloads), initialRequestN); } else { handleStream(streamId, requestChannel(payloads), initialRequestN); } }
private void handleStream(int streamId, Flux<Payload> response, int initialRequestN) { response .transform( frameFlux -> { LimitableRequestPublisher<Payload> payloads = LimitableRequestPublisher.wrap(frameFlux); sendingSubscriptions.put(streamId, payloads); payloads.increaseRequestLimit(initialRequestN); return payloads; }) .doFinally(signalType -> sendingSubscriptions.remove(streamId)) .subscribe( payload -> { final Frame frame = Frame.PayloadFrame.from(streamId, FrameType.NEXT, payload); payload.release(); sendProcessor.onNext(frame); }, t -> handleError(streamId, t), () -> { final Frame frame = Frame.PayloadFrame.from(streamId, FrameType.COMPLETE); sendProcessor.onNext(frame); }); }
private Mono<Void> handleMetadataPush(Payload payload) { return lifecycle .active() .then( Mono.fromRunnable( () -> { final Frame requestFrame = Frame.Request.from(0, FrameType.METADATA_PUSH, payload, 1); payload.release(); sendProcessor.onNext(requestFrame); })); }
private Mono<Void> handleFireAndForget(Payload payload) { return lifecycle .active() .then( Mono.fromRunnable( () -> { final int streamId = streamIdSupplier.nextStreamId(); final Frame requestFrame = Frame.Request.from(streamId, FrameType.REQUEST_FNF, payload, 1); payload.release(); sendProcessor.onNext(requestFrame); })); }
streamId, FrameType.REQUEST_STREAM, payload, n); payload.release(); sendProcessor.onNext(requestFrame); } else if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.RequestN.from(streamId, n)); t -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Error.from(streamId, t)); () -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Cancel.from(streamId));
() -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext( Frame.PayloadFrame.from( streamId, FrameType.COMPLETE)); } else { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.RequestN.from(streamId, n)); t -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Error.from(streamId, t)); () -> { if (contains(streamId) && !receiver.isDisposed()) { sendProcessor.onNext(Frame.Cancel.from(streamId));