public TransportPair( Supplier<T> addressSupplier, BiFunction<T, S, ClientTransport> clientTransportSupplier, Function<T, ServerTransport<S>> serverTransportSupplier) { T address = addressSupplier.get(); server = RSocketFactory.receive() .acceptor((setup, sendingSocket) -> Mono.just(new TestRSocket())) .transport(serverTransportSupplier.apply(address)) .start() .block(); client = RSocketFactory.connect() .transport(clientTransportSupplier.apply(address, server)) .start() .doOnError(Throwable::printStackTrace) .block(); }
private RSocket buildClient() { return RSocketFactory.connect() .transport(TcpClientTransport.create(server.address())) .start() .block(); }
@Test void responderRejectSetup() { SingleConnectionTransport transport = new SingleConnectionTransport(); String errorMsg = "error"; RejectingAcceptor acceptor = new RejectingAcceptor(errorMsg); RSocketFactory.receive().acceptor(acceptor).transport(transport).start().block(); transport.connect(); Frame sentFrame = transport.awaitSent(); assertThat(sentFrame.getType()).isEqualTo(FrameType.ERROR); RuntimeException error = Exceptions.from(sentFrame); assertThat(errorMsg).isEqualTo(error.getMessage()); assertThat(error).isInstanceOf(RejectedSetupException.class); RSocket acceptorSender = acceptor.senderRSocket().block(); assertThat(acceptorSender.isDisposed()).isTrue(); }
private Flux<Payload> consumer(String s) { return RSocketFactory.connect() .errorConsumer(Throwable::printStackTrace) .transport(clientSupplier) .start() .flatMapMany( rSocket -> { AtomicInteger count = new AtomicInteger(); return Flux.range(1, 100) .flatMap( i -> rSocket.requestStream(DefaultPayload.create("i -> " + i)).take(100), 1); }); }
public static void main(String... args) { RSocketFactory.receive() .acceptor(new PingHandler()) .transport(WebsocketServerTransport.create(7878)) .start() .block() .onClose() .block(); } }
public ClientSetupRule( Supplier<T> addressSupplier, BiFunction<T, S, ClientTransport> clientTransportSupplier, Function<T, ServerTransport<S>> serverTransportSupplier) { this.addressSupplier = addressSupplier; this.serverInit = address -> RSocketFactory.receive() .acceptor((setup, sendingSocket) -> Mono.just(new TestRSocket())) .transport(serverTransportSupplier.apply(address)) .start() .block(); this.clientConnector = (address, server) -> RSocketFactory.connect() .transport(clientTransportSupplier.apply(address, server)) .start() .doOnError(Throwable::printStackTrace) .block(); }
private RSocketFactory.ClientRSocketFactory getClientFactory(String destination) { RSocketFactory.ClientRSocketFactory connect = RSocketFactory.connect().frameDecoder(Frame::retain); if (keepalive) { connect = connect .keepAlive() .keepAliveTickPeriod(Duration.ofSeconds(tickPeriodSeconds)) .keepAliveAckTimeout(Duration.ofSeconds(ackTimeoutSeconds)) .keepAliveMissedAcks(missedAcks); } else { connect .keepAlive() .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveMissedAcks(missedAcks); } return connect .setupPayload(setupPayloadSupplier.apply(destination)) .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveTickPeriod(Duration.ofSeconds(0)); }
@Before public void startup() { TcpServerTransport serverTransport = TcpServerTransport.create(0); server = RSocketFactory.receive() .acceptor((setup, sendingSocket) -> Mono.just(new RSocketProxy(handler))) .transport(serverTransport) .start() .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(); }
private RSocketFactory.ClientRSocketFactory getClientFactory(String destination) { RSocketFactory.ClientRSocketFactory connect = RSocketFactory.connect().frameDecoder(Frame::retain); if (keepalive) { connect = connect .keepAlive() .keepAliveTickPeriod(Duration.ofSeconds(tickPeriodSeconds)) .keepAliveAckTimeout(Duration.ofSeconds(ackTimeoutSeconds)) .keepAliveMissedAcks(missedAcks); } else { connect .keepAlive() .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveMissedAcks(missedAcks); } return connect .setupPayload(setupPayloadSupplier.apply(destination)) .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveTickPeriod(Duration.ofSeconds(0)); }
public static void main(String... args) { RSocketFactory.receive() .frameDecoder(Frame::retain) .acceptor(new PingHandler()) .transport(TcpServerTransport.create(7878)) .start() .block() .onClose() .block(); } }
private RSocketFactory.ClientRSocketFactory getClientFactory(Payload setupPayload) { RSocketFactory.ClientRSocketFactory connect = RSocketFactory.connect().frameDecoder(Frame::retain); if (keepalive) { connect = connect .keepAlive() .keepAliveTickPeriod(Duration.ofSeconds(tickPeriodSeconds)) .keepAliveAckTimeout(Duration.ofSeconds(ackTimeoutSeconds)) .keepAliveMissedAcks(missedAcks); } else { connect .keepAlive() .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveMissedAcks(missedAcks); } return connect .setupPayload(setupPayload) .keepAliveAckTimeout(Duration.ofSeconds(0)) .keepAliveTickPeriod(Duration.ofSeconds(0)); }
try { server = RSocketFactory.receive() .errorConsumer(Throwable::printStackTrace) .acceptor(
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(); }
RSocketFactory.connect() .frameDecoder( frame ->
try { server = RSocketFactory.receive() .errorConsumer(Throwable::printStackTrace) .acceptor(
RSocketFactory.connect() .frameDecoder( frame ->
@Override public Mono<InetSocketAddress> bind(int port, ServiceMethodRegistry methodRegistry) { return Mono.defer( () -> { TcpServer tcpServer = TcpServer.create() .runOn(loopResources) .addressSupplier(() -> new InetSocketAddress(port)) .doOnConnection( connection -> { LOGGER.info("Accepted connection on {}", connection.channel()); connection.onDispose( () -> { LOGGER.info("Connection closed on {}", connection.channel()); connections.remove(connection); }); connections.add(connection); }); return RSocketFactory.receive() .frameDecoder( frame -> ByteBufPayload.create( frame.sliceData().retain(), frame.sliceMetadata().retain())) .acceptor(new RSocketServiceAcceptor(codec, methodRegistry)) .transport(() -> TcpServerTransport.create(tcpServer)) .start() .map(server -> this.server = server) .map(CloseableChannel::address); }); }