Java SingletonTask.reschedule方法代码示例

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
/**
 * Connect to remote servers.  We'll initiate the connection to
 * any nodes with a lower ID so that there will be a single connection
 * between each pair of nodes which we'll use symmetrically
 */
protected void startClients(RPCChannelInitializer channelInitializer) {
    final Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(workerGroup)
    .channel(NioSocketChannel.class)
    .option(ChannelOption.SO_REUSEADDR, true)
    .option(ChannelOption.SO_KEEPALIVE, true)
    .option(ChannelOption.TCP_NODELAY, true)
    .option(ChannelOption.SO_SNDBUF, SEND_BUFFER_SIZE)
    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, CONNECT_TIMEOUT)
    .handler(channelInitializer);
    clientBootstrap = bootstrap;

    ScheduledExecutorService ses = 
            syncManager.getThreadPool().getScheduledExecutor();
    reconnectTask = new SingletonTask(ses, new ConnectTask());
    reconnectTask.reschedule(0, TimeUnit.SECONDS);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
	// thread to do flow reconcile
	ScheduledExecutorService ses = threadPoolService.getScheduledExecutor();
	flowReconcileTask = new SingletonTask(ses, new Runnable() {
		@Override
		public void run() {
			try {
				if (doReconcile()) {
					flowReconcileTask.reschedule(
							FLOW_RECONCILE_DELAY_MILLISEC,
							TimeUnit.MILLISECONDS);
				}
			} catch (Exception e) {
				logger.warn("Exception in doReconcile(): {}", e);
			}
		}
	});

	String packetInName = OFType.PACKET_IN.getClass().getName();
	packetInName = packetInName.substring(packetInName.lastIndexOf('.')+1);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
	clearCurrentTopology();
	// Initialize role to floodlight provider role.
	this.role = floodlightProviderService.getRole();

	ScheduledExecutorService ses = threadPoolService.getScheduledExecutor();
	newInstanceTask = new SingletonTask(ses, new UpdateTopologyWorker());

	if (role != HARole.STANDBY) {
		newInstanceTask.reschedule(TOPOLOGY_COMPUTE_INTERVAL_MS, TimeUnit.MILLISECONDS);
	}

	linkDiscoveryService.addListener(this);
	floodlightProviderService.addOFMessageListener(OFType.PACKET_IN, this);
	floodlightProviderService.addHAListener(this.haListener);
	addRestletRoutable();
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
/**
 * Connect to remote servers.  We'll initiate the connection to
 * any nodes with a lower ID so that there will be a single connection
 * between each pair of nodes which we'll use symmetrically
 */
protected void startClients(ChannelPipelineFactory pipelineFactory) {
    final ClientBootstrap bootstrap =
            new ClientBootstrap(
                 new NioClientSocketChannelFactory(bossExecutor,
                                                   workerExecutor));
    bootstrap.setOption("child.reuseAddr", true);
    bootstrap.setOption("child.keepAlive", true);
    bootstrap.setOption("child.tcpNoDelay", true);
    bootstrap.setOption("child.sendBufferSize", SEND_BUFFER_SIZE);
    bootstrap.setOption("child.connectTimeoutMillis", CONNECT_TIMEOUT);
    bootstrap.setPipelineFactory(pipelineFactory);
    clientBootstrap = bootstrap;

    ScheduledExecutorService ses = 
            syncManager.getThreadPool().getScheduledExecutor();
    reconnectTask = new SingletonTask(ses, new ConnectTask());
    reconnectTask.reschedule(0, TimeUnit.SECONDS);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
	clearCurrentTopology();
	// Initialize role to floodlight provider role.
	this.role = floodlightProviderService.getRole();

	ScheduledExecutorService ses = threadPoolService.getScheduledExecutor();
	newInstanceTask = new SingletonTask(ses, new UpdateTopologyWorker());

	if (role != HARole.STANDBY)
		newInstanceTask.reschedule(TOPOLOGY_COMPUTE_INTERVAL_MS,
				TimeUnit.MILLISECONDS);

	linkDiscoveryService.addListener(this);
	floodlightProviderService.addOFMessageListener(OFType.PACKET_IN, this);
	floodlightProviderService.addHAListener(this.haListener);
	addRestletRoutable();
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
    clearCurrentTopology();
    // Initialize role to floodlight provider role.
    this.role = floodlightProvider.getRole();

    ScheduledExecutorService ses = threadPool.getScheduledExecutor();
    newInstanceTask = new SingletonTask(ses, new UpdateTopologyWorker());

    if (role != Role.SLAVE)
        newInstanceTask.reschedule(TOPOLOGY_COMPUTE_INTERVAL_MS,
                               TimeUnit.MILLISECONDS);

    linkDiscovery.addListener(this);
    floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
    floodlightProvider.addHAListener(this.haListener);
    addRestletRoutable();
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
/**
 * Connect to remote servers.  We'll initiate the connection to
 * any nodes with a lower ID so that there will be a single connection
 * between each pair of nodes which we'll use symmetrically
 */
protected void startClients(RPCChannelInitializer channelInitializer) {
    final Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(workerGroup)
    .channel(NioSocketChannel.class)
    .option(ChannelOption.SO_REUSEADDR, true)
    .option(ChannelOption.SO_KEEPALIVE, true)
    .option(ChannelOption.TCP_NODELAY, true)
    .option(ChannelOption.SO_SNDBUF, SEND_BUFFER_SIZE)
    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, CONNECT_TIMEOUT)
    .handler(channelInitializer);
    clientBootstrap = bootstrap;

    ScheduledExecutorService ses =
            syncManager.getThreadPool().getScheduledExecutor();
    reconnectTask = new SingletonTask(ses, new ConnectTask());
    reconnectTask.reschedule(0, TimeUnit.SECONDS);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context)
        throws FloodlightModuleException {

    rpcService = new RPCService(this, debugCounter);

    cleanupTask = new SingletonTask(threadPool.getScheduledExecutor(),
                                    new CleanupTask());
    cleanupTask.reschedule(CLEANUP_INTERVAL +
                           random.nextInt(30), TimeUnit.SECONDS);

    antientropyTask = new SingletonTask(threadPool.getScheduledExecutor(),
                                   new AntientropyTask());
    antientropyTask.reschedule(ANTIENTROPY_INTERVAL +
                               random.nextInt(30), TimeUnit.SECONDS);

    final ThreadGroup tg = new ThreadGroup("Hint Workers");
    tg.setMaxPriority(Thread.NORM_PRIORITY - 2);
    ThreadFactory f = new ThreadFactory() {
        AtomicInteger id = new AtomicInteger();

        @Override
        public Thread newThread(Runnable runnable) {
            return new Thread(tg, runnable,
                              "HintWorker-" + id.getAndIncrement());
        }
    };
    hintThreadPool = Executors.newCachedThreadPool(f);
    for (int i = 0; i < SYNC_WORKER_POOL; i++) {
        hintThreadPool.execute(new HintWorker());
    }

    doUpdateConfiguration();
    rpcService.run();

    updateConfigTask =
            new SingletonTask(threadPool.getScheduledExecutor(),
                              new UpdateConfigTask());
    updateConfigTask.reschedule(CONFIG_RESCAN_INTERVAL, TimeUnit.SECONDS);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
    // thread to do flow reconcile
    ScheduledExecutorService ses = threadPool.getScheduledExecutor();
    flowReconcileTask = new SingletonTask(ses, new Runnable() {
        @Override
        public void run() {
            try {
                if (doReconcile()) {
                    flowReconcileTask.reschedule(
                        FLOW_RECONCILE_DELAY_MILLISEC,
                        TimeUnit.MILLISECONDS);
                }
            } catch (Exception e) {
                logger.warn("Exception in doReconcile(): {}", e);
            }
        }
    });

    String packetInName = OFType.PACKET_IN.toClass().getName();
    packetInName = packetInName.substring(packetInName.lastIndexOf('.')+1);

    // Construct controller counter for the packet_in
    controllerPktInCounterName =
        CounterStore.createCounterName(ICounterStoreService.CONTROLLER_NAME,
                                       -1,
                                       packetInName);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
    // thread to do flow reconcile
    ScheduledExecutorService ses = threadPool.getScheduledExecutor();
    flowReconcileTask = new SingletonTask(ses, new Runnable() {
        @Override
        public void run() {
            try {
                if (doReconcile()) {
                    flowReconcileTask.reschedule(
                        FLOW_RECONCILE_DELAY_MILLISEC,
                        TimeUnit.MILLISECONDS);
                }
            } catch (Exception e) {
                logger.warn("Exception in doReconcile(): {}",
                            e.getMessage());
                e.printStackTrace();
            }
        }
    });
    
    String packetInName = OFType.PACKET_IN.toClass().getName();
    packetInName = packetInName.substring(packetInName.lastIndexOf('.')+1); 
    
    // Construct controller counter for the packet_in
    controllerPktInCounterName =
        CounterStore.createCounterName(ICounterStoreService.CONTROLLER_NAME, 
                                       -1,
                                       packetInName);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
    floodlightProvider.addOFSwitchListener(this);
    linkDiscovery.addListener(this);
    hostService.addHostListener(this);

    eventChannel = datagridService.createChannel(
                            TopologyManager.EVENT_CHANNEL_NAME,
                            byte[].class,
                            TopologyEvent.class);

    mutableTopology = topologyService.getTopology();

    // Run the cleanup thread
    String enableCleanup =
            context.getConfigParams(this).get(ENABLE_CLEANUP_PROPERTY);
    if (enableCleanup != null
            && enableCleanup.equalsIgnoreCase("false")) {
        cleanupEnabled = false;
    }

    log.debug("Cleanup thread is {}enabled", (cleanupEnabled) ? "" : "not ");

    if (cleanupEnabled) {
        IThreadPoolService threadPool =
                context.getServiceImpl(IThreadPoolService.class);
        cleanupTask = new SingletonTask(threadPool.getScheduledExecutor(),
                new SwitchCleanup());
        // Run the cleanup task immediately on startup
        cleanupTask.reschedule(0, TimeUnit.SECONDS);
    }

    // Run the Delayed Operations Handler thread
    delayedOperationsHandler.start();
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
    ScheduledExecutorService ses = threadPool.getScheduledExecutor();
    newInstanceTask = new SingletonTask(ses, new UpdateTopologyWorker());

    if (floodlightProvider.getRole() != Role.SLAVE)
        newInstanceTask.reschedule(TOPOLOGY_COMPUTE_INTERVAL_MS,
                               TimeUnit.MILLISECONDS);

    linkDiscovery.addListener(this);
    floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
    floodlightProvider.addHAListener(this);
    addRestletRoutable();
    registerTopologyDebugCounters();
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context) {
    ScheduledExecutorService ses = threadPool.getScheduledExecutor();
    newInstanceTask = new SingletonTask(ses, new UpdateTopologyWorker());

    if (floodlightProvider.getRole() != Role.SLAVE)
        newInstanceTask.reschedule(TOPOLOGY_COMPUTE_INTERVAL_MS,
                               TimeUnit.MILLISECONDS);

    linkDiscovery.addListener(this);
    floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
    floodlightProvider.addHAListener(this);
    addRestletRoutable();
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
public void startUp(FloodlightModuleContext context)
		throws FloodlightModuleException {

	timer = new HashedWheelTimer();
	rpcService = new RPCService(this, debugCounter, timer);

	cleanupTask = new SingletonTask(threadPool.getScheduledExecutor(),
			new CleanupTask());
	cleanupTask.reschedule(CLEANUP_INTERVAL +
			random.nextInt(30), TimeUnit.SECONDS);

	antientropyTask = new SingletonTask(threadPool.getScheduledExecutor(),
			new AntientropyTask());
	antientropyTask.reschedule(ANTIENTROPY_INTERVAL +
			random.nextInt(30), TimeUnit.SECONDS);

	final ThreadGroup tg = new ThreadGroup("Hint Workers");
	tg.setMaxPriority(Thread.NORM_PRIORITY - 2);
	ThreadFactory f = new ThreadFactory() {
		AtomicInteger id = new AtomicInteger();

		@Override
		public Thread newThread(Runnable runnable) {
			return new Thread(tg, runnable,
					"HintWorker-" + id.getAndIncrement());
		}
	};
	hintThreadPool = Executors.newCachedThreadPool(f);
	for (int i = 0; i < SYNC_WORKER_POOL; i++) {
		hintThreadPool.execute(new HintWorker());
	}

	doUpdateConfiguration();
	rpcService.run();

	updateConfigTask =
			new SingletonTask(threadPool.getScheduledExecutor(),
					new UpdateConfigTask());
	updateConfigTask.reschedule(CONFIG_RESCAN_INTERVAL, TimeUnit.SECONDS);
}
 

import net.floodlightcontroller.core.util.SingletonTask; //导入方法依赖的package包/类
@Override
@LogMessageDocs({
        @LogMessageDoc(level = "ERROR",
                message = "No storage source found.",
                explanation = "Storage source was not initialized; cannot initialize "
                        +
                        "link discovery.",
                recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG),
        @LogMessageDoc(level = "ERROR",
                message = "Error in installing listener for " +
                        "switch config table {table}",
                explanation = "Failed to install storage notification for the " +
                        "switch config table",
                recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG),
        @LogMessageDoc(level = "ERROR",
                message = "No storage source found.",
                explanation = "Storage source was not initialized; cannot initialize "
                        +
                        "link discovery.",
                recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG),
        @LogMessageDoc(level = "ERROR",
                message = "Exception in LLDP send timer.",
                explanation = "An unknown error occured while sending LLDP " +
                        "messages to switches.",
                recommendation = LogMessageDoc.CHECK_SWITCH)
})
public void startUp(FloodlightModuleContext context) {
    ScheduledExecutorService ses = threadPool.getScheduledExecutor();
    controller = context.getServiceImpl(IFloodlightProviderService.class);

    discoveryTask = new SingletonTask(ses, new Runnable() {
        @Override
        public void run() {
            try {
                discoverLinks();
            } catch (Exception e) {
                log.error("Exception in LLDP send timer.", e);
            } finally {
                log.trace("Rescheduling discovery task");
                discoveryTask.reschedule(DISCOVERY_TASK_INTERVAL,
                        TimeUnit.SECONDS);
            }
        }
    });

    discoveryTask.reschedule(DISCOVERY_TASK_INTERVAL, TimeUnit.SECONDS);

    // Register for the OpenFlow messages we want to receive
    floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
    floodlightProvider.addOFMessageListener(OFType.PORT_STATUS, this);
    // Register for switch updates
    floodlightProvider.addOFSwitchListener(this);
    restApi.addRestletRoutable(new LinkDiscoveryWebRoutable());
}