@Override public ListenableFuture<Void> connect(final TcpConnectionHandler<P> handler) { Assert.notNull(handler, "TcpConnectionHandler is required"); if (this.stopping) { return handleShuttingDownConnectFailure(handler); } Mono<Void> connectMono = this.tcpClient .handle(new ReactorNettyHandler(handler)) .connect() .doOnError(handler::afterConnectFailure) .then(); return new MonoToListenableFutureAdapter<>(connectMono); }
@Override public ListenableFuture<Void> connect(TcpConnectionHandler<P> handler, ReconnectStrategy strategy) { Assert.notNull(handler, "TcpConnectionHandler is required"); Assert.notNull(strategy, "ReconnectStrategy is required"); if (this.stopping) { return handleShuttingDownConnectFailure(handler); } // Report first connect to the ListenableFuture MonoProcessor<Void> connectMono = MonoProcessor.create(); this.tcpClient .handle(new ReactorNettyHandler(handler)) .connect() .doOnNext(updateConnectMono(connectMono)) .doOnError(updateConnectMono(connectMono)) .doOnError(handler::afterConnectFailure) // report all connect failures to the handler .flatMap(Connection::onDispose) // post-connect issues .retryWhen(reconnectFunction(strategy)) .repeatWhen(reconnectFunction(strategy)) .subscribe(); return new MonoToListenableFutureAdapter<>(connectMono); }
@Override public Mono<DuplexConnection> connect() { return client .doOnConnected(c -> c.addHandlerLast(new RSocketLengthCodec())) .connect() .map(TcpDuplexConnection::new); } }
@Override public ListenableFuture<Void> connect(final TcpConnectionHandler<P> handler) { Assert.notNull(handler, "TcpConnectionHandler is required"); if (this.stopping) { return handleShuttingDownConnectFailure(handler); } Mono<Void> connectMono = this.tcpClient .handle(new ReactorNettyHandler(handler)) .connect() .doOnError(handler::afterConnectFailure) .then(); return new MonoToListenableFutureAdapter<>(connectMono); }
@Override @SuppressWarnings("unchecked") public Mono<WebsocketClientOperations> connect() { return (Mono<WebsocketClientOperations>)cachedConfiguration.connect(); }
@Override public ListenableFuture<Void> connect(TcpConnectionHandler<P> handler, ReconnectStrategy strategy) { Assert.notNull(handler, "TcpConnectionHandler is required"); Assert.notNull(strategy, "ReconnectStrategy is required"); if (this.stopping) { return handleShuttingDownConnectFailure(handler); } // Report first connect to the ListenableFuture MonoProcessor<Void> connectMono = MonoProcessor.create(); this.tcpClient .handle(new ReactorNettyHandler(handler)) .connect() .doOnNext(updateConnectMono(connectMono)) .doOnError(updateConnectMono(connectMono)) .doOnError(handler::afterConnectFailure) // report all connect failures to the handler .flatMap(Connection::onDispose) // post-connect issues .retryWhen(reconnectFunction(strategy)) .repeatWhen(reconnectFunction(strategy)) .subscribe(); return new MonoToListenableFutureAdapter<>(connectMono); }
@SuppressWarnings("unchecked") Mono<HttpClientOperations> connect() { return (Mono<HttpClientOperations>)cachedConfiguration.connect(); }
@Override public Mono<? extends Connection> connect(Bootstrap b) { return source.connect(b); }
@SuppressWarnings("unchecked") Mono<HttpClientOperations> connect() { return (Mono<HttpClientOperations>)cachedConfiguration.connect(); }
@Override @SuppressWarnings("unchecked") public Mono<WebsocketClientOperations> connect() { return (Mono<WebsocketClientOperations>)cachedConfiguration.connect(); }
@Override public Mono<? extends Connection> connect(Bootstrap b) { return source.connect(b); }
@Override public Mono<? extends Connection> connect(Bootstrap b) { return connector.apply(sourceTcp.connect(b), b); }
@Override public Mono<? extends Connection> connect(Bootstrap b) { return connector.apply(sourceTcp.connect(b), b); }
@Override public Mono<DuplexConnection> connect() { return client .doOnConnected(c -> c.addHandlerLast(new RSocketLengthCodec())) .connect() .map(TcpDuplexConnection::new); } }
@Override public Mono<? extends Connection> connect(Bootstrap b) { if (onRequestError != null) { HttpClientConfiguration c = HttpClientConfiguration.get(b); return sourceTcp.connect(b) .onErrorResume(error -> Mono.subscriberContext() .doOnNext(ctx -> onRequestError.accept(new PreparingHttpClientRequest(ctx, c), error)) .then(Mono.error(error)) ); } else { return sourceTcp.connect(b); } }
@Override public ListenableFuture<Void> connect(final TcpConnectionHandler<P> handler) { Assert.notNull(handler, "TcpConnectionHandler is required"); if (this.stopping) { return handleShuttingDownConnectFailure(handler); } Mono<Void> connectMono = this.tcpClient .handle(new ReactorNettyHandler(handler)) .connect() .doOnError(handler::afterConnectFailure) .then(); return new MonoToListenableFutureAdapter<>(connectMono); }
@Override public ListenableFuture<Void> connect(final TcpConnectionHandler<P> handler) { Assert.notNull(handler, "TcpConnectionHandler is required"); if (this.stopping) { return handleShuttingDownConnectFailure(handler); } Mono<Void> connectMono = this.tcpClient .handle(new ReactorNettyHandler(handler)) .connect() .doOnError(handler::afterConnectFailure) .then(); return new MonoToListenableFutureAdapter<>(connectMono); }
static ByteBufFlux content(TcpClient cachedConfiguration, Function<ChannelOperations<?, ?>, Publisher<ByteBuf>> contentReceiver) { Bootstrap b; try { b = cachedConfiguration.configure(); } catch (Throwable t) { Exceptions.throwIfFatal(t); return ByteBufFlux.fromInbound(Mono.error(t)); } @SuppressWarnings("unchecked") ByteBufAllocator alloc = (ByteBufAllocator) b.config() .options() .getOrDefault(ChannelOption.ALLOCATOR, ByteBufAllocator.DEFAULT); @SuppressWarnings("unchecked") Mono<ChannelOperations<?, ?>> connector = (Mono<ChannelOperations<?, ?>>) cachedConfiguration.connect(b); return ByteBufFlux.fromInbound(connector.flatMapMany(contentReceiver), alloc); }