/** * Sends a {@code "writeComplete"} event to the first * {@link ChannelUpstreamHandler} in the {@link ChannelPipeline} of * the specified {@link Channel} in the next io-thread. */ public static ChannelFuture fireWriteCompleteLater(final Channel channel, final long amount) { return channel.getPipeline().execute(new Runnable() { public void run() { fireWriteComplete(channel, amount); } }); }
/** * Sends a {@code "channelClosed"} event to the first * {@link ChannelUpstreamHandler} in the {@link ChannelPipeline} of * the specified {@link Channel} once the io-thread runs again. */ public static ChannelFuture fireChannelClosedLater(final Channel channel) { return channel.getPipeline().execute(new Runnable() { public void run() { fireChannelClosed(channel); } }); }
private void fireWriteTimeOut(final ChannelHandlerContext ctx) { ctx.getPipeline().execute(new Runnable() { public void run() { try { writeTimedOut(ctx); } catch (Throwable t) { fireExceptionCaught(ctx, t); } } }); } }
private void fireReadTimedOut(final ChannelHandlerContext ctx) throws Exception { ctx.getPipeline().execute(new Runnable() { public void run() { try { readTimedOut(ctx); } catch (Throwable t) { fireExceptionCaught(ctx, t); } } }); } }
private void fireChannelIdle( final ChannelHandlerContext ctx, final IdleState state, final long lastActivityTimeMillis) { ctx.getPipeline().execute(new Runnable() { public void run() { try { channelIdle(ctx, state, lastActivityTimeMillis); } catch (Throwable t) { fireExceptionCaught(ctx, t); } } }); }
/** * Sends a {@code "channelUnbound"} event to the first * {@link ChannelUpstreamHandler} in the {@link ChannelPipeline} of * the specified {@link Channel} once the io-thread runs again. */ public static ChannelFuture fireChannelUnboundLater(final Channel channel) { return channel.getPipeline().execute(new Runnable() { public void run() { fireChannelUnbound(channel); } }); }
/** * Sends a {@code "channelInterestChanged"} event to the first * {@link ChannelUpstreamHandler} in the {@link ChannelPipeline} of * the specified {@link Channel} once the io-thread runs again. */ public static ChannelFuture fireChannelInterestChangedLater(final Channel channel) { return channel.getPipeline().execute(new Runnable() { public void run() { fireChannelInterestChanged(channel); } }); }
/** * Sends a {@code "exceptionCaught"} event to the first * {@link ChannelUpstreamHandler} in the {@link ChannelPipeline} of * the specified {@link Channel} once the io-thread runs again. */ public static ChannelFuture fireExceptionCaughtLater(final Channel channel, final Throwable cause) { return channel.getPipeline().execute(new Runnable() { public void run() { fireExceptionCaught(channel, cause); } }); }
/** * Sends a {@code "channelDisconnected"} event to the first * {@link ChannelUpstreamHandler} in the {@link ChannelPipeline} of * the specified {@link Channel} once the io-thread runs again. */ public static ChannelFuture fireChannelDisconnectedLater(final Channel channel) { return channel.getPipeline().execute(new Runnable() { public void run() { fireChannelDisconnected(channel); } }); } /**
/** * Sends a {@code "exceptionCaught"} event to the * {@link ChannelUpstreamHandler} which is placed in the closest upstream * from the handler associated with the specified * {@link ChannelHandlerContext} once the io-thread runs again. */ public static ChannelFuture fireExceptionCaughtLater(final ChannelHandlerContext ctx, final Throwable cause) { return ctx.getPipeline().execute(new Runnable() { public void run() { fireExceptionCaught(ctx, cause); } }); }
ctx.getPipeline().execute(new Runnable() { public void run() { if (!pendingUnencryptedWritesLock.tryLock()) {
void setInterestOps(final AbstractNioChannel<?> channel, final ChannelFuture future, final int interestOps) { boolean iothread = isIoThread(channel); if (!iothread) { channel.getPipeline().execute(new Runnable() { public void run() { setInterestOps(channel, future, interestOps);
@Override protected void writeRequested(ChannelPipeline pipeline, MessageEvent e) throws Exception { messages.addLast(e); HttpChildChannel httpChannel = httpChannelRef.get(); if (httpChannel != null) { ChannelPipeline httpPipeline = httpChannel.getPipeline(); httpPipeline.execute(flushTask); } }
@Override public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception { ctx.getPipeline().execute(new Runnable() { @Override public void run() { try { NiftyIODispatcher.super.handleDownstream(ctx, e); } catch (Exception ex) { Channels.fireExceptionCaught(ctx.getChannel(), ex); } } }); } }
private void stopStream(final ChannelPipeline pipeline) { if (pipeline.isAttached()) { // avoid race between pipeline clean up and channel events on same pipeline // by executing the pipeline clean up on the I/O worker thread pipeline.execute(new Runnable() { @Override public void run() { stopStreamAligned(pipeline); } }); } else { // no race if not attached stopStreamAligned(pipeline); } }
@Override public ChannelFuture execute(ChannelPipeline httpPipeline, Runnable task) { ChannelPipeline pipeline = transport.getPipeline(); ChannelFuture future = pipeline.execute(task); Channel tlsChannel = pipeline.getChannel(); ChannelFuture tlsFuture = future(tlsChannel); chainFutures(future, tlsFuture); return tlsFuture; }
@Override public ChannelFuture execute(ChannelPipeline httpPipeline, Runnable task) { ChannelPipeline pipeline = transport.getPipeline(); ChannelFuture future = pipeline.execute(task); Channel httpChannel = pipeline.getChannel(); ChannelFuture httpFuture = future(httpChannel); chainFutures(future, httpFuture); return httpFuture; }
@Override public ChannelFuture execute(ChannelPipeline httpPipeline, Runnable task) { if (transport != null) { ChannelPipeline pipeline = transport.getPipeline(); ChannelFuture future = pipeline.execute(task); Channel httpChannel = pipeline.getChannel(); ChannelFuture httpFuture = future(httpChannel); chainFutures(future, httpFuture); return httpFuture; } return super.execute(httpPipeline, task); }
private void attach(final int sequenceNo, final HttpChildChannel httpChannel, final ChannelFuture httpFuture) { // TODO: handle out of order sequence arrival more defensively if (sequenceNo < nextSequenceNo.get()) { String message = format("Replayed sequence number: %d", sequenceNo); ChannelException exception = new ChannelException(message); httpFuture.setFailure(exception); } else if (nextSequenceNo.compareAndSet(sequenceNo, sequenceNo + 1)) { HttpChannelConfig httpConfig = httpChannel.getConfig(); HttpHeaders httpHeaders = httpConfig.getWriteHeaders(); httpHeaders.set(Names.CACHE_CONTROL, Values.NO_CACHE); httpHeaders.set(Names.CONTENT_TYPE, Values.APPLICATION_OCTET_STREAM); httpConfig.setMaximumBufferedContentLength(8192); httpChannelRef.set(httpChannel); flushTask.run(); httpFuture.setSuccess(); } else { Runnable reorderTask = new Runnable() { @Override public void run() { attach(sequenceNo, httpChannel, httpFuture); } }; ChannelPipeline httpPipeline = httpChannel.getPipeline(); httpPipeline.execute(reorderTask); } }
@Override public ChannelFuture execute(ChannelPipeline tlsPipeline, Runnable task) { if (transport != null) { ChannelPipeline pipeline = transport.getPipeline(); ChannelFuture future = pipeline.execute(task); Channel tlsChannel = pipeline.getChannel(); ChannelFuture tlsFuture = future(tlsChannel); chainFutures(future, tlsFuture); return tlsFuture; } return super.execute(tlsPipeline, task); }