@Parameterized.Parameters public static Iterable<Function<RSocket, ? extends Publisher<?>>> rsocketInteractions() { EmptyPayload payload = EmptyPayload.INSTANCE; Publisher<Payload> payloadStream = Flux.just(payload); Function<RSocket, Mono<Payload>> resp = rSocket -> rSocket.requestResponse(payload); Function<RSocket, Flux<Payload>> stream = rSocket -> rSocket.requestStream(payload); Function<RSocket, Flux<Payload>> channel = rSocket -> rSocket.requestChannel(payloadStream); return Arrays.asList(resp, stream, channel); } }
@Override public Mono<Void> onClose() { return source.onClose(); } }
@Override public void dispose() { delegate.dispose(); }
@Override public Mono<Payload> requestResponse(Payload payload) { try { return requestHandler.requestResponse(payload); } catch (Throwable t) { return Mono.error(t); } }
@Override public Flux<Payload> requestStream(Payload payload) { try { return requestHandler.requestStream(payload); } catch (Throwable t) { return Flux.error(t); } }
@Override public Flux<Payload> requestChannel(Publisher<Payload> payloads) { try { return requestHandler.requestChannel(payloads); } catch (Throwable t) { return Flux.error(t); } }
@Override public Mono<Void> fireAndForget(Payload payload) { return child.fireAndForget(payload); }
(setup, reactiveSocket) -> { reactiveSocket .requestStream(DefaultPayload.create("Hello-Bidi")) .map(Payload::getDataUtf8) .log() .block(); socket.onClose().block();
@Override public Mono<Void> metadataPush(Payload payload) { return source.metadataPush(payload); }
.verify(Duration.ofSeconds(5)); StepVerifier.create(clientRequester.onClose()).expectComplete().verify(Duration.ofSeconds(5)); StepVerifier.create(serverRequester.flatMap(socket -> socket.onClose())) .expectComplete() .verify(Duration.ofSeconds(5)); StepVerifier.create(clientRequester.requestResponse(DefaultPayload.create("test"))) .expectErrorMatches( err -> err instanceof RejectedSetupException && errorMessage.equals(err.getMessage()))
.requestResponse(DefaultPayload.create("Hello")) .map(Payload::getDataUtf8) .onErrorReturn("error") .requestResponse(DefaultPayload.create("Hello")) .map(Payload::getDataUtf8) .onErrorReturn("error") .requestResponse(DefaultPayload.create("Hello")) .map(Payload::getDataUtf8) .onErrorReturn("error") .block(); socket.dispose();
@Test public void testWidowReset() throws InterruptedException { testRSocket( (latch, socket) -> { assertEquals(1.0, socket.availability(), 0.0); Publisher<Payload> payloadPublisher = socket.requestResponse(EmptyPayload.INSTANCE); Subscriber<Payload> subscriber = TestSubscriber.create(); payloadPublisher.subscribe(subscriber); verify(subscriber).onComplete(); double good = socket.availability(); subscriber = TestSubscriber.create(); payloadPublisher.subscribe(subscriber); verify(subscriber).onError(any(RuntimeException.class)); double bad = socket.availability(); assertTrue(good > bad); try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } double reset = socket.availability(); assertTrue(reset > bad); latch.countDown(); }); }
public static void main(String[] args) { RSocketFactory.receive() .acceptor(new SocketAcceptorImpl()) .transport(TcpServerTransport.create("localhost", 7000)) .start() .subscribe(); RSocket socket = RSocketFactory.connect() .transport(TcpClientTransport.create("localhost", 7000)) .start() .block(); socket .requestStream(DefaultPayload.create("Hello")) .map(Payload::getDataUtf8) .doOnNext(System.out::println) .take(10) .then() .doFinally(signalType -> socket.dispose()) .then() .block(); }
public static void main(String[] args) { RSocketFactory.receive() .acceptor(new SocketAcceptorImpl()) .transport(TcpServerTransport.create("localhost", 7000)) .start() .subscribe(); RSocket socket = RSocketFactory.connect() .transport(TcpClientTransport.create("localhost", 7000)) .start() .block(); socket .requestChannel( Flux.interval(Duration.ofMillis(1000)).map(i -> DefaultPayload.create("Hello"))) .map(Payload::getDataUtf8) .doOnNext(System.out::println) .take(10) .doFinally(signalType -> socket.dispose()) .then() .block(); }
@Override public double availability() { return child.availability(); }
@Override public Mono<Payload> requestResponse(Payload payload) { return Mono.from( subscriber -> { Subscriber<? super Payload> oneSubscriber = new OneSubscriber<>(subscriber); Subscriber<? super Payload> backupRequest = new FirstRequestSubscriber(oneSubscriber, () -> child.requestResponse(payload)); child.requestResponse(payload).subscribe(backupRequest); }); }
@Override public Flux<Payload> requestStream(Payload payload) { return delegate.requestStream(payload).doFinally(requestStream); }
@Override public Flux<Payload> requestChannel(Publisher<Payload> payloads) { return source .requestChannel(payloads) .doOnError(th -> errorPercentage.insert(0.0)) .doOnComplete(() -> updateErrorPercentage(1.0)); }
@Override public Mono<Void> fireAndForget(Payload payload) { return source.fireAndForget(payload); }