Esempio n. 1
0
    def __init__(self, *args, **kwargs):
        super(SurgeMonitor, self).__init__(*args, **kwargs)
        self.switches = {}

        CONF = cfg.CONF
        CONF.register_opts([
            cfg.FloatOpt(
                'POLLING_INTERVAL',
                default=1.0,
                help='The interval at which switch statistics will be fetched'
            ),
            cfg.IntOpt(
                'TRAFFIC_THRESHOLD',
                default=196,
                help=
                'If a switch recieves traffic higher than this, it is classified as a surge'
            ),
            cfg.StrOpt(
                'LOG_PATH',
                default='/home/mininet/surge_monitor/logs/traffic_history/',
                help='Path where log files will be stored')
        ])
        self.conf = CONF

        SwitchStats.polling_interval = CONF.POLLING_INTERVAL
        SwitchStats.surge_threshold = CONF.TRAFFIC_THRESHOLD

        self.monitor_thread = hub.spawn(
            lambda: self._monitor(CONF.POLLING_INTERVAL))
Esempio n. 2
0
    def __init__(self, *args, **kwargs):
        super(PBCE, self).__init__(*args, **kwargs)

        self.CONF = cfg.CONF
        self.CONF.register_opts([
            cfg.IntOpt('lower', default=20),
            cfg.IntOpt('upper', default=30),
            cfg.FloatOpt('dc', default=0.5),
            cfg.FloatOpt('weight', default=0.5),
            cfg.FloatOpt('debounce', default=5.0),
            cfg.FloatOpt('timeout', default=10.0)])

        self.logger.info("parameters:\n"
                         " lower: %s\n"
                         " upper: %s\n"
                         " dc: %s\n"
                         " weight: %s\n"
                         " debounce: %s\n"
                         " timeout: %s",
                         self.CONF.lower,
                         self.CONF.upper,
                         self.CONF.dc,
                         self.CONF.weight,
                         self.CONF.debounce,
                         self.CONF.timeout)

        self.dpset = kwargs['dpset']
        self.topo = nx.DiGraph()
        self.host = {}

        self.evports = {}
        self.rewrite = None

        self.arp = {}
        self.debounce = {}

        self.monitor_thread = hub.spawn(self._monitor)

        self.prev_util = {}
        self.util = {}
        self.count_arrv = {}
        self.arrv = {}
    def __init__(self, *args, **kwargs):
        super(TrafficMonitor, self).__init__(*args, **kwargs)
        self.datapaths = {}
        self.switch_traffic_stats = {}
    
        CONF = cfg.CONF
        CONF.register_opts([
            cfg.FloatOpt('MAX_POLLING_INTERVAL', default=5.0, help='The interval at which switch statistics will be fetched'),
            cfg.IntOpt('TRAFFIC_THRESHOLD', default=100, help='If a switch recieves traffic higher than this, it is classified as a surge'),
        ])

        self.traffic_threshold = CONF.TRAFFIC_THRESHOLD
        self.polling_interval = CONF.MAX_POLLING_INTERVAL

        self.monitor_thread = hub.spawn(self._monitor)
Esempio n. 4
0
LOG = logging.getLogger('ryu.controller.controller')

CONF = cfg.CONF
CONF.register_cli_opts([
    cfg.StrOpt('ofp-listen-host', default='', help='openflow listen host'),
    cfg.IntOpt('ofp-tcp-listen-port',
               default=ofproto_common.OFP_TCP_PORT,
               help='openflow tcp listen port'),
    cfg.IntOpt('ofp-ssl-listen-port',
               default=ofproto_common.OFP_SSL_PORT,
               help='openflow ssl listen port'),
    cfg.StrOpt('ctl-privkey', default=None, help='controller private key'),
    cfg.StrOpt('ctl-cert', default=None, help='controller certificate'),
    cfg.StrOpt('ca-certs', default=None, help='CA certificates'),
    cfg.FloatOpt(
        'socket-timeout',
        default=5.0,
        help='Time, in seconds, to await completion of socket operations.')
])


class OpenFlowController(object):
    def __init__(self):
        super(OpenFlowController, self).__init__()

    # entry point
    def __call__(self):
        # LOG.debug('call')
        self.server_loop()

    def server_loop(self):
        if CONF.ctl_privkey is not None and CONF.ctl_cert is not None:
Esempio n. 5
0
    cfg.StrOpt('ctl-privkey', default=None, help='controller private key'),
    cfg.StrOpt('ctl-cert', default=None, help='controller certificate'),
    cfg.StrOpt('ca-certs', default=None, help='CA certificates'),
    cfg.ListOpt('ofp-switch-address-list',
                item_type=str,
                default=[],
                help='list of IP address and port pairs (default empty). '
                'e.g., "127.0.0.1:6653,[::1]:6653"'),
    cfg.IntOpt('ofp-switch-connect-interval',
               default=DEFAULT_OFP_SW_CON_INTERVAL,
               help='interval in seconds to connect to switches '
               '(default %d)' % DEFAULT_OFP_SW_CON_INTERVAL),
])
CONF.register_opts([
    cfg.FloatOpt(
        'socket-timeout',
        default=5.0,
        help='Time, in seconds, to await completion of socket operations.'),
    cfg.FloatOpt(
        'echo-request-interval',
        default=15.0,
        help='Time, in seconds, between sending echo requests to a datapath.'),
    cfg.IntOpt(
        'maximum-unreplied-echo-requests',
        default=0,
        min=0,
        help=
        'Maximum number of unreplied echo requests before datapath is disconnected.'
    )
])

Esempio n. 6
0
    cfg.IntOpt('retry-interval',
               default=DEFAULT_ZSERV_INTERVAL,
               help='Retry interval connecting to Zebra server '
               '(default: %s)' % DEFAULT_ZSERV_INTERVAL),
    cfg.StrOpt('db-url',
               default=DEFAULT_ZSERV_DATABASE,
               help='URL to database used by Zebra protocol service '
               '(default: %s)' % DEFAULT_ZSERV_DATABASE),
    cfg.StrOpt('router-id',
               default=DEFAULT_ZSERV_ROUTER_ID,
               help='Initial Router ID used by Zebra protocol service '
               '(default: %s)' % DEFAULT_ZSERV_ROUTER_ID),
    cfg.Opt(
        'frr-version',
        LooseVersion,
        default=DEFAULT_ZSERV_FRR_VERSION,
        help='FRRouting version when integrated with FRRouting (e.g., 3.0)'),
],
                       group='zapi')

CONF.register_cli_opts([
    # k_shortest_forwarding
    cfg.IntOpt('k_paths', default=4, help='number of candidate paths of KSP.'),
    cfg.StrOpt('weight',
               default='bw',
               help='weight type of computing shortest path.'),
    cfg.IntOpt('fanout', default=4, help='switch fanout number.'),
    cfg.StrOpt('dir', help='dir of countfile'),
    cfg.FloatOpt('miceIndex', help='mice index of algorithm'),
    cfg.FloatOpt('index', help='index of algorithm')
])