Java 类net.floodlightcontroller.core.util.SingletonTask 实例源码

项目：fresco_floodlight 文件：RPCService.java

/**
 * 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);
}

项目：fresco_floodlight 文件：FlowReconcileManager.java

@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);
}

项目：fresco_floodlight 文件：TopologyManager.java

@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();
}

项目：iTAP-controller 文件：RPCService.java

/**
 * 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);
}

项目：iTAP-controller 文件：FlowReconcileManager.java

@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);
}

项目：iTAP-controller 文件：TopologyManager.java

@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();
}

项目：SDN-Multicast 文件：RPCService.java

/**
 * 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);
}

项目：SDN-Multicast 文件：FlowReconcileManager.java

@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);
}

项目：SDN-Multicast 文件：TopologyManager.java

@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();
}

项目：arscheduler 文件：RPCService.java

/**
 * 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);
}

项目：arscheduler 文件：FlowReconcileManager.java

@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);
}

项目：arscheduler 文件：TopologyManager.java

@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();
}

项目：QoS-floodlight 文件：RPCService.java

/**
 * 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);
}

项目：QoS-floodlight 文件：TopologyManager.java

@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();
}

项目：floodlight1.2-delay 文件：RPCService.java

/**
 * 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);
}

项目：floodlight1.2-delay 文件：FlowReconcileManager.java

@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);
}

项目：floodlight1.2-delay 文件：TopologyManager.java

@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();
}

项目：floodlight-hardware 文件：RPCService.java

/**
 * 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);
}

项目：floodlight-hardware 文件：FlowReconcileManager.java

@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);
}

项目：floodlight-hardware 文件：TopologyManager.java

@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();
}

项目：ACAMPController 文件：RPCService.java

/**
 * 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);
}

项目：ACAMPController 文件：FlowReconcileManager.java

@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);
}

项目：ACAMPController 文件：TopologyManager.java

@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();
}

项目：fast-failover-demo 文件：RPCService.java

/**
 * 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);
}

项目：fast-failover-demo 文件：FlowReconcileManager.java

@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);
}

项目：fast-failover-demo 文件：TopologyManager.java

@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();
}

项目：floodlightLB 文件：RPCService.java

/**
 * 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);
}

项目：floodlightLB 文件：FlowReconcileManager.java

@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);
}

项目：floodlightLB 文件：TopologyManager.java

@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();
}

项目：DSC 文件：RPCService.java

/**
 * 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);
}

项目：DSC 文件：FlowReconcileManager.java

@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);
}

项目：DSC 文件：TopologyManager.java

@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();
}

项目：floodlight_with_topoguard 文件：RPCService.java

/**
 * 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);
}

项目：floodlight_with_topoguard 文件：TopologyManager.java

@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();
}

项目：floodlight 文件：RPCService.java

/**
 * 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);
}

项目：floodlight 文件：FlowReconcileManager.java

@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);
}

项目：floodlight 文件：TopologyManager.java

@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();
}

项目：FloodligtModule 文件：RPCService.java

/**
 * 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);
}

项目：FloodligtModule 文件：TopologyManager.java

@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();
}

项目：multicastSDN 文件：RPCService.java

/**
 * 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);
}