@Override public boolean setUncancellable() { return delegate.setUncancellable(); }
@Override public boolean setUncancellable() { return delegate.setUncancellable(); }
@Override public boolean setUncancellable() { return delegate.setUncancellable(); }
@Override public void bind(SocketAddress localAddress, ChannelPromise promise) { if (!promise.setUncancellable()) { return; } promise.setFailure(new UnsupportedOperationException()); }
@Override public void connect(final SocketAddress remoteAddress, SocketAddress localAddress, final ChannelPromise promise) { if (!promise.setUncancellable()) { return; } promise.setFailure(new UnsupportedOperationException()); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (acceptOutboundMessage(msg)) { if (!promise.setUncancellable()) { return; } } super.write(ctx, msg, promise); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (acceptOutboundMessage(msg)) { if (!promise.setUncancellable()) { return; } } super.write(ctx, msg, promise); }
/** * Add a flush to this {@link ChannelOutboundBuffer}. This means all previous added messages are marked as flushed * and so you will be able to handle them. */ public void addFlush() { // There is no need to process all entries if there was already a flush before and no new messages // where added in the meantime. // // See https://github.com/netty/netty/issues/2577 Entry entry = unflushedEntry; if (entry != null) { if (flushedEntry == null) { // there is no flushedEntry yet, so start with the entry flushedEntry = entry; } do { flushed ++; if (!entry.promise.setUncancellable()) { // Was cancelled so make sure we free up memory and notify about the freed bytes int pending = entry.cancel(); decrementPendingOutboundBytes(pending, false, true); } entry = entry.next; } while (entry != null); // All flushed so reset unflushedEntry unflushedEntry = null; } }
private void deregister(final ChannelPromise promise, final boolean fireChannelInactive) { if (!promise.setUncancellable()) { return;
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (acceptOutboundMessage(msg)) { if (!promise.setUncancellable()) { return; } } try { super.write(ctx, msg, promise); } catch (Exception e) { promise.tryFailure(e); throw e; } }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (acceptOutboundMessage(msg)) { if (!promise.setUncancellable()) { return; } } try { super.write(ctx, msg, promise); } catch (Exception e) { promise.tryFailure(e); throw e; } }
if (!promise.setUncancellable()) { return;
assertEventLoop(); if (!promise.setUncancellable() || !ensureOpen(promise)) { return;
@Override public final void disconnect(final ChannelPromise promise) { assertEventLoop(); if (!promise.setUncancellable()) { return; } boolean wasActive = isActive(); try { doDisconnect(); } catch (Throwable t) { safeSetFailure(promise, t); closeIfClosed(); return; } if (wasActive && !isActive()) { invokeLater(new Runnable() { @Override public void run() { pipeline.fireChannelInactive(); } }); } safeSetSuccess(promise); closeIfClosed(); // doDisconnect() might have closed the channel }
@Override public void connect( final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) { if (!promise.setUncancellable() || !ensureOpen(promise)) { return; } try { boolean wasActive = isActive(); doConnect(remoteAddress, localAddress); // Get the state as trySuccess() may trigger an ChannelFutureListener that will close the Channel. // We still need to ensure we call fireChannelActive() in this case. boolean active = isActive(); safeSetSuccess(promise); if (!wasActive && active) { pipeline().fireChannelActive(); } } catch (Throwable t) { safeSetFailure(promise, annotateConnectException(t, remoteAddress)); closeIfClosed(); } } }
@Override public final void disconnect(final ChannelPromise promise) { assertEventLoop(); if (!promise.setUncancellable()) { return; } boolean wasActive = isActive(); try { doDisconnect(); } catch (Throwable t) { safeSetFailure(promise, t); closeIfClosed(); return; } if (wasActive && !isActive()) { invokeLater(new Runnable() { @Override public void run() { pipeline.fireChannelInactive(); } }); } safeSetSuccess(promise); closeIfClosed(); // doDisconnect() might have closed the channel }
@Override public void connect( final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) { if (!promise.setUncancellable() || !ensureOpen(promise)) { return; } try { boolean wasActive = isActive(); doConnect(remoteAddress, localAddress); // Get the state as trySuccess() may trigger an ChannelFutureListener that will close the Channel. // We still need to ensure we call fireChannelActive() in this case. boolean active = isActive(); safeSetSuccess(promise); if (!wasActive && active) { pipeline().fireChannelActive(); } } catch (Throwable t) { safeSetFailure(promise, annotateConnectException(t, remoteAddress)); closeIfClosed(); } } }
@Override public void connect(final SocketAddress remoteAddress, SocketAddress localAddress, final ChannelPromise promise) { if (!promise.setUncancellable() || !ensureOpen(promise)) { return;
if (!promise.setUncancellable() || !ensureOpen(promise)) { return;
final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) { if (!promise.setUncancellable() || !ensureOpen(promise)) { return;