@Override public Mono<Void> fireAndForget(Payload payload) { payload.release(); return Mono.error(new UnsupportedOperationException("Fire and forget not implemented.")); }
@Override public Mono<Void> metadataPush(Payload payload) { payload.release(); return Mono.error(new UnsupportedOperationException("Metadata-Push not implemented.")); }
@Override public Mono<Payload> requestResponse(Payload payload) { payload.release(); return Mono.just(pong.retain()); } });
@Override public Mono<Payload> requestResponse(Payload payload) { payload.release(); return Mono.error(new UnsupportedOperationException("Request-Response not implemented.")); }
@Override public Flux<Payload> requestStream(Payload payload) { payload.release(); return Flux.error(new UnsupportedOperationException("Request-Stream not implemented.")); }
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 void handleRequestResponse(int streamId, Mono<Payload> response) { response .doOnSubscribe(subscription -> sendingSubscriptions.put(streamId, subscription)) .map( payload -> { int flags = FLAGS_C; if (payload.hasMetadata()) { flags = Frame.setFlag(flags, FLAGS_M); } final Frame frame = Frame.PayloadFrame.from(streamId, FrameType.NEXT_COMPLETE, payload, flags); payload.release(); return frame; }) .switchIfEmpty( Mono.fromCallable(() -> Frame.PayloadFrame.from(streamId, FrameType.COMPLETE))) .doFinally(signalType -> sendingSubscriptions.remove(streamId)) .subscribe(sendProcessor::onNext, t -> handleError(streamId, t)); }
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); })); }
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<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); }); })); }
streamId, FrameType.NEXT, payload); payload.release(); return requestFrame; })
Frame.Request.from( streamId, FrameType.REQUEST_STREAM, payload, n); payload.release(); sendProcessor.onNext(requestFrame); } else if (contains(streamId) && !receiver.isDisposed()) {
@Override public Mono<Void> metadataPush(Payload payload) { try { return delegate.metadataPush(payload); } catch (Throwable t) { payload.release(); return Mono.error(t); } }
@Override protected Payload unwrap(Payload payload) { try { ByteBuf data = payload.sliceData(); ByteBuf metadata = payload.sliceMetadata(); ByteBuf unwrappedMetadata = Metadata.getMetadata(metadata); return ByteBufPayload.create(data.retain(), unwrappedMetadata.retain()); } finally { payload.release(); } }
@Override protected Payload unwrap(Payload payload) { try { ByteBuf data = payload.sliceData(); ByteBuf metadata = payload.sliceMetadata(); ByteBuf unwrappedMetadata = Metadata.getMetadata(metadata); return ByteBufPayload.create(data.retain(), unwrappedMetadata.retain()); } finally { payload.release(); } }
@Override public Mono<Payload> requestResponse(Payload payload) { try { return wrapMono(delegate.requestResponse(payload)); } catch (Throwable t) { payload.release(); return Mono.error(t); } }
@Override public Mono<Void> metadataPush(Payload payload) { return _notify() .doOnError(t -> payload.release()) .then(source.metadataPush(payload)); }
@Test public void testFireForget() { Payload incoming = Mockito.mock(Payload.class); Payload transformed = ByteBufPayload.create("transformed"); RSocket mock = Mockito.mock(RSocket.class); Mockito.when(mock.fireAndForget(Mockito.any(Payload.class))).thenReturn(Mono.empty()); DefaultProteusSocket socket = new DefaultProteusSocket(payload -> transformed, () -> mock); socket.fireAndForget(incoming).block(); Mockito.verify(incoming, Mockito.times(0)).release(); }
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); })); }
@Test public void testRequestResponse() { Payload incoming = Mockito.mock(Payload.class); Payload transformed = ByteBufPayload.create("transformed"); Payload outgoing = ByteBufPayload.create("outgoing"); RSocket mock = Mockito.mock(RSocket.class); Mockito.when(mock.requestResponse(Mockito.any(Payload.class))).thenReturn(Mono.just(outgoing)); DefaultProteusSocket socket = new DefaultProteusSocket(payload -> transformed, () -> mock); Payload block = socket.requestResponse(incoming).block(); Assert.assertTrue(block == outgoing); Mockito.verify(incoming, Mockito.times(0)).release(); }