@Override public ChannelPromise addListener(GenericFutureListener<? extends Future<? super Void>> listener) { delegate.addListener(listener); return this; }
@Override public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { ChannelPipeline p = future.channel().pipeline(); p.remove(encoderName); promise.setSuccess(); } else { promise.setFailure(future.cause()); } } });
void success(long total) { if (promise.isDone()) { // No need to notify the progress or fulfill the promise because it's done already. return; } progress(total, total); promise.trySuccess(); }
private void shutdownInput0(ChannelPromise promise) { try { socket.shutdownInput(); promise.setSuccess(); } catch (Throwable t) { promise.setFailure(t); } }
private static void notifyHeaderWritePromise(ChannelFuture future, ChannelPromise promise) { Throwable cause = future.cause(); if (cause == null) { promise.setSuccess(); } else { promise.setFailure(cause); } }
@Override public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception { // Remember the requested remote address for later use. final InetSocketAddress inetRemoteAddr = (InetSocketAddress) remoteAddress; this.remoteAddress = inetRemoteAddr; // Configure the pipeline. final Channel ch = ctx.channel(); ChannelUtil.disableWriterBufferWatermark(ch); final ChannelPipeline p = ch.pipeline(); p.addLast(new FlushConsolidationHandler()); p.addLast(ReadSuppressingHandler.INSTANCE); try { if (sslCtx != null) { configureAsHttps(ch, inetRemoteAddr); } else { configureAsHttp(ch); } } catch (Throwable t) { promise.tryFailure(t); ctx.close(); } finally { if (p.context(this) != null) { p.remove(this); } } ctx.connect(remoteAddress, localAddress, promise); }
private ChannelFuture finishEncode(final ChannelHandlerContext ctx, ChannelPromise promise) { if (finished) { promise.setSuccess(); return promise; } finished = true; final ByteBuf footer = ctx.alloc().heapBuffer( compressor.maxCompressedLength(buffer.readableBytes()) + HEADER_LENGTH); flushBufferedData(footer); final int idx = footer.writerIndex(); footer.setLong(idx, MAGIC_NUMBER); footer.setByte(idx + TOKEN_OFFSET, (byte) (BLOCK_TYPE_NON_COMPRESSED | compressionLevel)); footer.setInt(idx + COMPRESSED_LENGTH_OFFSET, 0); footer.setInt(idx + DECOMPRESSED_LENGTH_OFFSET, 0); footer.setInt(idx + CHECKSUM_OFFSET, 0); footer.writerIndex(idx + HEADER_LENGTH); return ctx.writeAndFlush(footer, promise); }
private void doFlush(final ChannelHandlerContext ctx) { final Channel channel = ctx.channel(); if (!channel.isActive()) { discard(null); return; ByteBufAllocator allocator = ctx.alloc(); while (channel.isWritable()) { if (currentWrite == null) { currentWrite = queue.poll(); if (currentWrite.promise.isDone()) { ChannelFuture f = ctx.write(message); if (endOfInput) { this.currentWrite = null; f.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { } else if (channel.isWritable()) { f.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { f.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception {
@Override public ChannelFuture writeSettingsAck(ChannelHandlerContext ctx, ChannelPromise promise) { try { ByteBuf buf = ctx.alloc().buffer(FRAME_HEADER_LENGTH); writeFrameHeaderInternal(buf, 0, SETTINGS, new Http2Flags().ack(true), 0); return ctx.write(buf, promise); } catch (Throwable t) { return promise.setFailure(t); } }
@Override public void operationComplete(ChannelFuture future) { if (future.isSuccess()) { ChannelPipeline p = future.channel().pipeline(); ChannelHandlerContext ctx = p.context(HttpRequestEncoder.class); if (ctx == null) { ctx = p.context(HttpClientCodec.class); } if (ctx == null) { promise.setFailure(new IllegalStateException("ChannelPipeline does not contain " + "a HttpRequestEncoder or HttpClientCodec")); return; } p.addAfter(ctx.name(), "ws-encoder", newWebSocketEncoder()); promise.setSuccess(); } else { promise.setFailure(future.cause()); } } });
@Override public void run() { if (regFuture.isSuccess()) { channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE); } else { promise.setFailure(regFuture.cause()); } } });
ChannelPipeline p = channel.pipeline(); if (p.get(HttpObjectAggregator.class) != null) { p.remove(HttpObjectAggregator.class); if (p.get(HttpContentCompressor.class) != null) { p.remove(HttpContentCompressor.class); ctx = p.context(HttpServerCodec.class); if (ctx == null) { promise.setFailure( new IllegalStateException("No HttpDecoder and no HttpServerCodec in the pipeline")); return promise; p.addBefore(ctx.name(), "wsdecoder", newWebsocketDecoder()); p.addBefore(ctx.name(), "wsencoder", newWebSocketEncoder()); encoderName = ctx.name(); } else { p.replace(ctx.name(), "wsdecoder", newWebsocketDecoder()); p.addBefore(encoderName, "wsencoder", newWebSocketEncoder()); channel.writeAndFlush(response).addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception {
private ChannelFuture finishEncode(final ChannelHandlerContext ctx, ChannelPromise promise) { if (finished) { promise.setSuccess(); return promise; ByteBuf footer = ctx.alloc().heapBuffer(); if (writeHeader && wrapper == ZlibWrapper.GZIP) { footer.writeBytes(gzipHeader); if (!footer.isWritable()) { ctx.write(footer); footer = ctx.alloc().heapBuffer(); int crcValue = (int) crc.getValue(); int uncBytes = deflater.getTotalIn(); footer.writeByte(crcValue); footer.writeByte(crcValue >>> 8); footer.writeByte(crcValue >>> 16);
protected void immediately(ChannelHandlerContext ctx, ChannelPromise promise) { if (isAlreadyClosing(ctx)) { promise.setSuccess(); return; } if (ctx.channel().isActive()) { ctx.close(promise); } else { promise.setSuccess(); } }
+ " isCancelled [{}] for frame {}", promise.isSuccess(), promise.isDone(), promise.isCancelled(), frame); ChannelFuture future = ctx.writeAndFlush(data, promise); if (LOG.isTraceEnabled()) { LOG.trace("Returned future [{}] isSuccess [{}] isDone [{}] isCancelled [{}] cause [{}]" + " for frame {}", future, future.isSuccess(), future.isDone(), future.isCancelled(), future.cause(), frame); if (future.cause() != null) { LOG.trace("Write operation failed due to:", future.cause());
promise.setFailure(PROTOCOL_EXCEPTION); return; promise.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { promise.setFailure(PROTOCOL_EXCEPTION); return; boolean localSideClosed = spdySynStreamFrame.isLast(); if (!acceptStream(streamId, priority, remoteSideClosed, localSideClosed)) { promise.setFailure(PROTOCOL_EXCEPTION); return; promise.setFailure(PROTOCOL_EXCEPTION); return; promise.setFailure(PROTOCOL_EXCEPTION); return; promise.setFailure(PROTOCOL_EXCEPTION); return; promise.setFailure(PROTOCOL_EXCEPTION); return; promise.setFailure(PROTOCOL_EXCEPTION); return;
FullHttpRequest request = newHandshakeRequest(); HttpResponseDecoder decoder = channel.pipeline().get(HttpResponseDecoder.class); if (decoder == null) { HttpClientCodec codec = channel.pipeline().get(HttpClientCodec.class); if (codec == null) { promise.setFailure(new IllegalStateException("ChannelPipeline does not contain " + "a HttpResponseDecoder or HttpClientCodec")); return promise; channel.writeAndFlush(request).addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) {
private void sendData(Channel ch) { QueueCommandHolder command = queue.peek(); if (command != null && command.trySend()) { QueueCommand data = command.getCommand(); List<CommandData<Object, Object>> pubSubOps = data.getPubSubOperations(); if (!pubSubOps.isEmpty()) { for (CommandData<Object, Object> cd : pubSubOps) { for (Object channel : cd.getParams()) { ch.pipeline().get(CommandPubSubDecoder.class).addPubSubCommand((ChannelName) channel, cd); } } } else { ch.attr(CURRENT_COMMAND).set(data); } command.getChannelPromise().addListener(listener); ch.writeAndFlush(data, command.getChannelPromise()); } }
@Override public ChannelFuture goAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, ByteBuf debugData, ChannelPromise promise) { if (!ctx.channel().isActive()) { // There's no point of sending a GOAWAY frame because the connection is over already. promise.unvoid().trySuccess(); debugData.release(); return promise; } return super.goAway(ctx, lastStreamId, errorCode, debugData, promise); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (!ctx.channel().isActive()) { ReferenceCountUtil.release(msg); return; } if (msg instanceof HttpRequestMessage) { promise.addListener((future) -> { if (!future.isSuccess()) { fireWriteError("request headers", future.cause(), ctx); } }); HttpRequestMessage zuulReq = (HttpRequestMessage) msg; preWriteHook(ctx, zuulReq); super.write(ctx, buildOriginHttpRequest(zuulReq), promise); } else if (msg instanceof HttpContent) { promise.addListener((future) -> { if (!future.isSuccess()) { fireWriteError("request content chunk", future.cause(), ctx); } }); super.write(ctx, msg, promise); } else { //should never happen ReferenceCountUtil.release(msg); throw new ZuulException("Received invalid message from client", true); } }