Exemplo n.º 1
0
    def __init__(self, *args, **kwargs):
        super(Switches, self).__init__(*args, **kwargs)

        self.name = 'switches'
        self.dps = {}                 # datapath_id => Datapath class
        self.port_state = {}          # datapath_id => ports
        self.ports = PortDataState()  # Port class -> PortData class
        self.links = LinkState()      # Link class -> timestamp
        self.is_active = True

        # by jesse : for other controller link
        self.cports = PortDataState()
        self.clinks = LinkState()

        # by jesse : for same switch port link (in_port == out_port)
        self.sports = PortDataState()
        self.slinks = LinkState()

	# by jesse : add vlan
	self.update_lldp_data_flag = False

        self.link_discovery = self.CONF.observe_links
        if self.link_discovery:
            self.install_flow = self.CONF.install_lldp_flow
            self.explicit_drop = self.CONF.explicit_drop
            self.lldp_event = hub.Event()
            self.link_event = hub.Event()
            self.threads.append(hub.spawn(self.lldp_loop))
            self.threads.append(hub.spawn(self.link_loop))
Exemplo n.º 2
0
    def __init__(self, *args, **kwargs):
        super(Generic_Agent_CHT, self).__init__(*args, **kwargs)
        global CTRL_TYPE

        hub.spawn(self.exit_detect_thread)
        CTRL_TYPE = raw_input('Please input SDN Controller Type: ')

        while True:
            try:
                # Get SYSTEM_NAME from Generic_LLDP_Module
                response = self.session.post(GENERIC_URL_BASE + '/controllers/regist/' + CTRL_TYPE)
                # if response code not 200, raise an exception
                response.raise_for_status()
                data = yaml.safe_load(response.text)
                self.SYSTEM_NAME = data['system_name']
                self.LLDP_FORMAT = data['LLDP_subtype']
                break
            except Exception as e:
                print e
                time.sleep(5)

        self.datapaths = {}
        self.links = {}
        self.mac_to_port = {}
        self.LLDP_recv_port = {}
        self.hosts = {}
        hub.spawn(self.lldp_thread)
Exemplo n.º 3
0
 def start(self):
     self.receive = True
     self.queue = hub.Queue()
     self.receive_thread = hub.spawn(self.receiver)
     self.logger.info('server: receiver thread spawned')
     self.processor_thread = hub.spawn(self.service_queue)
     self.logger.info('server: processor thread spawned')
Exemplo n.º 4
0
    def _create_bgp_speaker_for_vlan(self, vlan, bgp_speaker_key):
        """Set up BGP speaker for an individual VLAN if required.

        Args:
            vlan (valve VLAN): VLAN for BGP speaker.
        Returns:
            ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker: BGP speaker.
        """
        route_handler = lambda x: self._bgp_route_handler(x, bgp_speaker_key)
        server_address = sorted(vlan.bgp_server_addresses_by_ipv(bgp_speaker_key.ipv))[0]
        beka = Beka(
            local_address=str(server_address),
            bgp_port=vlan.bgp_port,
            local_as=vlan.bgp_as,
            router_id=vlan.bgp_routerid,
            peer_up_handler=self._bgp_up_handler,
            peer_down_handler=self._bgp_down_handler,
            route_handler=route_handler,
            error_handler=self.logger.warning)
        for ip_dst, ip_gw in self._vlan_prefixes_by_ipv(vlan, bgp_speaker_key.ipv):
            beka.add_route(prefix=str(ip_dst), next_hop=str(ip_gw))
        for bgp_neighbor_address in vlan.bgp_neighbor_addresses_by_ipv(bgp_speaker_key.ipv):
            beka.add_neighbor(
                connect_mode=vlan.bgp_connect_mode,
                peer_ip=str(bgp_neighbor_address),
                peer_as=vlan.bgp_neighbor_as)
        hub.spawn(beka.run)
        return beka
Exemplo n.º 5
0
    def __init__(self,*args,**kwargs):
        super(ForwardingBasic,self).__init__(args,kwargs)
        self.CONF.register_opts([
            cfg.StrOpt("topology",default = None,
                help = "Specified network topology",
                )
            ])
        self.topo = "fattree"
        self.topo = None
        self.name = "Forwarding-Basic"

        self.spanning_tree_done = True
        self.spanning_tree_links = set([])
        self.mac_to_port = {}
        self.mac_to_port.setdefault(0,{})

        self.install_port_events = True
        self.total_links = 0
        self.poll_port_stats = True
        self.link_rate_out_file = open("logs/link_rate.out.%s" %time.strftime("%Y%m%d_%H%M%S") ,'w')

        if self.topo is None:
            self.logger.info("No topology specified.")
        else:
            self.logger.info("Specified topology is %s" %self.topo)
            if self.topo == 'fattree':
                self.expected_links = 64
                self.fat_tree_k = 4
        spawn(self.send_port_req_loop)
Exemplo n.º 6
0
    def __init__(self, *args, **kwargs):
        super(Ryu,self).__init__(*args,**kwargs)
        #--- register for configuration options
        self.CONF.register_opts([
                cfg.StrOpt('SciPassConfig',default='/etc/SciPass/SciPass.xml',
                           help='where to find the SciPass config file'),
                ])
        
        self.logger.error("Starting SciPass")
        self.datapaths = {}
        self.isactive = 1
        self.statsInterval = 5
        self.balanceInterval = 15
        self.bal = None
        self.stats = {}
        self.stats_thread = hub.spawn(self._stats_loop)
        self.balance_thread = hub.spawn(self._balance_loop)
        
        self.ports = defaultdict(dict);
        self.prefix_bytes = defaultdict(lambda: defaultdict(int))
        self.lastStatsTime = None
        self.flowmods = {}
        
        api = SciPass(logger = self.logger,
                      config_file = self.CONF.SciPassConfig )
        
        api.registerForwardingStateChangeHandler(self.changeSwitchForwardingState)

        self.api = api
        
        wsgi = kwargs['wsgi']
        wsgi.register(SciPassRest, {'api' : self.api})
Exemplo n.º 7
0
    def _wait_bpdu_timer(self):
        time_exceed = False

        while True:
            self.wait_timer_event = hub.Event()
            message_age = (self.designated_times.message_age
                           if self.designated_times else 0)
            timer = self.port_times.max_age - message_age
            timeout = hub.Timeout(timer)
            try:
                self.wait_timer_event.wait()
            except hub.Timeout as t:
                if t is not timeout:
                    err_msg = 'Internal error. Not my timeout.'
                    raise RyuException(msg=err_msg)
                self.logger.info('[port=%d] Wait BPDU timer is exceeded.',
                                 self.ofport.port_no, extra=self.dpid_str)
                time_exceed = True
            finally:
                timeout.cancel()
                self.wait_timer_event = None

            if time_exceed:
                break

        if time_exceed:  # Bridge.recalculate_spanning_tree
            hub.spawn(self.wait_bpdu_timeout)
Exemplo n.º 8
0
    def start_sock_server(self):
        if os.path.exists(SOCKFILE):
            os.unlink(SOCKFILE)

        self.sock = hub.socket.socket(hub.socket.AF_UNIX, hub.socket.SOCK_DGRAM)
        self.sock.bind(SOCKFILE)
        hub.spawn(self.recv_loop)
Exemplo n.º 9
0
def agent_main_wrapper(bridge_classes):
    ovs_agent.main(bridge_classes)
    # The following call terminates Ryu's AppManager.run_apps(),
    # which is needed for clean shutdown of an agent process.
    # The close() call must be called in another thread, otherwise
    # it suicides and ends prematurely.
    hub.spawn(app_manager.AppManager.get_instance().close)
Exemplo n.º 10
0
    def start(self):
        # Only two main green threads are required for APGW bgp-agent.
        # One for NetworkController, another for BGPS core.

        # If configuration file was provided and loaded successfully. We start
        # BGPS core using these settings. If no configuration file is provided
        # or if configuration file is missing minimum required settings BGPS
        # core is not started.
        if self.config_file:
            LOG.debug('Loading config. from settings file.')
            settings = self.load_config(self.config_file)
            # Configure log settings, if available.
            if getattr(settings, 'LOGGING', None):
                dictConfig(settings.LOGGING)

            if getattr(settings, 'BGP', None):
                self._start_core(settings)

            if getattr(settings, 'SSH', None) is not None:
                hub.spawn(ssh.SSH_CLI_CONTROLLER.start, None, **settings.SSH)
        # Start Network Controller to server RPC peers.
        t = hub.spawn(net_ctrl.NET_CONTROLLER.start, *[],
                      **{net_ctrl.NC_RPC_BIND_IP: self.bind_ip,
                      net_ctrl.NC_RPC_BIND_PORT: self.bind_port})
        LOG.debug('Started Network Controller')

        super(RyuBGPSpeaker, self).start()

        return t
Exemplo n.º 11
0
 def __init__(self, *args, **kwargs):
     super(ProxyAccess, self).__init__(*args, **kwargs)
     self.mac_to_port = {}
     self.ip_to_mac = {}
     self.dps = []
     self.web_server_dp = None
     hub.spawn(self._redirect)
Exemplo n.º 12
0
    def start(self):
        super(RyuBGPSpeaker, self).start()

        # If configuration file was provided and loaded successfully, we start
        # BGPSpeaker using the given settings.
        # If no configuration file is provided or if any minimum required
        # setting is missing, BGPSpeaker will not be started.
        if self.config_file:
            LOG.debug('Loading config file %s...', self.config_file)
            settings = load_config(self.config_file)

            # Configure logging settings, if available.
            if hasattr(settings, 'LOGGING'):
                # Not implemented yet.
                LOG.debug('Loading LOGGING settings... (NOT implemented yet)')
                # from logging.config import dictConfig
                # logging_settings = dictConfig(settings.LOGGING)

            # Configure BGP settings, if available.
            if hasattr(settings, 'BGP'):
                LOG.debug('Loading BGP settings...')
                self._start_speaker(settings.BGP)

            # Configure SSH settings, if available.
            if hasattr(settings, 'SSH'):
                LOG.debug('Loading SSH settings...')
                hub.spawn(SSH_CLI_CONTROLLER.start, **settings.SSH)

        # Start RPC server with the given RPC settings.
        rpc_settings = {
            NC_RPC_BIND_PORT: CONF.rpc_port,
            NC_RPC_BIND_IP: validate_rpc_host(CONF.rpc_host),
        }
        return hub.spawn(NET_CONTROLLER.start, **rpc_settings)
Exemplo n.º 13
0
def main():
    try:
        CONF(project='ryu', version='ryu-manager %s' % version,
             default_config_files=['/usr/local/etc/ryu/ryu.conf'])
    except cfg.ConfigFilesNotFoundError:
        CONF(project='ryu', version='ryu-manager %s' % version)

    log.init_log()

    app_lists = CONF.app_lists + CONF.app

    app_mgr = AppManager()
    app_mgr.load_apps(app_lists)
    contexts = app_mgr.create_contexts()
    app_mgr.instantiate_apps(**contexts)

    services = []

    # TODO: do the following in app_manager's instantiate_apps()
    ofpapp = controller.start_service(app_mgr)
    if ofpapp:
        thr = hub.spawn(ofpapp)
        services.append(thr)

    webapp = wsgi.start_service(app_mgr)
    if webapp:
        thr = hub.spawn(webapp)
        services.append(thr)

    try:
        hub.joinall(services)
    finally:
        app_mgr.close()
Exemplo n.º 14
0
    def start(self):
        super(RemoteOvsdb, self).start()
        t = hub.spawn(self._run_thread, self._idl_loop)
        self.threads.append(t)

        t = hub.spawn(self._run_thread, self._event_proxy_loop)
        self.threads.append(t)
Exemplo n.º 15
0
    def _start_recv_nw_sock(self, port):

        self.nwsock = hub.socket.socket(hub.socket.AF_INET, hub.socket.SOCK_STREAM)
        self.nwsock.bind(("0.0.0.0", port))
        self.nwsock.listen(5)

        hub.spawn(self._recv_loop_nw_sock)
Exemplo n.º 16
0
 def __init__(self, *args, **kwargs):
     super(RyuController, self).__init__(*args, **kwargs)
     self.mac_to_port = {}
     self.flowstats = {}
     self.detected_flags = {}
     self.done = False
     self.byte_treshold = 500000
     self.packet_treshold = 5000
     self.detected_flags = {}
     if socket.gethostname() == 'lt-debian':
         self.gateway_port = 1
         self.map_port_mac = {
             3: '52:54:00:12:e9:0b',
             1: '52:54:00:34:0d:1f',
             65534: '32:32:7c:ac:49:42'
         }
     elif socket.gethostname() == 'OVS-Switch':
         self.gateway_port = 1
         self.map_port_mac = {
             1: '52:54:00:ee:6e:d7',
             2: '52:54:00:2d:0f:99',
             65534: '82:c8:6a:fe:33:4f'
         }
     else:
         self.gateway_port = 33
         self.map_port_mac = {
             32: '00:0c:29:a7:de:cd',
             33: '00:0a:f7:1a:a9:34',
             34: '00:1b:21:bd:dc:9d'
         }
     self.gateway_mac = haddr_to_bin(self.map_port_mac[self.gateway_port])
     self.threads.append(hub.spawn(parser.run))
     self.threads.append(hub.spawn(counter.run))
     self.threads.append(hub.spawn(self.poller))
Exemplo n.º 17
0
 def _create_dot1x_speaker(self, dot1x_intf, chewie_id, radius_ip, radius_port, radius_secret):
     chewie = Chewie(  # pylint: disable=too-many-function-args
         dot1x_intf, self.logger,
         self.auth_handler, self.failure_handler, self.logoff_handler,
         radius_ip, radius_port, radius_secret, chewie_id)
     hub.spawn(chewie.run)
     return chewie
Exemplo n.º 18
0
    def __init__(self, inception, zk_storage=False):
        # zk_storage: Decide whether to use zookeeper (True) or not (False)
        self.zk_storage = zk_storage
        self.inception = inception
        if self.zk_storage:
            # Flag indicating master/slave role
            self.master_ctl = False

            self.pos_path = "/pos"
            self.arp_path = "/arp"
            self.queue_path = "/queue"
            self.leader_path = "/election"
            self.pktin_path = "/log/packet_in"
            self.rpc_path = "/log/rpc"

            self.digest_to_pktin = {}

            zk_logger = logging.getLogger('kazoo')
            zk_log_level = log.LOG_LEVELS[CONF.zk_log_level]
            zk_logger.setLevel(zk_log_level)
            console_handler = logging.StreamHandler()
            console_handler.setLevel(zk_log_level)
            console_handler.setFormatter(logging.Formatter(CONF.log_formatter))
            zk_logger.addHandler(console_handler)
            self.zk = client.KazooClient(hosts=CONF.zk_servers,
                                         logger=zk_logger)
            self.zk.start()
            self.zk.ensure_path(self.pos_path)
            self.zk.ensure_path(self.arp_path)
            self.zk.ensure_path(self.pktin_path)
            self.zk.ensure_path(self.rpc_path)

            self.pkt_queue = self.zk.LockingQueue(self.queue_path)
            self.thread_pkt = hub.spawn(self.handle_pkt_queue)
            hub.spawn(self.run_for_leader)
    def _handle_open(self, msg):

        self.peer_as = msg.my_as
        peer_holdtime = msg.hold_time
        self.hold_time = min(peer_holdtime, self.hold_time)
        self.peer_id = msg.bgp_identifier
        self.peer_capabilities = msg.data
        for capability in self.peer_capabilities:
            if isinstance(capability, BGP4.multi_protocol_extension):
                if capability.addr_family == 1:
                    self._4or6 = 4
                elif capability.addr_family == 2:
                    self._4or6 = 6
                else:
                    self._4or6 = 0
            if isinstance(capability, BGP4.support_4_octets_as_num):
                self.peer_as = capability.as_num

        LOG.info('BGP peer info. 4/6: %s, AS %s, hold time %s, ID %s, capability %s',
                 self._4or6, self.peer_as, self.hold_time, self.peer_id,
                 self.peer_capabilities)

        self.send_open_msg()

        if self.__check_capabilities(self.peer_capabilities):
            self.peer_last_keepalive_timestamp = time.time()
            hub.spawn(self.keepalive)
            self.send_current_route_table()
        else:
            self.send_notification_msg(err_code=2, err_subcode=0, data="Capability check failed.")
Exemplo n.º 20
0
    def __init__(self, *args, **kwargs):
        super(SDNIP, self).__init__(*args, **kwargs)
        self.fwd = kwargs['fwd']
        self.hop_db = kwargs['hop_db']
        self.cfg_mgr = SDNIPConfigManager()
        self.waiters = {}
        self.bgp_speaker =\
            BGPSpeaker(self.cfg_mgr.as_number,
                       str(self.cfg_mgr.router_id),
                       bgp_server_port=self.cfg_mgr.listen_port,
                       best_path_change_handler=self.best_path_change_handler,
                       peer_down_handler=self.peer_down_handler,
                       peer_up_handler=self.peer_up_handler)

        speaker_ids = self.cfg_mgr.get_all_speaker_id()

        for speaker_id in speaker_ids:
            self.bgp_speaker.neighbor_add(speaker_id,
                                          self.cfg_mgr.as_number,
                                          is_next_hop_self=True)

        hub.spawn(self.prefix_check_loop)

        if with_dk:
            dk_plugin.DynamicLoader.register_custom_cmd('sdn-ip:info', self.cmd_self_info)
            dk_plugin.DynamicLoader.register_custom_cmd('sdn-ip:routes', self.cmd_list_routes)
            dk_plugin.DynamicLoader.register_custom_cmd('sdn-ip:flows', self.cmd_get_flows)
Exemplo n.º 21
0
 def start(self):
     self.epl.listen(9999, "127.0.0.1")
     self.icsq = self.epl.incoming_connection_status()
     self.mql = message_queue(queuename, self.epl)
     self.threads.append(hub.spawn(self._broker_loop))
     self.logger.info("Started broker communication...")
     self.threads.append(hub.spawn(self._event_loop))
Exemplo n.º 22
0
 def _meter_stats_reply_handler(self, ev):
     body = ev.msg.body
     dpid = ev.msg.datapath.id
     self.logger.info('datapath         meter_id   kbps  ')
     self.logger.info('---------------- -------- --------')
     modified_ports = []
     for stat in sorted(body, key=attrgetter('meter_id')):
         if stat.meter_id in self.time_prev[dpid]:
             sleep = float(stat.duration_sec) + (stat.duration_nsec / 10.0**9) - self.time_prev[dpid][stat.meter_id]                
             self.meter_speed[dpid][stat.meter_id] = self._get_speed(stat.byte_in_count, self.meter_prev[dpid][stat.meter_id], sleep)
         else:
             self.meter_speed[dpid][stat.meter_id] = 0
         self.time_prev[dpid][stat.meter_id] = float(stat.duration_sec) + (stat.duration_nsec / 10.0**9)
         self.meter_prev[dpid][stat.meter_id] = stat.byte_in_count
         self.logger.info("%016x %08x %6.1f",dpid, stat.meter_id, self.meter_speed[dpid][stat.meter_id])
         if stat.meter_id in self.meter_to_src[dpid]:
             src = self.meter_to_src[dpid][stat.meter_id]
             port = self.mac_to_port[dpid][src]
             self.rate_used[dpid].setdefault(port, {})
             self.rate_used_mod[dpid].setdefault(port, {})
             self.rate_used[dpid][port][src] = self.meter_speed[dpid][stat.meter_id]
             if (self.rate_used[dpid][port][src] >= int(self.rate_allocated[dpid][port][src]*0.7) 
                 and (self.rate_allocated[dpid][port][src] < self.rate_request[dpid][port][src])):
                 if int(self.rate_allocated[dpid][port][src]*1.5) < self.rate_request[dpid][port][src]:
                     self.rate_used_mod[dpid][port][src] = int(self.rate_allocated[dpid][port][src]*1.5)
                 else:
                     self.rate_used_mod[dpid][port][src] = self.rate_request[dpid][port][src]
                 if port not in modified_ports:
                     modified_ports.append(port)
             else:
                     self.rate_used_mod[dpid][port][src] = self.rate_used[dpid][port][src]
     for port in modified_ports:
         hub.spawn(self._mod_port_meters, dpid, port)
Exemplo n.º 23
0
    def __init__(self, *args, **kwargs):
        super(HLApp, self).__init__(*args, **kwargs)

        self.commandSender = CommandSender.get_instance()

        self.flow_collector = kwargs['flow_collector']

        self.network_monitor = kwargs['network_monitor']

        self.flowClassifier = FlowClassifier.get_instance()

        self.routeCalculator = RouteCalculator.get_instance()

        self.pathPreInstall = PathPreInstall()
        self.activePairSelector = ActivePairSelector()
        self.rerouter = None

        self.DISCOVER_PERIOD = 5
        self.COLLECTOR_PERIOD = 5
        self.FLOW_COUNT = 1
        self.TCP_IDLE_TIME = 10
        self.ICMP_IDLE_TIME = 60

        self.network_monitor_thread = hub.spawn(self._monitor)
        self.flow_collector_thread = hub.spawn(self._collector)
Exemplo n.º 24
0
def main():
    try:
        CONF(project='ryu', version='ryu-manager %s' % version,
             default_config_files=['/usr/local/etc/ryu/ryu.conf'])
    except cfg.ConfigFilesNotFoundError:
        CONF(project='ryu', version='ryu-manager %s' % version)

    log.init_log()

    # always enable ofp for now.
    app_lists = CONF.app_lists + CONF.app + ['ryu.controller.ofp_handler']

    app_mgr = AppManager()
    app_mgr.load_apps(app_lists)
    contexts = app_mgr.create_contexts()
    app_mgr.instantiate_apps(**contexts)

    services = []

    ctlr = controller.OpenFlowController()
    thr = hub.spawn(ctlr)
    services.append(thr)

    webapp = wsgi.start_service(app_mgr)
    if webapp:
        thr = hub.spawn(webapp)
        services.append(thr)

    try:
        hub.joinall(services)
    finally:
        app_mgr.close()
Exemplo n.º 25
0
    def __init__(self, as_number, router_id,
                 bgp_server_port=DEFAULT_BGP_SERVER_PORT,
                 refresh_stalepath_time=DEFAULT_REFRESH_STALEPATH_TIME,
                 refresh_max_eor_time=DEFAULT_REFRESH_MAX_EOR_TIME,
                 best_path_change_handler=None,
                 peer_down_handler=None,
                 peer_up_handler=None,
                 ssh_console=False,
                 label_range=DEFAULT_LABEL_RANGE):
        """Create a new BGPSpeaker object with as_number and router_id to
        listen on bgp_server_port.

        ``as_number`` specifies an Autonomous Number. It must be an integer
        between 1 and 65535.

        ``router_id`` specifies BGP router identifier. It must be the
        string representation of an IPv4 address (e.g. 10.0.0.1).

        ``bgp_server_port`` specifies TCP listen port number. 179 is
        used if not specified.

        ``refresh_stalepath_time`` causes the BGP speaker to remove
        stale routes from the BGP table after the timer expires, even
        if the speaker does not receive a Router-Refresh End-of-RIB
        message. This feature is disabled (not implemented yet).

        ``refresh_max_eor_time`` causes the BGP speaker to generate a
        Route-Refresh End-of-RIB message if it was not able to
        generate one due to route flapping. This feature is disabled
        (not implemented yet).

        ``best_path_change_handler``, if specified, is called when any
        best remote path is changed due to an update message or remote
        peer down. The handler is supposed to take one argument, the
        instance of an EventPrefix class instance.

        ``peer_down_handler``, if specified, is called when BGP peering
        session goes down.

        ``peer_up_handler``, if specified, is called when BGP peering
        session goes up.

        """
        super(BGPSpeaker, self).__init__()

        settings = {}
        settings[LOCAL_AS] = as_number
        settings[ROUTER_ID] = router_id
        settings[BGP_SERVER_PORT] = bgp_server_port
        settings[REFRESH_STALEPATH_TIME] = refresh_stalepath_time
        settings[REFRESH_MAX_EOR_TIME] = refresh_max_eor_time
        settings[LABEL_RANGE] = label_range
        self._core_start(settings)
        self._init_signal_listeners()
        self._best_path_change_handler = best_path_change_handler
        self._peer_down_handler = peer_down_handler
        self._peer_up_handler = peer_up_handler
        if ssh_console:
            hub.spawn(ssh.SSH_CLI_CONTROLLER.start)
Exemplo n.º 26
0
 def __init__(self, *args, **kwargs):
     super(RpcVRRPManager, self).__init__(*args, **kwargs)
     self._args = args
     self._kwargs = kwargs
     self._peers = []
     self._rpc_events = hub.Queue(128)
     self.server_thread = hub.spawn(self._peer_accept_thread)
     self.event_thread = hub.spawn(self._rpc_request_loop_thread)
Exemplo n.º 27
0
 def datapath_handler(self, ev):
     # Target switch datapath
     self.dp = ev.dp
     version = self.dp.ofproto.OFP_VERSION
     if version not in self._OFCTL:
         raise OFPUnknownVersion(version=version)
     self.ofctl = self._OFCTL[version]
     hub.spawn(self._do_test)
Exemplo n.º 28
0
 def peer_accept_handler(self, new_sock, addr):
     peer = Peer(self._rpc_events)
     table = {
         rpc.MessageType.REQUEST: peer._handle_vrrp_request,
     }
     peer._endpoint = rpc.EndPoint(new_sock, disp_table=table)
     self._peers.append(peer)
     hub.spawn(self._peer_loop_thread, peer)
Exemplo n.º 29
0
 def start(self, is_active, peer_addr, conn_handle):
     if is_active:
         with Timeout(DEFAULT_CONN_TIMEOUT, socket.error):
             self._socket.connect(peer_addr)
         hub.spawn(conn_handle, self._socket, True)
     else:
         self._socket.listen(50)
         hub.spawn(self._listen_loop, conn_handle)
Exemplo n.º 30
0
 def conn_handle(self, socket, is_active):
     if is_active:
         self._state_map = self._ACTIVE_STATE_MAP
     else:
         self._state_map = self._PASSIVE_STATE_MAP
     self._socket = socket
     self.state_change(ldp_event.LDP_STATE_INITIAL)
     hub.spawn(self._recv_loop)
Exemplo n.º 31
0
    def _deactivate_subscriber_rules(self):
        def deactivate_flows():
            self._ec.deactivate_rules(imsi=self.cfg.imsi, rule_ids=None)

        hub.joinall([hub.spawn(deactivate_flows)])
Exemplo n.º 32
0
 def __init__(self, *args, **kwargs):
     super(SimpleSwitch13, self).__init__(*args, **kwargs)
     self.mac_to_port = {}
     self.datapaths = {}
     self.monitor_thread = hub.spawn(self._monitor)
Exemplo n.º 33
0
    def start(self):
        super(BMPStation, self).start()

        return hub.spawn(
            StreamServer((SERVER_HOST, SERVER_PORT), self.loop).serve_forever)
Exemplo n.º 34
0
 def start(self, ryudp):
     self.ryudp = ryudp
     self.stop()
     self.thread = hub.spawn(self)
Exemplo n.º 35
0
from operator import attrgetter
Exemplo n.º 36
0
 def start(self):
     """
     Hook that is called after startup initialization is done.
     """
     self.threads.append(hub.spawn(self._event_loop))
Exemplo n.º 37
0
 def __init__(self, *args, **kwargs):
     super(SamplerSwitch, self).__init__(*args, **kwargs)
     self.datapaths = {}
     self.monitor_thread = hub.spawn(self._monitor) #hub that will query switches
 def __init__(self, *args, **kwargs):
     super(SimpleMonitor, self).__init__(*args, **kwargs)
     self.datapaths = {}
     self.monitor_thread = hub.spawn(self._monitor)
Exemplo n.º 39
0
 def _enable_router(self):
     if self._arp_thread is None:
         self._arp_thread = hub.spawn(self._arp_loop)
     # TODO: implement real routing logic
     self.logger.debug('TODO:_enable_router')
Exemplo n.º 40
0
 def start(self):
     self.stop()
     self.thread = hub.spawn(self)
Exemplo n.º 41
0
 def start(self):
     super(NIB,self).start()
     self.logger.debug("start here ing")
     self.threads.append(hub.spawn(self.queue_stats_request))
    def __init__(self, *args, **kwargs):
        super(PortStatsReporter, self).__init__(*args, **kwargs)
        self.datapaths = {}

        self.monitor_thread = hub.spawn(self._monitor)
        self.monitoring_time = 5
Exemplo n.º 43
0
    def __init__(self, *args, **kwargs):
        super(Controller, self).__init__(*args, **kwargs)

        conf = DictionaryConfiguration()

        # configurations for the system
        # arp table for different tenants
        self.arp_table = {  # {tenant_id ->{ip -> mac}}
            1: {
                # d1
                '191.168.1.1': '00:00:00:00:00:01',
                '191.168.1.4': '00:00:00:00:00:04',
                '191.168.1.6': '00:00:00:00:00:06',
                '191.168.111.1': '10:00:00:00:00:00',
                # d2
                '191.168.2.1': '00:00:00:00:00:21',
            },
            2: {
                # d1
                '191.168.1.3': '00:00:00:00:00:03',
                '191.168.1.2': '00:00:00:00:00:02',
                '191.168.1.5': '00:00:00:00:00:05',
                '191.168.1.7': '00:00:00:00:00:07',
                # d2
                '191.168.2.2': '00:00:00:00:00:22'
            }
        }

        # pmac -> tenant_id
        self.host_pmac = {
            '00:00:00:00:00:01': 1,
            '00:00:00:00:00:02': 2,
            '00:00:00:00:00:03': 2,
            '00:00:00:00:00:04': 1,
            '00:00:00:00:00:05': 2,
            '00:00:00:00:00:06': 1,
            '10:00:00:00:00:00': 1,
            '00:00:00:00:00:21': 1,
            '00:00:00:00:00:07': 2,
            '00:00:00:00:00:22': 2
        }

        # tenant_id -> tenant_level
        self.tenant_level = {1: 2, 2: 1}

        # record all potential subnet
        self.subnets = ['191.0.0.0/8', '192.0.0.0/8', '10.0.0.0/8']

        # record all potential gateway
        # 'NAT' : port_no
        # datacenter_id : port_no
        self.potential_gateway = {
            10: {
                2: 6
            },
            11: {
                2: 6
            },
            12: {
                2: 6
            },
            13: {
                1: 5
            },
            14: {
                1: 5
            },
            15: {
                1: 5
            }
        }

        # remote datacenter_id -> {dpid -> peer}
        # if there is no peer, then peer is -1
        self.gateways_datacenter_port = {2: {10: -1, 11: 12, 12: 11}}

        # record all potential gateway_ip
        # datacenter_id -> [gateway_ip]
        self.gateway_ip = ['191.0.0.1']

        # record speed for tenant
        # tenant_id -> speed
        self.tenant_speed = {
            # 1: 1024 * 1,
            # 2: 1024 * 1
        }

        # record all datacenter_id
        self.all_datacenter_id = [1, 2]

        # record for system
        # data in controller
        self.vmac_to_pmac = {  # {vmac -> vmac}
        }
        self.pmac_to_vmac = {  # {pmac -> vmac}
        }
        self.dpid_to_vmac = {}  # {dpid -> vmac}
        self.datapathes = {}  # {dpid -> datapath}
        self.dpid_to_ports = {}  # {dpid -> ports}
        self.dpid_to_dpid = {}  # {(dpid, port_id) -> dpid}
        self.switch_topo = nx.Graph()  # switch topo
        self.port_speed = {
        }  # {dpid -> {remote_dpid -> 'max_speed' - 'cur_speed'}}
        self.meters = {}  # {dpid -> {meter_id -> band_id}}
        self.gateways = {}  # {dpid -> {port_no -> datacenter_id}}
        self.gateway_vmac = {}  # {dpid -> vmac}
        self.host_queue = {}  # gateway_id -> queue for host
        self.switch_gateway_connection = {
        }  # (switch_id, gateway_id) -> (switch_port, gateway_port)
        self.host_gateway = {}  # {vmac -> gateway_id}

        # components
        self.flow_manager = FlowManager(datapathes=self.datapathes,
                                        gateways=self.gateways)
        self.lldp_manager = LLDPListener(
            datapathes=self.datapathes,
            dpid_potrs=self.dpid_to_ports,
            dpid_to_dpid=self.dpid_to_dpid,
            topo=self.switch_topo,
            DEFAULT_TTL=self.DEFAULT_TTL,
            port_speed=self.port_speed,
            potential_gateways=self.potential_gateway)
        self.swtich_manager = SwitchManager(
            datapathes=self.datapathes,
            dpid_to_ports=self.dpid_to_ports,
            dpid_to_vmac=self.dpid_to_vmac,
            lldp_manager=self.lldp_manager,
            meters=self.meters,
            subnets=self.subnets,
            potential_gateway=self.potential_gateway)
        self.arp_manager = ArpManager(
            arp_table=self.arp_table,
            pmac_to_vmac=self.pmac_to_vmac,
            gateway_ip=self.gateway_ip,
            gateways=self.gateways,
            dpid_to_vmac=self.dpid_to_vmac,
            switch_gateway_connection=self.switch_gateway_connection,
            datapathes=self.datapathes,
            host_gateway=self.host_gateway)
        self.mac_manager = MacManager(tenant_level=self.tenant_level)
        self.meter_manager = MeterModifier(meters=self.meters)
        self.host_manager = HostManager(host_pmac=self.host_pmac,
                                        mac_manager=self.mac_manager,
                                        pmac_to_vmac=self.pmac_to_vmac,
                                        vmac_to_pmac=self.vmac_to_pmac,
                                        tenant_speed=self.tenant_speed,
                                        meter_manager=self.meter_manager)
        self.topo_manager = TopoManager(topo=self.switch_topo,
                                        dpid_to_dpid=self.dpid_to_dpid)
        self.gateway_manager = GatewayManager(
            gateways=self.gateways,
            potential_gateway=self.potential_gateway,
            gateway_flow_table_inquire_time=self.GATEWAY_FLOW_INQUIRY_TIME,
            datapathes=self.datapathes,
            gateway_port_inquire_time=self.GATEWAY_PORT_INQUIRY_TIME,
            gateway_datacenter_port_max_speed=self.DEFAULT_GG_BW,
            balance_time_interval=self.GATEWAY_BALANCE_TIME,
            all_datacenter_id=self.all_datacenter_id,
            topo_manager=self.topo_manager,
            meter_manager=self.meter_manager)

        # hub
        self.init_hub = hub.spawn(self.init_controller)
        self.gateway_statistics_inquiry_hub = hub.spawn(
            self.gateway_manager.inquiry_gateway_flow_table_info)
        self.gateways_datacenter_port_hub = hub.spawn(
            self.gateway_manager.inquiry_gateway_datacenter_port)
        # self.gateway_banlance_hub = hub.spawn(self.gateway_manager.gateway_balance_hub)
        self.gateway_init_record_hub = hub.spawn(
            self.gateway_manager.init_gateway_record)
Exemplo n.º 44
0
 def _websocket_handler(self, ws):
     rpc_client = WebSocketRPCClient(ws)
     self.app.rpc_clients.append(rpc_client)
     # init_client requires a running event loop
     spawn(self.app.init_client, rpc_client)
     rpc_client.serve_forever()
Exemplo n.º 45
0
    def __init__(self, *args, **kwargs):
        super(ProjectCCMP, self).__init__(*args, **kwargs)
        self.mac_to_port = {}
        self.topology_api_app = self
        self.datapath_list = {}
        self.arp_table = {}
        self.switches = []
        self.hosts = {}
        self.multipath_group_ids = {}
        self.group_ids = []
        self.adjacency = defaultdict(
            dict
        )  #self.adjacency[s1.dpid][s2.dpid] = s1.port_no        self.adjacency[s2.dpid][s1.dpid] = s2.port_no
        self.bandwidths = defaultdict(lambda: defaultdict(lambda: DEFAULT_BW))
        self.paths = defaultdict(list)

        self.host_ip = {
            (13, 19): ["10.0.0.1", "10.0.0.7"],
            (13, 20): ["10.0.0.1", "10.0.0.8"],
            (13, 21): ["10.0.0.1", "10.0.0.9"],
            (13, 22): ["10.0.0.1", "10.0.0.10"],
            (13, 23): ["10.0.0.1", "10.0.0.11"],
            (13, 24): ["10.0.0.1", "10.0.0.12"],
            (14, 19): ["10.0.0.2", "10.0.0.7"],
            (14, 20): ["10.0.0.2", "10.0.0.8"],
            (14, 21): ["10.0.0.2", "10.0.0.9"],
            (14, 22): ["10.0.0.2", "10.0.0.10"],
            (14, 23): ["10.0.0.2", "10.0.0.11"],
            (14, 24): ["10.0.0.2", "10.0.0.12"],
            (15, 19): ["10.0.0.3", "10.0.0.7"],
            (15, 20): ["10.0.0.3", "10.0.0.8"],
            (15, 21): ["10.0.0.3", "10.0.0.9"],
            (15, 22): ["10.0.0.3", "10.0.0.10"],
            (15, 23): ["10.0.0.3", "10.0.0.11"],
            (15, 24): ["10.0.0.3", "10.0.0.12"],
            (16, 19): ["10.0.0.4", "10.0.0.7"],
            (16, 20): ["10.0.0.4", "10.0.0.8"],
            (16, 21): ["10.0.0.4", "10.0.0.9"],
            (16, 22): ["10.0.0.4", "10.0.0.10"],
            (16, 23): ["10.0.0.4", "10.0.0.11"],
            (16, 24): ["10.0.0.4", "10.0.0.12"],
            (17, 19): ["10.0.0.5", "10.0.0.7"],
            (17, 20): ["10.0.0.5", "10.0.0.8"],
            (17, 21): ["10.0.0.5", "10.0.0.9"],
            (17, 22): ["10.0.0.5", "10.0.0.10"],
            (17, 23): ["10.0.0.5", "10.0.0.11"],
            (17, 24): ["10.0.0.5", "10.0.0.12"],
            (18, 19): ["10.0.0.6", "10.0.0.7"],
            (18, 20): ["10.0.0.6", "10.0.0.8"],
            (18, 21): ["10.0.0.6", "10.0.0.9"],
            (18, 22): ["10.0.0.6", "10.0.0.10"],
            (18, 23): ["10.0.0.6", "10.0.0.11"],
            (18, 24): ["10.0.0.6", "10.0.0.12"]
        }

        self.host_port = {
            (13, 19): [5, 5],
            (13, 20): [5, 6],
            (13, 21): [5, 5],
            (13, 22): [5, 5],
            (13, 23): [5, 6],
            (13, 24): [5, 5],
            (14, 19): [5, 5],
            (14, 20): [5, 6],
            (14, 21): [5, 5],
            (14, 22): [5, 5],
            (14, 23): [5, 6],
            (14, 24): [5, 5],
            (15, 19): [6, 5],
            (15, 20): [6, 6],
            (15, 21): [6, 5],
            (15, 22): [6, 5],
            (15, 23): [6, 6],
            (15, 24): [6, 5],
            (16, 19): [5, 5],
            (16, 20): [5, 6],
            (16, 21): [5, 5],
            (16, 22): [5, 5],
            (16, 23): [5, 6],
            (16, 24): [5, 5],
            (17, 19): [5, 5],
            (17, 20): [5, 6],
            (17, 21): [5, 5],
            (17, 22): [5, 5],
            (17, 23): [5, 6],
            (17, 24): [5, 5],
            (18, 19): [5, 5],
            (18, 20): [5, 6],
            (18, 21): [5, 5],
            (18, 22): [5, 5],
            (18, 23): [5, 6],
            (18, 24): [5, 5]
        }

        #h1-eth0<->s13-eth5 (OK OK)
        #h2-eth0<->s14-eth5 (OK OK)
        #h3-eth0<->s15-eth6 (OK OK)
        #h4-eth0<->s16-eth5 (OK OK)
        #h5-eth0<->s17-eth5 (OK OK)
        #h6-eth0<->s18-eth5 (OK OK)

        #h7-eth0<->s19-eth5 (OK OK)
        #h8-eth0<->s20-eth6 (OK OK)
        #h9-eth0<->s21-eth5 (OK OK)
        #h10-eth0<->s22-eth5 (OK OK)
        #h11-eth0<->s23-eth6 (OK OK)
        #h12-eth0<->s24-eth5 (OK OK)

        self.count = 0
        self.isInstallFlows = False
        self.isReInstallFlows = False

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