import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
public static void init() throws Exception {
    if (INSTANCE != null) {
        return;
    }
    log.info("\tLoading configuration file...");
    load();
    log.info("\tChecking configuration items...");
    check();
    if (INSTANCE.relayPort.length > 0) {
        log.info("\tStarting Relays...");
        startupRelays();
    }
    log.info("\tInitializing dns cache...");
    DnsCache.init(INSTANCE.dnsCacheCapacity);
    log.info("\tInitializing global network traffic handler...");
    TRAFFIC_HANDLER = new GlobalTrafficShapingHandler(Executors.newScheduledThreadPool(1), 1000);
    TRAFFIC_HANDLER.setWriteLimit(INSTANCE.writeLimit);
    TRAFFIC_HANDLER.setReadLimit(INSTANCE.readLimit);
    log.info("\tEnd of configuration");
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
@Override
public boolean execute(String[] args) {

    logger.info("Connections: {}", Apex.getChannelGroup().size());
    if (Apex.getInstance().getConnectionsPerSecondTask() != null) {
        logger.info("Connections per second: {}", Apex.getInstance().getConnectionsPerSecondTask().getPerSecond());
    }
    logger.info("Online backend servers: {}", Apex.getBalancingStrategy().size());

    GlobalTrafficShapingHandler trafficShapingHandler = Apex.getInstance().getTrafficShapingHandler();
    if (trafficShapingHandler != null) {
        TrafficCounter trafficCounter = trafficShapingHandler.trafficCounter();

        logger.info("Current bytes read: {}", trafficCounter.currentReadBytes());
        logger.info("Current bytes written: {}", trafficCounter.currentWrittenBytes());
        logger.info("Last read throughput: {}", trafficCounter.lastReadThroughput());
        logger.info("Last write throughput: {}", trafficCounter.lastWrittenBytes());
        logger.info("Total bytes read: {}", trafficCounter.cumulativeReadBytes());
        logger.info("Total bytes written: {}", trafficCounter.cumulativeWrittenBytes());
    }

    return true;
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
private ProxyToServerConnection(
        DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        ChainedProxy chainedProxy,
        Queue<ChainedProxy> availableChainedProxies,
        HttpFilters initialFilters,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    super(DISCONNECTED, proxyServer, true);
    this.clientConnection = clientConnection;
    this.serverHostAndPort = serverHostAndPort;
    this.chainedProxy = chainedProxy;
    this.availableChainedProxies = availableChainedProxies;
    this.trafficHandler = globalTrafficShapingHandler;
    this.currentFilters = initialFilters;

    // Report connection status to HttpFilters
    currentFilters.proxyToServerConnectionQueued();

    setupConnectionParameters();
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
private ProxyToServerConnection(
        DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        ChainedProxy chainedProxy,
        Queue<ChainedProxy> availableChainedProxies,
        HttpFilters initialFilters,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    super(DISCONNECTED, proxyServer, true);
    this.clientConnection = clientConnection;
    this.serverHostAndPort = serverHostAndPort;
    this.chainedProxy = chainedProxy;
    this.availableChainedProxies = availableChainedProxies;
    this.trafficHandler = globalTrafficShapingHandler;
    this.currentFilters = initialFilters;

    // Report connection status to HttpFilters
    this.currentFilters.proxyToServerConnectionQueued();

    setupConnectionParameters();
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
public void start() {
    Configuration config = Configuration.INSTANCE;
    InternalLoggerFactory.setDefaultFactory(Slf4JLoggerFactory.INSTANCE);
    EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline()
                                .addLast("logging", new LoggingHandler(LogLevel.DEBUG))
                                .addLast(new XConnectHandler());
                        if (config.getReadLimit() != 0 || config.getWriteLimit() != 0) {
                            socketChannel.pipeline().addLast(
                                    new GlobalTrafficShapingHandler(Executors.newScheduledThreadPool(1), config.getWriteLimit(), config.getReadLimit())
                            );
                        }
                    }
                });
        log.info("\tStartup {}-{}-server [{}]", Constants.APP_NAME, Constants.APP_VERSION, config.getProtocol());
        new Thread(() -> new UdpServer().start()).start();
        ChannelFuture future = bootstrap.bind(config.getHost(), config.getPort()).sync();
        future.addListener(future1 -> log.info("\tTCP listening at {}:{}...", config.getHost(), config.getPort()));
        future.channel().closeFuture().sync();
    } catch (Exception e) {
        log.error("\tSocket bind failure ({})", e.getMessage());
    } finally {
        log.info("\tShutting down and recycling...");
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
        Configuration.shutdownRelays();
    }
    System.exit(0);
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
public void start() {
	try {

		FSClient.start();

		Config config = ConfigXmlLoader.load(CONFIG);
		PacLoader.load(PAC);

		bossGroup = new NioEventLoopGroup(1);
		workerGroup = new NioEventLoopGroup();
		bootstrap = new ServerBootstrap();
		trafficHandler = new GlobalTrafficShapingHandler(
				Executors.newScheduledThreadPool(2), 1000);

		bootstrap
				.group(bossGroup, workerGroup)
				.channel(NioServerSocketChannel.class)
				.childHandler(
						new SocksServerInitializer(config, trafficHandler));

		logger.info("Start At Port " + config.get_localPort());
		startMBean();
		bootstrap.bind(config.get_localPort()).sync().channel()
				.closeFuture().sync();
	} catch (Exception e) {
		logger.error("start error", e);
	} finally {
		stop();
	}
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
@Override
protected void initChannel(SocketChannel channel) throws Exception {

    BackendInfo backendInfo = Apex.getBalancingStrategy()
            .selectBackend(channel.remoteAddress().getHostName(), channel.remoteAddress().getPort());

    if (backendInfo == null) {
        // Gracefully close the channel
        channel.close();

        logger.error("Unable to select a backend server. All down?");
        return;
    }

    channel.pipeline()
            .addLast(new ReadTimeoutHandler(readTimeout))
            .addLast(new WriteTimeoutHandler(writeTimeout));

    GlobalTrafficShapingHandler trafficShapingHandler = Apex.getInstance().getTrafficShapingHandler();
    if (trafficShapingHandler != null) {
        channel.pipeline().addLast(trafficShapingHandler);
    }

    channel.pipeline().addLast(new SocketUpstreamHandler(backendInfo));

    // Keep track of connections per second
    if (connectionsPerSecondTask != null) {
        connectionsPerSecondTask.inc();
    }

    logger.debug("Connected [{}] <-> [{}:{} ({})]", channel.remoteAddress(), backendInfo.getHost(), backendInfo.getPort(), backendInfo.getName());
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
ClientToProxyConnection(
        final DefaultHttpProxyServer proxyServer,
        SslEngineSource sslEngineSource,
        boolean authenticateClients,
        ChannelPipeline pipeline,
        GlobalTrafficShapingHandler globalTrafficShapingHandler) {
    super(AWAITING_INITIAL, proxyServer, false);

    initChannelPipeline(pipeline);

    if (sslEngineSource != null) {
        LOG.debug("Enabling encryption of traffic from client to proxy");
        encrypt(pipeline, sslEngineSource.newSslEngine(),
                authenticateClients)
                .addListener(
                        new GenericFutureListener<Future<? super Channel>>() {
                            @Override
                            public void operationComplete(
                                    Future<? super Channel> future)
                                    throws Exception {
                                if (future.isSuccess()) {
                                    clientSslSession = sslEngine
                                            .getSession();
                                    recordClientSSLHandshakeSucceeded();
                                }
                            }
                        });
    }
    this.globalTrafficShapingHandler = globalTrafficShapingHandler;

    LOG.debug("Created ClientToProxyConnection");
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
/**
 * Create a new ProxyToServerConnection.
 * 
 * @param proxyServer
 * @param clientConnection
 * @param serverHostAndPort
 * @param initialFilters
 * @param initialHttpRequest
 * @return
 * @throws UnknownHostException
 */
static ProxyToServerConnection create(DefaultHttpProxyServer proxyServer,
        ClientToProxyConnection clientConnection,
        String serverHostAndPort,
        HttpFilters initialFilters,
        HttpRequest initialHttpRequest,
        GlobalTrafficShapingHandler globalTrafficShapingHandler)
        throws UnknownHostException {
    Queue<ChainedProxy> chainedProxies = new ConcurrentLinkedQueue<ChainedProxy>();
    ChainedProxyManager chainedProxyManager = proxyServer
            .getChainProxyManager();
    if (chainedProxyManager != null) {
        chainedProxyManager.lookupChainedProxies(initialHttpRequest,
                chainedProxies);
        if (chainedProxies.size() == 0) {
            // ChainedProxyManager returned no proxies, can't connect
            return null;
        }
    }
    return new ProxyToServerConnection(proxyServer,
            clientConnection,
            serverHostAndPort,
            chainedProxies.poll(),
            chainedProxies,
            initialFilters,
            globalTrafficShapingHandler);
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
public SocksServerInitializer(Config config,
		GlobalTrafficShapingHandler trafficHandler) {
	this.trafficHandler = trafficHandler;
	socksMessageEncoder = new SocksMessageEncoder();
	socksServerHandler = new SocksServerHandler(config);
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
public static GlobalTrafficShapingHandler getShaper() {
  initIfNecessary();
  return shaper;
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
/**
 * Creates a new GlobalTrafficShapingHandler for this HttpProxyServer, using this proxy's proxyToServerEventLoop.
 *
 * @param transportProtocol
 * @param readThrottleBytesPerSecond
 * @param writeThrottleBytesPerSecond
 *
 * @return
 */
private GlobalTrafficShapingHandler createGlobalTrafficShapingHandler(TransportProtocol transportProtocol, long readThrottleBytesPerSecond, long writeThrottleBytesPerSecond) {
    EventLoopGroup proxyToServerEventLoop = this.getProxyToServerWorkerFor(transportProtocol);
    return new GlobalTrafficShapingHandler(proxyToServerEventLoop,
            writeThrottleBytesPerSecond,
            readThrottleBytesPerSecond,
            TRAFFIC_SHAPING_CHECK_INTERVAL_MS,
            Long.MAX_VALUE);
}
 

import io.netty.handler.traffic.GlobalTrafficShapingHandler; //导入依赖的package包/类
public GlobalTrafficShapingHandler getTrafficShapingHandler() {

        return trafficShapingHandler;
    }