Java tutorial
/* * 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.traffic; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPromise; import java.util.ArrayDeque; import java.util.concurrent.TimeUnit; /** * <p>This implementation of the {@link AbstractTrafficShapingHandler} is for channel * traffic shaping, that is to say a per channel limitation of the bandwidth.</p> * <p>Note the index used in {@code OutboundBuffer.setUserDefinedWritability(index, boolean)} is <b>1</b>.</p> * * <p>The general use should be as follow:</p> * <ul> * <li><p>Add in your pipeline a new ChannelTrafficShapingHandler.</p> * <p><tt>ChannelTrafficShapingHandler myHandler = new ChannelTrafficShapingHandler();</tt></p> * <p><tt>pipeline.addLast(myHandler);</tt></p> * * <p><b>Note that this handler has a Pipeline Coverage of "one" which means a new handler must be created * for each new channel as the counter cannot be shared among all channels.</b>.</p> * * <p>Other arguments can be passed like write or read limitation (in bytes/s where 0 means no limitation) * or the check interval (in millisecond) that represents the delay between two computations of the * bandwidth and so the call back of the doAccounting method (0 means no accounting at all).</p> * * <p>A value of 0 means no accounting for checkInterval. If you need traffic shaping but no such accounting, * it is recommended to set a positive value, even if it is high since the precision of the * Traffic Shaping depends on the period where the traffic is computed. The highest the interval, * the less precise the traffic shaping will be. It is suggested as higher value something close * to 5 or 10 minutes.</p> * * <p>maxTimeToWait, by default set to 15s, allows to specify an upper bound of time shaping.</p> * </li> * <li>In your handler, you should consider to use the {@code channel.isWritable()} and * {@code channelWritabilityChanged(ctx)} to handle writability, or through * {@code future.addListener(new GenericFutureListener())} on the future returned by * {@code ctx.write()}.</li> * <li><p>You shall also consider to have object size in read or write operations relatively adapted to * the bandwidth you required: for instance having 10 MB objects for 10KB/s will lead to burst effect, * while having 100 KB objects for 1 MB/s should be smoothly handle by this TrafficShaping handler.</p></li> * <li><p>Some configuration methods will be taken as best effort, meaning * that all already scheduled traffics will not be * changed, but only applied to new traffics.</p> * <p>So the expected usage of those methods are to be used not too often, * accordingly to the traffic shaping configuration.</p></li> * </ul> */ public class ChannelTrafficShapingHandler extends AbstractTrafficShapingHandler { private final ArrayDeque<ToSend> messagesQueue = new ArrayDeque<ToSend>(); private long queueSize; /** * Create a new instance. * * @param writeLimit * 0 or a limit in bytes/s * @param readLimit * 0 or a limit in bytes/s * @param checkInterval * The delay between two computations of performances for * channels or 0 if no stats are to be computed. * @param maxTime * The maximum delay to wait in case of traffic excess. */ public ChannelTrafficShapingHandler(long writeLimit, long readLimit, long checkInterval, long maxTime) { super(writeLimit, readLimit, checkInterval, maxTime); } /** * Create a new instance using default * max time as delay allowed value of 15000 ms. * * @param writeLimit * 0 or a limit in bytes/s * @param readLimit * 0 or a limit in bytes/s * @param checkInterval * The delay between two computations of performances for * channels or 0 if no stats are to be computed. */ public ChannelTrafficShapingHandler(long writeLimit, long readLimit, long checkInterval) { super(writeLimit, readLimit, checkInterval); } /** * Create a new instance using default Check Interval value of 1000 ms and * max time as delay allowed value of 15000 ms. * * @param writeLimit * 0 or a limit in bytes/s * @param readLimit * 0 or a limit in bytes/s */ public ChannelTrafficShapingHandler(long writeLimit, long readLimit) { super(writeLimit, readLimit); } /** * Create a new instance using * default max time as delay allowed value of 15000 ms and no limit. * * @param checkInterval * The delay between two computations of performances for * channels or 0 if no stats are to be computed. */ public ChannelTrafficShapingHandler(long checkInterval) { super(checkInterval); } @Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { TrafficCounter trafficCounter = new TrafficCounter(this, ctx.executor(), "ChannelTC" + ctx.channel().hashCode(), checkInterval); setTrafficCounter(trafficCounter); trafficCounter.start(); super.handlerAdded(ctx); } @Override public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { trafficCounter.stop(); // write order control synchronized (this) { if (ctx.channel().isActive()) { for (ToSend toSend : messagesQueue) { long size = calculateSize(toSend.toSend); trafficCounter.bytesRealWriteFlowControl(size); queueSize -= size; ctx.write(toSend.toSend, toSend.promise); } } else { for (ToSend toSend : messagesQueue) { if (toSend.toSend instanceof ByteBuf) { ((ByteBuf) toSend.toSend).release(); } } } messagesQueue.clear(); } releaseWriteSuspended(ctx); releaseReadSuspended(ctx); super.handlerRemoved(ctx); } private static final class ToSend { final long relativeTimeAction; final Object toSend; final ChannelPromise promise; private ToSend(final long delay, final Object toSend, final ChannelPromise promise) { relativeTimeAction = delay; this.toSend = toSend; this.promise = promise; } } @Override void submitWrite(final ChannelHandlerContext ctx, final Object msg, final long size, final long delay, final long now, final ChannelPromise promise) { final ToSend newToSend; // write order control synchronized (this) { if (delay == 0 && messagesQueue.isEmpty()) { trafficCounter.bytesRealWriteFlowControl(size); ctx.write(msg, promise); return; } newToSend = new ToSend(delay + now, msg, promise); messagesQueue.addLast(newToSend); queueSize += size; checkWriteSuspend(ctx, delay, queueSize); } final long futureNow = newToSend.relativeTimeAction; ctx.executor().schedule(new Runnable() { @Override public void run() { sendAllValid(ctx, futureNow); } }, delay, TimeUnit.MILLISECONDS); } private void sendAllValid(final ChannelHandlerContext ctx, final long now) { // write order control synchronized (this) { ToSend newToSend = messagesQueue.pollFirst(); for (; newToSend != null; newToSend = messagesQueue.pollFirst()) { if (newToSend.relativeTimeAction <= now) { long size = calculateSize(newToSend.toSend); trafficCounter.bytesRealWriteFlowControl(size); queueSize -= size; ctx.write(newToSend.toSend, newToSend.promise); } else { messagesQueue.addFirst(newToSend); break; } } if (messagesQueue.isEmpty()) { releaseWriteSuspended(ctx); } } ctx.flush(); } /** * @return current size in bytes of the write buffer. */ public long queueSize() { return queueSize; } }