.transport(TcpServerTransport.create("localhost", 7000)) .start() .subscribe();
frame.sliceData().retain(), frame.sliceMetadata().retain())) .acceptor(acceptor) .transport(rsocketTransport) .start() .block(START_TIMEOUT);
@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); }); }
@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); }); }
@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); }); }
@Override public Mono<Gateway> start( GatewayConfig config, Executor workerPool, Call call, Metrics metrics) { return Mono.defer( () -> { LOGGER.info("Starting gateway with {}", config); GatewayMetrics metrics1 = new GatewayMetrics(config.name(), metrics); RSocketGatewayAcceptor acceptor = new RSocketGatewayAcceptor(call.create(), metrics1); if (workerPool != null) { loopResources = new GatewayLoopResources((EventLoopGroup) workerPool); } WebsocketServerTransport rsocketTransport = WebsocketServerTransport.create( prepareHttpServer(loopResources, config.port(), metrics1)); return RSocketFactory.receive() .frameDecoder( frame -> ByteBufPayload.create( frame.sliceData().retain(), frame.sliceMetadata().retain())) .acceptor(acceptor) .transport(rsocketTransport) .start() .doOnSuccess(server -> this.server = server) .doOnSuccess( server -> LOGGER.info( "Rsocket Gateway has been started successfully on {}", server.address())) .thenReturn(this); }); }
default <T extends Closeable> Start<T> transport(ServerTransport<T> transport) { return transport(() -> transport); } }
.transport(serverSupplier.get()) .start() .block();
RSocketFactory.receive() .acceptor((setup, rsocket) -> Mono.just(new EchoRSocket())) .transport(serverTransport) .start() .block(Duration.ofSeconds(10));
RSocketFactory.receive() .acceptor(acceptor) .transport(serverTransport.apply(new InetSocketAddress("localhost", 0))) .start() .block(Duration.ofSeconds(5));
.transport(TcpServerTransport.create("localhost", 7000)) .start() .subscribe();
.transport(serverSupplier.get()) .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(); }
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(); }
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(); }
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(); }
@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(); }
default <T extends Closeable> Start<T> transport(ServerTransport<T> transport) { return transport(() -> transport); } }
@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() .frameDecoder(Frame::retain) .acceptor(new PingHandler()) .transport(TcpServerTransport.create(7878)) .start() .block() .onClose() .block(); } }