private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Schedule a timeout. final WriteTimeoutTask task = new WriteTimeoutTask(ctx, promise); task.scheduledFuture = ctx.executor().schedule(task, timeoutNanos, TimeUnit.NANOSECONDS); if (!task.scheduledFuture.isDone()) { addWriteTimeoutTask(task); // Cancel the scheduled timeout if the flush promise is complete. promise.addListener(task); } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (timeoutNanos > 0) { promise = promise.unvoid(); scheduleTimeout(ctx, promise); } ctx.write(msg, promise); }
@Override public void run() { // Was not written yet so issue a write timeout // The promise itself will be failed with a ClosedChannelException once the close() was issued // See https://github.com/netty/netty/issues/2159 if (!promise.isDone()) { try { writeTimedOut(ctx); } catch (Throwable t) { ctx.fireExceptionCaught(t); } } removeWriteTimeoutTask(this); }
private static WebClientProvider getWebClientProvider(ClientConfiguration clientConfiguration) { Duration connectTimeout = clientConfiguration.getConnectTimeout(); Duration soTimeout = clientConfiguration.getSocketTimeout(); TcpClient tcpClient = TcpClient.create(); if (!connectTimeout.isNegative()) { tcpClient = tcpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, Math.toIntExact(connectTimeout.toMillis())); } if (!soTimeout.isNegative()) { tcpClient = tcpClient.doOnConnected(connection -> connection // .addHandlerLast(new ReadTimeoutHandler(soTimeout.toMillis(), TimeUnit.MILLISECONDS)) .addHandlerLast(new WriteTimeoutHandler(soTimeout.toMillis(), TimeUnit.MILLISECONDS))); } String scheme = "http"; HttpClient httpClient = HttpClient.from(tcpClient); if (clientConfiguration.useSsl()) { httpClient = httpClient.secure(sslConfig -> { Optional<SSLContext> sslContext = clientConfiguration.getSslContext(); sslContext.ifPresent(it -> sslConfig.sslContext(new JdkSslContext(it, true, ClientAuth.NONE))); }); scheme = "https"; } ReactorClientHttpConnector connector = new ReactorClientHttpConnector(httpClient); WebClientProvider provider = WebClientProvider.create(scheme, connector); return provider.withDefaultHeaders(clientConfiguration.getDefaultHeaders()); }
protected void refreshWriteTimeoutHandler(Channel channel) { if(channel != null) { if(this.writeTimeout <= 0) { if(channel.pipeline().get("writeTimeout") != null) { channel.pipeline().remove("writeTimeout"); } } else { if(channel.pipeline().get("writeTimeout") == null) { channel.pipeline().addFirst("writeTimeout", new WriteTimeoutHandler(this.writeTimeout)); } else { channel.pipeline().replace("writeTimeout", "writeTimeout", new WriteTimeoutHandler(this.writeTimeout)); } } } }
@Override public void initChannel(SocketChannel ch) throws Exception { SSLEngine engine = createSSLEngine(); ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast("read-timeout", new ReadTimeoutHandler( 90 /* seconds */ )); pipeline.addLast("write-timeout", new WriteTimeoutHandler( 90 /* seconds */ )); pipeline.addLast("ssl", new SslHandler(engine)); pipeline.addLast("codec-http", new HttpServerCodec()); pipeline.addLast("aggregator", new HttpObjectAggregator(65536)); pipeline.addLast("handler", new BergamotAgentServerHandler(BergamotAgentServer.this, engine)); } });
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (timeoutNanos > 0) { promise = promise.unvoid(); scheduleTimeout(ctx, promise); } ctx.write(msg, promise); }
private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Schedule a timeout. final WriteTimeoutTask task = new WriteTimeoutTask(ctx, promise); task.scheduledFuture = ctx.executor().schedule(task, timeoutNanos, TimeUnit.NANOSECONDS); if (!task.scheduledFuture.isDone()) { addWriteTimeoutTask(task); // Cancel the scheduled timeout if the flush promise is complete. promise.addListener(task); } }
@Override public void run() { // Was not written yet so issue a write timeout // The promise itself will be failed with a ClosedChannelException once the close() was issued // See https://github.com/netty/netty/issues/2159 if (!promise.isDone()) { try { writeTimedOut(ctx); } catch (Throwable t) { ctx.fireExceptionCaught(t); } } removeWriteTimeoutTask(this); }
@Override public void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast( new ReadTimeoutHandler(requestTimeout /* seconds */), new WriteTimeoutHandler(requestTimeout /* seconds */), new SslHandler(createSSLEngine()), new NRPEDecoder(), new NRPEEncoder(), new NRPEHandler(request, responseHandler, errorHandler) ); } });
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (timeoutNanos > 0) { promise = promise.unvoid(); scheduleTimeout(ctx, promise); } ctx.write(msg, promise); }
private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Schedule a timeout. final WriteTimeoutTask task = new WriteTimeoutTask(ctx, promise); task.scheduledFuture = ctx.executor().schedule(task, timeoutNanos, TimeUnit.NANOSECONDS); if (!task.scheduledFuture.isDone()) { addWriteTimeoutTask(task); // Cancel the scheduled timeout if the flush promise is complete. promise.addListener(task); } }
@Override public void run() { // Was not written yet so issue a write timeout // The promise itself will be failed with a ClosedChannelException once the close() was issued // See https://github.com/netty/netty/issues/2159 if (!promise.isDone()) { try { writeTimedOut(ctx); } catch (Throwable t) { ctx.fireExceptionCaught(t); } } removeWriteTimeoutTask(this); }
pipeline.addLast(new WriteTimeoutHandler(ApnsClient.this.writeTimeoutMillis, TimeUnit.MILLISECONDS));
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (timeoutNanos > 0) { promise = promise.unvoid(); scheduleTimeout(ctx, promise); } ctx.write(msg, promise); }
private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Schedule a timeout. final WriteTimeoutTask task = new WriteTimeoutTask(ctx, promise); task.scheduledFuture = ctx.executor().schedule(task, timeoutNanos, TimeUnit.NANOSECONDS); if (!task.scheduledFuture.isDone()) { addWriteTimeoutTask(task); // Cancel the scheduled timeout if the flush promise is complete. promise.addListener(task); } }
@Override public void run() { // Was not written yet so issue a write timeout // The promise itself will be failed with a ClosedChannelException once the close() was issued // See https://github.com/netty/netty/issues/2159 if (!promise.isDone()) { try { writeTimedOut(ctx); } catch (Throwable t) { ctx.fireExceptionCaught(t); } } removeWriteTimeoutTask(this); }
private void writeRequest(HttpRequest request) { channel.pipeline().addFirst(new WriteTimeoutHandler(context.configuration().writeTimeoutMillis(), TimeUnit.MILLISECONDS)); StreamedRequest streamedRequest = new StreamedRequest(request,
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (timeoutNanos > 0) { promise = promise.unvoid(); scheduleTimeout(ctx, promise); } ctx.write(msg, promise); }
private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Schedule a timeout. final WriteTimeoutTask task = new WriteTimeoutTask(ctx, promise); task.scheduledFuture = ctx.executor().schedule(task, timeoutNanos, TimeUnit.NANOSECONDS); if (!task.scheduledFuture.isDone()) { addWriteTimeoutTask(task); // Cancel the scheduled timeout if the flush promise is complete. promise.addListener(task); } }