io.edurt.datacap.pinot.org.jboss.netty.handler.traffic.GlobalTrafficShapingHandler Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of datacap-shaded-pinot Show documentation
Show all versions of datacap-shaded-pinot Show documentation
DataCap - Shaded for Apache Pinot
/*
* 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.edurt.datacap.pinot.org.jboss.netty.handler.traffic;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import io.edurt.datacap.pinot.org.jboss.netty.channel.ChannelHandler.Sharable;
import io.edurt.datacap.pinot.org.jboss.netty.channel.ChannelHandlerContext;
import io.edurt.datacap.pinot.org.jboss.netty.channel.ChannelStateEvent;
import io.edurt.datacap.pinot.org.jboss.netty.channel.MessageEvent;
import io.edurt.datacap.pinot.org.jboss.netty.handler.execution.ExecutionHandler;
import io.edurt.datacap.pinot.org.jboss.netty.handler.execution.MemoryAwareThreadPoolExecutor;
import io.edurt.datacap.pinot.org.jboss.netty.handler.execution.OrderedMemoryAwareThreadPoolExecutor;
import io.edurt.datacap.pinot.org.jboss.netty.util.ObjectSizeEstimator;
import io.edurt.datacap.pinot.org.jboss.netty.util.Timeout;
import io.edurt.datacap.pinot.org.jboss.netty.util.Timer;
import io.edurt.datacap.pinot.org.jboss.netty.util.TimerTask;
/**
* This implementation of the {@link AbstractTrafficShapingHandler} is for global
* traffic shaping, that is to say a global limitation of the bandwidth, whatever
* the number of opened channels.
*
* The general use should be as follow:
*
* - Create your unique GlobalTrafficShapingHandler like:
* GlobalTrafficShapingHandler myHandler = new GlobalTrafficShapingHandler(timer);
* timer could be created using HashedWheelTimer
* pipeline.addLast("GLOBAL_TRAFFIC_SHAPING", myHandler);
*
* Note that this handler has a Pipeline Coverage of "all" which means only one such handler must be created
* and shared among all channels as the counter must be shared among all channels.
*
* 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).
*
* 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.
*
* maxTimeToWait, by default set to 15s, allows to specify an upper bound of time shaping.
*
* - Add it in your pipeline, before a recommended {@link ExecutionHandler} (like
* {@link OrderedMemoryAwareThreadPoolExecutor} or {@link MemoryAwareThreadPoolExecutor}).
* pipeline.addLast("GLOBAL_TRAFFIC_SHAPING", myHandler);
*
* - When you shutdown your application, release all the external resources
* by calling:
* myHandler.releaseExternalResources();
*
*
*/
@Sharable
public class GlobalTrafficShapingHandler extends AbstractTrafficShapingHandler {
private Map> messagesQueues = new HashMap>();
/**
* Create the global TrafficCounter
*/
void createGlobalTrafficCounter() {
TrafficCounter tc;
if (timer != null) {
tc = new TrafficCounter(this, timer, "GlobalTC",
checkInterval);
setTrafficCounter(tc);
tc.start();
}
}
public GlobalTrafficShapingHandler(Timer timer, long writeLimit,
long readLimit, long checkInterval) {
super(timer, writeLimit, readLimit, checkInterval);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(Timer timer, long writeLimit,
long readLimit, long checkInterval, long maxTime) {
super(timer, writeLimit, readLimit, checkInterval, maxTime);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(Timer timer, long writeLimit,
long readLimit) {
super(timer, writeLimit, readLimit);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(Timer timer, long checkInterval) {
super(timer, checkInterval);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(Timer timer) {
super(timer);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(ObjectSizeEstimator objectSizeEstimator,
Timer timer, long writeLimit, long readLimit,
long checkInterval) {
super(objectSizeEstimator, timer, writeLimit, readLimit,
checkInterval);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(ObjectSizeEstimator objectSizeEstimator,
Timer timer, long writeLimit, long readLimit,
long checkInterval, long maxTime) {
super(objectSizeEstimator, timer, writeLimit, readLimit,
checkInterval, maxTime);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(ObjectSizeEstimator objectSizeEstimator,
Timer timer, long writeLimit, long readLimit) {
super(objectSizeEstimator, timer, writeLimit, readLimit);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(ObjectSizeEstimator objectSizeEstimator,
Timer timer, long checkInterval) {
super(objectSizeEstimator, timer, checkInterval);
createGlobalTrafficCounter();
}
public GlobalTrafficShapingHandler(ObjectSizeEstimator objectSizeEstimator,
Timer timer) {
super(objectSizeEstimator, timer);
createGlobalTrafficCounter();
}
private static final class ToSend {
final long date;
final MessageEvent toSend;
private ToSend(final long delay, final MessageEvent toSend) {
this.date = System.currentTimeMillis() + delay;
this.toSend = toSend;
}
}
@Override
protected synchronized void submitWrite(final ChannelHandlerContext ctx, final MessageEvent evt, final long delay)
throws Exception {
Integer key = ctx.getChannel().getId();
List messagesQueue = messagesQueues.get(key);
if (delay == 0 && (messagesQueue == null || messagesQueue.isEmpty())) {
internalSubmitWrite(ctx, evt);
return;
}
if (timer == null) {
// Sleep since no executor
Thread.sleep(delay);
internalSubmitWrite(ctx, evt);
return;
}
if (messagesQueue == null) {
messagesQueue = new LinkedList();
messagesQueues.put(key, messagesQueue);
}
final ToSend newToSend = new ToSend(delay, evt);
messagesQueue.add(newToSend);
final List mqfinal = messagesQueue;
timer.newTimeout(new TimerTask() {
public void run(Timeout timeout) throws Exception {
sendAllValid(ctx, mqfinal);
}
}, delay + 1, TimeUnit.MILLISECONDS);
}
private synchronized void sendAllValid(ChannelHandlerContext ctx, final List messagesQueue)
throws Exception {
while (!messagesQueue.isEmpty()) {
ToSend newToSend = messagesQueue.remove(0);
if (newToSend.date <= System.currentTimeMillis()) {
internalSubmitWrite(ctx, newToSend.toSend);
} else {
messagesQueue.add(0, newToSend);
break;
}
}
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
Integer key = ctx.getChannel().getId();
List messagesQueue = new LinkedList();
messagesQueues.put(key, messagesQueue);
super.channelConnected(ctx, e);
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
Integer key = ctx.getChannel().hashCode();
List mq = messagesQueues.remove(key);
if (mq != null) {
mq.clear();
}
super.channelClosed(ctx, e);
}
}