- write() now accepts a ChannelPromise and returns ChannelFuture as most users expected. It makes the user's life much easier because it is now much easier to get notified when a specific message has been written. - flush() does not create a ChannelPromise nor returns ChannelFuture. It is now similar to what read() looks like.
144 lines
4.7 KiB
Java
144 lines
4.7 KiB
Java
/*
|
|
* Copyright 2012 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.handler.timeout;
|
|
|
|
import io.netty.bootstrap.ServerBootstrap;
|
|
import io.netty.channel.Channel;
|
|
import io.netty.channel.ChannelDuplexHandler;
|
|
import io.netty.channel.ChannelFuture;
|
|
import io.netty.channel.ChannelFutureListener;
|
|
import io.netty.channel.ChannelHandlerContext;
|
|
import io.netty.channel.ChannelInitializer;
|
|
import io.netty.channel.ChannelOutboundHandlerAdapter;
|
|
import io.netty.channel.ChannelPromise;
|
|
|
|
import java.util.concurrent.ScheduledFuture;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
/**
|
|
* Raises a {@link WriteTimeoutException} when no data was written within a
|
|
* certain period of time.
|
|
*
|
|
* <pre>
|
|
* // The connection is closed when there is no outbound traffic
|
|
* // for 30 seconds.
|
|
*
|
|
* public class MyChannelInitializer extends {@link ChannelInitializer}<{@link Channel}> {
|
|
* public void initChannel({@link Channel} channel) {
|
|
* channel.pipeline().addLast("writeTimeoutHandler", new {@link WriteTimeoutHandler}(30);
|
|
* channel.pipeline().addLast("myHandler", new MyHandler());
|
|
* }
|
|
* }
|
|
*
|
|
* // Handler should handle the {@link WriteTimeoutException}.
|
|
* public class MyHandler extends {@link ChannelDuplexHandler} {
|
|
* {@code @Override}
|
|
* public void exceptionCaught({@link ChannelHandlerContext} ctx, {@link Throwable} cause)
|
|
* throws {@link Exception} {
|
|
* if (cause instanceof {@link WriteTimeoutException}) {
|
|
* // do something
|
|
* } else {
|
|
* super.exceptionCaught(ctx, cause);
|
|
* }
|
|
* }
|
|
* }
|
|
*
|
|
* {@link ServerBootstrap} bootstrap = ...;
|
|
* ...
|
|
* bootstrap.childHandler(new MyChannelInitializer());
|
|
* ...
|
|
* </pre>
|
|
* @see ReadTimeoutHandler
|
|
* @see IdleStateHandler
|
|
*/
|
|
public class WriteTimeoutHandler extends ChannelOutboundHandlerAdapter {
|
|
|
|
private final long timeoutMillis;
|
|
|
|
private boolean closed;
|
|
|
|
/**
|
|
* Creates a new instance.
|
|
*
|
|
* @param timeoutSeconds
|
|
* write timeout in seconds
|
|
*/
|
|
public WriteTimeoutHandler(int timeoutSeconds) {
|
|
this(timeoutSeconds, TimeUnit.SECONDS);
|
|
}
|
|
|
|
/**
|
|
* Creates a new instance.
|
|
*
|
|
* @param timeout
|
|
* write timeout
|
|
* @param unit
|
|
* the {@link TimeUnit} of {@code timeout}
|
|
*/
|
|
public WriteTimeoutHandler(long timeout, TimeUnit unit) {
|
|
if (unit == null) {
|
|
throw new NullPointerException("unit");
|
|
}
|
|
|
|
if (timeout <= 0) {
|
|
timeoutMillis = 0;
|
|
} else {
|
|
timeoutMillis = Math.max(unit.toMillis(timeout), 1);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
|
|
scheduleTimeout(ctx, promise);
|
|
ctx.write(msg, promise);
|
|
}
|
|
|
|
private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise future) {
|
|
if (timeoutMillis > 0) {
|
|
// Schedule a timeout.
|
|
final ScheduledFuture<?> sf = ctx.executor().schedule(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (future.tryFailure(WriteTimeoutException.INSTANCE)) {
|
|
// If succeeded to mark as failure, notify the pipeline, too.
|
|
try {
|
|
writeTimedOut(ctx);
|
|
} catch (Throwable t) {
|
|
ctx.fireExceptionCaught(t);
|
|
}
|
|
}
|
|
}
|
|
}, timeoutMillis, TimeUnit.MILLISECONDS);
|
|
|
|
// Cancel the scheduled timeout if the flush future is complete.
|
|
future.addListener(new ChannelFutureListener() {
|
|
@Override
|
|
public void operationComplete(ChannelFuture future) throws Exception {
|
|
sf.cancel(false);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
protected void writeTimedOut(ChannelHandlerContext ctx) throws Exception {
|
|
if (!closed) {
|
|
ctx.fireExceptionCaught(WriteTimeoutException.INSTANCE);
|
|
ctx.close();
|
|
closed = true;
|
|
}
|
|
}
|
|
}
|