org.jboss.netty.util.Timer Java Examples

@Override
public ChannelFactory get() {
    int workerCount = 0;

    if ("TCP".equalsIgnoreCase(thriftTransportConfig.getSpanDataSenderTransportType())) {
        workerCount++;
    }
    if ("TCP".equalsIgnoreCase(thriftTransportConfig.getStatDataSenderTransportType())) {
        workerCount++;
    }

    if (workerCount == 0) {
        return null;
    } else {
        Timer timer = connectTimerProvider.get();

        final ClientChannelFactory clientChannelFactory = new ClientChannelFactory();
        return clientChannelFactory.createChannelFactory(1, workerCount, timer);
    }
}
 

@Inject
public ThriftModuleLifeCycle(
        Provider<CommandDispatcher> commandDispatcherProvider,
        @DefaultClientFactory Provider<PinpointClientFactory> clientFactoryProvider,
        @AgentDataSender Provider<EnhancedDataSender<Object>> tcpDataSenderProvider,
        @SpanStatConnectTimer Provider<Timer> spanStatConnectTimerProvider,
        @SpanStatChannelFactory Provider<ChannelFactory> spanStatChannelFactoryProvider,
        @SpanClientFactory Provider<PinpointClientFactory> spanClientFactoryProvider,
        @StatClientFactory Provider<PinpointClientFactory> statClientFactoryProvider,
        @SpanDataSender Provider<DataSender> spanDataSenderProvider,
        @StatDataSender Provider<DataSender> statDataSenderProvider
        ) {
    this.commandDispatcherProvider = Assert.requireNonNull(commandDispatcherProvider, "commandDispatcherProvider");
    this.clientFactoryProvider = Assert.requireNonNull(clientFactoryProvider, "clientFactoryProvider");
    this.tcpDataSenderProvider = Assert.requireNonNull(tcpDataSenderProvider, "tcpDataSenderProvider");

    this.spanStatConnectTimerProvider = Assert.requireNonNull(spanStatConnectTimerProvider, "spanStatConnectTimerProvider");

    this.spanStatChannelFactoryProvider = Assert.requireNonNull(spanStatChannelFactoryProvider, "spanStatChannelFactoryProvider");

    this.spanClientFactoryProvider = Assert.requireNonNull(spanClientFactoryProvider, "spanClientFactoryProvider");
    this.statClientFactoryProvider = Assert.requireNonNull(statClientFactoryProvider, "statClientFactoryProvider");

    this.spanDataSenderProvider = Assert.requireNonNull(spanDataSenderProvider, "spanDataSenderProvider");
    this.statDataSenderProvider = Assert.requireNonNull(statDataSenderProvider, "statDataSenderProvider");
}
 

void connect(SocketAddressProvider remoteAddressProvider, boolean reconnect, PipelineFactory pipelineFactory) {
    Assert.requireNonNull(remoteAddressProvider, "remoteAddress");

    final ChannelPipeline pipeline = pipelineFactory.newPipeline();

    Timer channelTimer = createTimer("Pinpoint-PinpointClientHandler-Timer");
    final ChannelHandler writeTimeout = new WriteTimeoutHandler(channelTimer, 3000, TimeUnit.MILLISECONDS);
    pipeline.addLast("writeTimeout", writeTimeout);

    this.pinpointClientHandler = this.clientHandlerFactory.newClientHandler(connectionFactory, remoteAddressProvider, channelTimer, reconnect);
    if (pinpointClientHandler instanceof SimpleChannelHandler) {
        pipeline.addLast("socketHandler", (SimpleChannelHandler) this.pinpointClientHandler);
    } else {
        throw new IllegalArgumentException("invalid pinpointClientHandler");
    }

    final SocketAddress remoteAddress = remoteAddressProvider.resolve();
    this.connectFuture  = connect0(remoteAddress, pipeline);
}
 

public ChannelFactory createChannelFactory(int bossCount, int workerCount, Timer timer) {
    ExecutorService boss = newCachedThreadPool("Pinpoint-Client-Boss");
    BossPool bossPool = new NioClientBossPool(boss, bossCount, timer, ThreadNameDeterminer.CURRENT);

    ExecutorService worker = newCachedThreadPool("Pinpoint-Client-Worker");
    WorkerPool workerPool = new NioWorkerPool(worker, workerCount, ThreadNameDeterminer.CURRENT);
    return new NioClientSocketChannelFactory(bossPool, workerPool);
}
 

public HttpPipelineFactory(Configuration conf, Timer timer) throws Exception {
  SHUFFLE = getShuffle(conf);
  if (conf.getBoolean(SHUFFLE_SSL_ENABLED_KEY,
                      SHUFFLE_SSL_ENABLED_DEFAULT)) {
    LOG.info("Encrypted shuffle is enabled.");
    sslFactory = new SSLFactory(SSLFactory.Mode.SERVER, conf);
    sslFactory.init();
  }
  this.idleStateHandler = new IdleStateHandler(timer, 0, connectionKeepAliveTimeOut, 0);
}
 

public ControllerHandshakeTimeoutHandler(OFControllerChannelHandler channelHandler,
                               Timer timer,
                               long timeoutSeconds) {
    super();
    this.channelHandler = channelHandler;
    this.timer = timer;
    this.timeoutNanos = TimeUnit.SECONDS.toNanos(timeoutSeconds);

}
 

private Timer createTimer(String name) {
    final String timerName = getTimerName(name);

    HashedWheelTimer timer = TimerFactory.createHashedWheelTimer(timerName, 100, TimeUnit.MILLISECONDS, 512);
    timer.start();
    return timer;
}
 

@Override
public Timer get() {
    if ("TCP".equalsIgnoreCase(thriftTransportConfig.getSpanDataSenderTransportType()) || "TCP".equalsIgnoreCase(thriftTransportConfig.getStatDataSenderTransportType())) {
        return createTimer("Pinpoint-SpanStatConnect-Timer");
    }
    return null;
}
 

public HealthCheckManager(Timer timer, long waitTimeMillis, ChannelGroup channelGroup) {
    Assert.requireNonNull(timer, "timer");
    Assert.isTrue(waitTimeMillis > 0, "waitTimeMillis is must greater than 0");
    Assert.requireNonNull(channelGroup, "channelGroup");

    this.timer = timer;
    this.waitTimeMillis = waitTimeMillis;

    this.channelGroup = channelGroup;
}
 

public DefaultPinpointClientFactory(ChannelFactory channelFactory, Timer timer, ConnectionFactoryProvider connectionFactoryProvider) {
    this.channelFactory = Assert.requireNonNull(channelFactory, "channelFactory");
    this.timer = Assert.requireNonNull(timer, "timer");

    this.useExternalResource = true;
    this.socketOptionBuilder = new SocketOption.Builder();
    this.connectionFactoryProvider = Assert.requireNonNull(connectionFactoryProvider, "connectionFactoryProvider");
}
 

public PinpointClientHandshaker(Map<String, Object> handshakeData, Timer handshakerTimer, long retryInterval, int maxHandshakeCount) {
    Assert.isTrue(retryInterval > 0, "retryInterval must greater than zero.");
    Assert.isTrue(maxHandshakeCount > 0, "maxHandshakeCount must greater than zero.");
    
    this.state = new AtomicInteger(STATE_INIT);
    this.handshakerTimer = Assert.requireNonNull(handshakerTimer, "handshakerTimer");
    this.handshakeData = Assert.requireNonNull(handshakeData, "handshakeData");

    this.retryInterval = retryInterval;
    this.maxHandshakeCount = maxHandshakeCount;

    this.handshakeCount = new AtomicInteger(0);
}
 

public NettyDispatcher(NettyServerConfiguration configuration, Timer timer) {
	this.processorFactory = configuration.getProcessorFactory();
	this.protocolFactory = configuration.getProtocolFactory();
	this.queuedResponseLimit = configuration.getQueuedResponseLimit();
	this.taskTimeoutMillis = 0;
	this.taskTimeoutTimer = timer;
	this.queueTimeoutMillis = 0;
}
 

@Override
public PinpointClientHandler newClientHandler(ConnectionFactory connectionFactory, SocketAddressProvider remoteAddressProvider, Timer channelTimer, boolean reconnect) {
    PinpointClientHandshaker handshaker = handshakerFactory.newHandShaker(channelTimer);
    final DefaultPinpointClientHandler clientHandler = new DefaultPinpointClientHandler(connectionFactory, remoteAddressProvider, handshaker,
            clusterOption, clientOption, channelTimer,
            messageListener,
            serverStreamChannelMessageHandler,
            stateChangeEventListeners
    );

    if (reconnect) {
        clientHandler.initReconnect();
    }
    return clientHandler;
}
 

ConnectionFactory(Timer connectTimer, Closed closed, ChannelFactory channelFactory,
                         SocketOption socketOption, ClientOption clientOption, ClientHandlerFactory clientHandlerFactory, PipelineFactory pipelineFactory) {

    this.connectTimer = Assert.requireNonNull(connectTimer, "connectTimer");
    this.closed = Assert.requireNonNull(closed, "release");

    this.channelFactory = Assert.requireNonNull(channelFactory, "channelFactory");

    this.socketOption = Assert.requireNonNull(socketOption, "option");
    this.clientOption = Assert.requireNonNull(clientOption, "connectTimer");
    this.clientHandlerFactory = Assert.requireNonNull(clientHandlerFactory, "clientHandlerFactory");
    this.pipelineFactory = Assert.requireNonNull(pipelineFactory, "pipelineFactory");
}
 

public RequestManager(Timer timer, long defaultTimeoutMillis) {
    if (timer == null) {
        throw new NullPointerException("timer");
    }
    
    if (defaultTimeoutMillis <= 0) {
        throw new IllegalArgumentException("defaultTimeoutMillis must greater than zero.");
    }
    
    this.timer = timer;
    this.defaultTimeoutMillis = defaultTimeoutMillis;
}
 

public DefaultPinpointClientHandler(ConnectionFactory connectionFactory, SocketAddressProvider socketAddressProvider, PinpointClientHandshaker handshaker,
                                    ClusterOption localClusterOption, ClientOption clientOption,
                                    Timer channelTimer,
                                    MessageListener messageListener,
                                    ServerStreamChannelMessageHandler serverStreamChannelMessageHandler,
                                    List<StateChangeEventListener> stateChangeEventListeners) {

    this.connectionFactory = Assert.requireNonNull(connectionFactory, "clientFactory");
    this.socketAddressProvider = Assert.requireNonNull(socketAddressProvider, "socketAddressProvider");

    this.channelTimer = Assert.requireNonNull(channelTimer, "channelTimer");
    this.requestManager = new RequestManager(channelTimer, clientOption.getRequestTimeoutMillis());
    this.clientOption = Assert.requireNonNull(clientOption, "clientOption");


    this.messageListener = Assert.requireNonNull(messageListener, "messageListener");
    this.serverStreamChannelMessageHandler = Assert.requireNonNull(serverStreamChannelMessageHandler, "serverStreamChannelMessageHandler");

    this.objectUniqName = ClassUtils.simpleClassNameAndHashCodeString(this);
    this.handshaker = Assert.requireNonNull(handshaker, "handshaker");

    this.pingIdGenerator = new AtomicInteger(0);
    this.state = new PinpointClientHandlerState(this.objectUniqName, this, stateChangeEventListeners);

    this.localClusterOption = Assert.requireNonNull(localClusterOption, "clusterOption");

}
 

public HandshakeTimeoutHandler(RPCChannelHandler handler,
                               Timer timer,
                               long timeoutSeconds) {
    super();
    this.handler = handler;
    this.timer = timer;
    this.timeoutNanos = TimeUnit.SECONDS.toNanos(timeoutSeconds);

}
 

public BootstrapTimeoutHandler(Timer timer,
                               long timeoutSeconds) {
    super();
    this.timer = timer;
    this.timeoutNanos = TimeUnit.SECONDS.toNanos(timeoutSeconds);

}
 

public RSHandshakeTimeoutHandler(RemoteSyncChannelHandler channelHandler,
                                 Timer timer,
                                 long timeoutSeconds) {
    super();
    this.channelHandler = channelHandler;
    this.timer = timer;
    this.timeoutNanos = TimeUnit.SECONDS.toNanos(timeoutSeconds);
}
 

public HandshakeTimeoutHandler(OFChannelHandler channelHandler,
                               Timer timer,
                               long timeoutSeconds) {
    super();
    this.channelHandler = channelHandler;
    this.timer = timer;
    this.timeoutNanos = TimeUnit.SECONDS.toNanos(timeoutSeconds);

}
 

private Timer createTimer() {
    HashedWheelTimer timer = TimerFactory.createHashedWheelTimer("Pinpoint-Flink-Cluster-Timer", 100, TimeUnit.MILLISECONDS, 512);
    timer.start();
    return timer;
}
 

public NettyClientHandler(NettyClient client, Timer timer){
	this.client = client;
	this.timer = timer;
}
 

public CommonsConnectionPool(Timer timer, ChannelFactory channelFactory) {
    this.channelFactory = channelFactory;
    this.timer = timer;
}
 

public HttpOutboundPipeline (Timer timer) {
    IDLE_STATE_HANDLER = new IdleStateHandler(timer, IDLE_TIMEOUT_READER, IDLE_TIMEOUT_WRITER, IDLE_TIMEOUT_BOTH);
}
 

public CommonHttpPipeline(Timer timer) {
    this.idleStateHandler = new IdleStateHandler(timer, IDLE_TIMEOUT_READER, IDLE_TIMEOUT_WRITER, IDLE_TIMEOUT_BOTH);
    this.outboundConnectionPool = new CommonsConnectionPool(timer, OUTBOUND_CHANNEL_FACTORY);
}
 

NioClientBoss(Executor bossExecutor, Timer timer, ThreadNameDeterminer determiner) {
    super(bossExecutor, determiner);
    this.timer = timer;
}
 

@Inject
public SpanClientFactoryProvider(ThriftTransportConfig thriftTransportConfig, @SpanStatChannelFactory Provider<ChannelFactory> channelFactoryProvider, @SpanStatConnectTimer Provider<Timer> spanStatConnectTimer) {
    this.thriftTransportConfig = Assert.requireNonNull(thriftTransportConfig, "thriftTransportConfig");
    this.channelFactoryProvider = Assert.requireNonNull(channelFactoryProvider, "channelFactoryProvider");
    this.spanStatConnectTimer = Assert.requireNonNull(spanStatConnectTimer, "spanStatConnectTimer");
}
 

private static Timer createTimer(String timerName) {
    HashedWheelTimer timer = TimerFactory.createHashedWheelTimer(timerName, 100, TimeUnit.MILLISECONDS, 512);
    timer.start();
    return timer;
}
 

@Inject
public SpanStatChannelFactoryProvider(ThriftTransportConfig thriftTransportConfig, @SpanStatConnectTimer Provider<Timer> connectTimerProvider) {
    this.thriftTransportConfig = Assert.requireNonNull(thriftTransportConfig, "thriftTransportConfig");
    this.connectTimerProvider = Assert.requireNonNull(connectTimerProvider, "connectTimerProvider");
}
 

@Inject
public StatClientFactoryProvider(ThriftTransportConfig thriftTransportConfig, @SpanStatChannelFactory Provider<ChannelFactory> channelFactoryProvider, @SpanStatConnectTimer Provider<Timer> connectTimerProvider) {
    this.thriftTransportConfig = Assert.requireNonNull(thriftTransportConfig, "thriftTransportConfig");
    this.channelFactoryProvider = Assert.requireNonNull(channelFactoryProvider, "channelFactoryProvider");
    this.connectTimerProvider = Assert.requireNonNull(connectTimerProvider, "connectTimerProvider");
}