def __init__(self, *_args, **_kwargs): super(RyuApp, self).__init__() self.name = self.__class__.__name__ self.event_handlers = {} # ev_cls -> handlers:list self.observers = {} # ev_cls -> observer-name -> states:set self.threads = [] self.events = hub.Queue(128) self.replies = hub.Queue() self.logger = logging.getLogger(self.name) self.threads.append(hub.spawn(self._event_loop))
def __init__(self, socket): super(Client, self).__init__() self.send_queue = hub.Queue(32) #controller and server send message self.status = True self.server = None # connect to server self.socket = socket self.client_id = 0
def __init__(self, *args, **kwargs): super(SimpleRouter, self).__init__(*args, **kwargs) self.ping_q = hub.Queue() self.portInfo = {} self.arpInfo = {} self.routingInfo = {} self.mplsInfo = {} self.mac_to_port = dict() self.ipToMac = dict() self.ports_to_ips = [ ('10.0.0.8', '255.255.255.0', '00:00:00:00:00:50'), ('10.0.1.1', '255.255.255.0', '00:00:00:00:00:60'), ('10.0.2.1', '255.255.255.0', '00:00:00:00:00:70'), ('10.0.3.1', '255.255.255.0', '00:00:00:00:00:80') ] self.tablaEnrutamiento = [('10.0.0.0', '255.255.255.0', 1, None), ('10.0.1.0', '255.255.255.0', 2, None), ('10.0.2.0', '255.255.255.0', 3, None), ('10.0.3.0', '255.255.255.0', 4, None)] self.dict_pendientes = dict()
def __init__(self, *args, **kwargs): super(SimpleRouter, self).__init__(*args, **kwargs) self.ping_q = hub.Queue() self.portInfo = {} self.arpInfo = {} self.routingInfo = {} self.mplsInfo = {}
def test_ocs_failure(self): """ Test that when the OCS fails to respond to an update request, the service is cut off until the update can be completed """ sub1 = SubContextConfig('IMSI001010000088888', '192.168.128.74', default_ambr_config, 4) quota = 1024 self.test_util.controller.mock_create_session = Mock( return_value=session_manager_pb2.CreateSessionResponse( credits=[create_update_response(sub1.imsi, 1, quota)], static_rules=[session_manager_pb2.StaticRuleInstall( rule_id="simple_match" )], ), ) update_complete = hub.Queue() self.test_util.controller.mock_update_session = Mock( side_effect=get_standard_update_response( update_complete, None, quota, success=False), ) self.test_util.controller.mock_terminate_session = Mock( return_value=session_manager_pb2.SessionTerminateResponse(), ) self.test_util.sessiond.CreateSession( session_manager_pb2.LocalCreateSessionRequest( sid=SubscriberID(id=sub1.imsi), ue_ipv4=sub1.ip, ), ) self.assertEqual(self.test_util.controller.mock_create_session.call_count, 1) packets = get_packets_for_flows( sub1, self.test_util.static_rules["simple_match"].flow_list) packet_count = int(quota / len(packets[0])) + 1 sender = self.test_util.get_packet_sender([sub1], packets, packet_count) # assert after session init, data can flow self.assertGreater(self.test_util.thread.run_in_greenthread(sender), 0) # wait for failed update self.assertIsNotNone(get_from_queue(update_complete)) hub.sleep(2) # assert that no data can be sent anymore self.assertEqual(self.test_util.thread.run_in_greenthread(sender), 0) self.test_util.controller.mock_update_session = Mock( side_effect=get_standard_update_response( update_complete, None, quota, success=True), ) # wait for second update cycle to reactivate hub.sleep(4) self.assertGreater(self.test_util.thread.run_in_greenthread(sender), 0) self.test_util.sessiond.EndSession(SubscriberID(id=sub1.imsi)) self.assertEqual(self.test_util.controller.mock_terminate_session.call_count, 1)
def __init__(self, *_args, **_kwargs): super(RyuApp, self).__init__() self.name = self.__class__.__name__ self.event_handlers = {} # ev_cls -> handlers:list self.observers = {} # ev_cls -> observer-name -> states:set self.threads = [] self.main_thread = None self.events = hub.Queue(128) self._events_sem = hub.BoundedSemaphore(self.events.maxsize) if hasattr(self.__class__, 'LOGGER_NAME'): self.logger = logging.getLogger(self.__class__.LOGGER_NAME) else: self.logger = logging.getLogger(self.name) self.CONF = cfg.CONF #modify by hmily if self.CONF.enable_debugger: self.logger.setLevel(logging.DEBUG) self.logger.debug("[debug]--ryuApp init") # prevent accidental creation of instances of this class outside RyuApp class _EventThreadStop(event.EventBase): pass self._event_stop = _EventThreadStop() self.is_active = True
def __init__(self, soc, data, app): self.soc = soc self.app = app self.que = hub.Queue() # (mtype, data, xid) self.hello = fibcapi.parse_ff_hello(data) self.dpath = fibcryu.FFDatapath(self.que, self.get_id()) self.ports = list()
def __init__(self, *args, **kwargs): super(ZClient, self).__init__(*args, **kwargs) self.zserv = None # ZServer instance self.zserv_addr = (CONF.server_host, CONF.server_port) self.zserv_ver = CONF.server_version self.send_q = hub.Queue(16) self.route_type = get_zebra_route_type_by_name(CONF.client_route_type)
def __init__(self, ws): self.ws = ws self.queue = hub.Queue() super(WebSocketRPCClient, self).__init__( JSONRPCProtocol(), WebSocketClientTransport(ws, self.queue), )
def __init__(self, *args, **kwargs): super(VRRPManager, self).__init__(*args, **kwargs) self._args = args self._kwargs = kwargs self.name = vrrp_event.VRRP_MANAGER_NAME self._instances = {} # name -> VRRPInstance self.shutdown = hub.Queue()
def __init__(self, dp, s): super(Switch, self).__init__(dp) self.name = None # switches[dpid] = Switch # reference to routing.py self.switches = s # neigbors[Switch] = port_no self.neighbors = {} # ports[port_no] = Port # overshadow super.ports self.ports = {} # ARP table # ip_to_mac[ip_addr] = (mac_addr, time_stamp) self.ip_to_mac = {} # temporarily store packets without ARP entry self.msg_buffer = [] self.queue = hub.Queue() self.tbl = RoutingTable(self.dp.id) self.init_thread()
def __init__(self, *_args, **_kwargs): super(RyuApp, self).__init__() # 其name 即为类的名字 self.name = self.__class__.__name__ # 事件 与 句柄列表 的字典 self.event_handlers = {} # ev_cls -> handlers:list self.observers = {} # ev_cls -> observer-name -> states:set # 线程列表 self.threads = [] self.main_thread = None # hub.Queue 并发队列,其最大数量为128 # 存放 事件及状态 self.events = hub.Queue(128) # 声明有限信号量,其最大个数与hub.Queue.maxsize相同,即128 self._events_sem = hub.BoundedSemaphore(self.events.maxsize) # 判断是否含有LOGGER_NAME 属性,self.__class__即指向该类 if hasattr(self.__class__, 'LOGGER_NAME'): self.logger = logging.getLogger(self.__class__.LOGGER_NAME) else: self.logger = logging.getLogger(self.name) self.CONF = cfg.CONF # prevent accidental creation of instances of this class outside RyuApp # 防止在RyuApp之外意外创建此类的实例 class _EventThreadStop(event.EventBase): pass self._event_stop = _EventThreadStop() # 标识 self.is_active = True
def __init__(self, *args, **kwargs): super(SimpleBGPSpeaker, self).__init__(*args, **kwargs) self.bgp_q = hub.Queue() self.name = 'bgps' self.bgpPeerStatus = {} self.target_route_dist = None self.bgp_thread = hub.spawn(self.monitor_target_remotePrefix)
def __init__(self, *_args, **_kwargs): super(RyuApp, self).__init__() self.name = self.__class__.__name__ self.event_handlers = {} # ev_cls -> handlers:list self.observers = {} # ev_cls -> observer-name -> states:set self.threads = [] self.events = hub.Queue(128) self.replies = hub.Queue() self.logger = logging.getLogger(self.name) # prevent accidental creation of instances of this class outside RyuApp class _EventThreadStop(event.EventBase): pass self._event_stop = _EventThreadStop() self.is_active = True
def __init__(self, socket, address): super(Datapath, self).__init__() self.socket = socket # TCP_NODELAY 不使用Nagle算法 self.socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) # 设置阻塞时间 self.socket.settimeout(CONF.socket_timeout) self.address = address self.is_active = True # The limit is arbitrary. We need to limit queue size to # prevent it from eating memory up. # 限制是任意的。 # 我们需要限制队列大小以防止它占用内存。 self.send_q = hub.Queue(16) # 有限信号量 self._send_q_sem = hub.BoundedSemaphore(self.send_q.maxsize) self.echo_request_interval = CONF.echo_request_interval self.max_unreplied_echo_requests = CONF.maximum_unreplied_echo_requests self.unreplied_echo_requests = [] self.xid = random.randint(0, self.ofproto.MAX_XID) self.id = None # datapath_id is unknown yet self._ports = None self.flow_format = ofproto_v1_0.NXFF_OPENFLOW10 self.ofp_brick = ryu.base.app_manager.lookup_service_brick('ofp_event') # 状态标识 self.state = None # for pylint self.set_state(HANDSHAKE_DISPATCHER)
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')
def test_basic_init(self): """ Initiate subscriber, return 1 static policy with monitoring key, send traffic to match the policy, verify monitoring update is sent, terminate subscriber """ sub1 = SubContextConfig('IMSI001010000088888', '192.168.128.74', default_ambr_config, 4) quota = 1024 # bytes self.test_util.controller.mock_create_session = Mock( return_value=session_manager_pb2.CreateSessionResponse( credits=[], static_rules=[ session_manager_pb2.StaticRuleInstall( rule_id="monitor_rule", ), ], dynamic_rules=[], usage_monitors=[ create_monitor_response( sub1.imsi, "mkey1", quota, session_manager_pb2.PCC_RULE_LEVEL, ), ], ), ) self.test_util.controller.mock_terminate_session = Mock( return_value=session_manager_pb2.SessionTerminateResponse(), ) monitor_complete = hub.Queue() self.test_util.controller.mock_update_session = Mock( side_effect=get_standard_update_response( None, monitor_complete, quota, ), ) self.test_util.sessiond.CreateSession( session_manager_pb2.LocalCreateSessionRequest( sid=SubscriberID(id=sub1.imsi), ue_ipv4=sub1.ip, ), ) self.assertEqual(self.test_util.controller.mock_create_session.call_count, 1) packets = get_packets_for_flows( sub1, self.test_util.static_rules["monitor_rule"].flow_list, ) packet_count = int(quota / len(packets[0])) + 1 self.test_util.thread.run_in_greenthread( self.test_util.get_packet_sender([sub1], packets, packet_count), ) self.assertIsNotNone(get_from_queue(monitor_complete)) self.assertEqual(self.test_util.controller.mock_update_session.call_count, 1) self.test_util.sessiond.EndSession(SubscriberID(id=sub1.imsi)) self.assertEqual(self.test_util.controller.mock_terminate_session.call_count, 1)
def __init__(self, socket, address): super(GlobalAgent, self).__init__() self.socket = socket self.address = address self.send_q = hub.Queue(32) self.is_active = True self.global_ctrn = None self.agent_id = -1
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)
def __init__(self, socket, address): super(Datapath, self).__init__() self.socket = socket self.socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) self.address = address self.is_active = True # The limit is arbitrary. We need to limit queue size to # prevent it from eating memory up self.send_q = hub.Queue(16) self.xid = random.randint(0, self.ofproto.MAX_XID) self.id = None # datapath_id is unknown yet self.ports = None self.flow_format = ofproto_v1_0.NXFF_OPENFLOW10 self.ofp_brick = ryu.base.app_manager.lookup_service_brick('ofp_event') self.set_state(handler.HANDSHAKE_DISPATCHER) # -------------------------- Fujitsu code start ----------------------------- # For optical enhancing # make msgtype dictionary self.msgtype_dict = {} msgtype_list = { "OFPT_HELLO", "OFPT_ERROR", "OFPT_ECHO_REQUEST", "OFPT_ECHO_REPLY", "OFPT_EXPERIMENTER", "OFPT_FEATURES_REQUEST", "OFPT_FEATURES_REPLY", "OFPT_GET_CONFIG_REQUEST", "OFPT_GET_CONFIG_REPLY", "OFPT_SET_CONFIG", "OFPT_PACKET_IN", "OFPT_FLOW_REMOVED", "OFPT_PORT_STATUS", "OFPT_PACKET_OUT", "OFPT_FLOW_MOD", "OFPT_GROUP_MOD", "OFPT_PORT_MOD", "OFPT_TABLE_MOD", "OFPT_MULTIPART_REQUEST", "OFPT_MULTIPART_REPLY", "OFPT_BARRIER_REQUEST", "OFPT_BARRIER_REPLY", "OFPT_QUEUE_GET_CONFIG_REQUEST", "OFPT_QUEUE_GET_CONFIG_REPLY", "OFPT_ROLE_REQUEST", "OFPT_ROLE_REPLY", "OFPT_GET_ASYNC_REQUEST", "OFPT_GET_ASYNC_REPLY", "OFPT_SET_ASYNC", "OFPT_METER_MOD" } for msgtype in msgtype_list: if hasattr(self.ofproto, msgtype): self.msgtype_dict[getattr(self.ofproto, msgtype)] = msgtype
def __init__(self, *args, **kwargs): super(Controller, self).__init__(*args, **kwargs) self.topo = {} self.status = False self.client_id = 1 self.send_queue = hub.Queue(16) self.socket = socket.socket() self.start_serve('127.0.0.1', 8888) self.time = 0
def __init__(self, id, matches, old_rule, new_rule, src_vnf, dst_vnf): from ryu.lib import hub self.id = id self.matches = matches self.fast_matches = to_ingress_egress(map(Match.from_ofp_match, [matches['ingress'], matches['egress']])) self.old_rule = old_rule self.new_rule = new_rule self.src_vnf = src_vnf self.dst_vnf = dst_vnf # ingress: [src, dst], egress: [src, dst] self.states = to_ingress_egress([[self.STATE_WAITING_FOR_START_PKT, self.STATE_WAITING_FOR_START_PKT], [self.STATE_WAITING_FOR_START_PKT, self.STATE_WAITING_FOR_START_PKT]]) self.repeat_timers = to_ingress_egress([[None, None], [None, None]]) self.queues = to_ingress_egress([hub.Queue(), hub.Queue()]) self.state_lock = Lock() self.pending_delete = False self.statistics = HandoverStatistics()
def get_table_stats(test_controller): """ Send an ovs request to retrieve all table stats, wait on queue """ queue = hub.Queue() def request_table_stats(): test_controller.table_stats_lookup(queue) hub.joinall([hub.spawn(request_table_stats)]) return queue.get(block=True)
def __init__(self, *args, **kwargs): super(RpcVRRPManager, self).__init__(*args, **kwargs) self.CONF.register_opts([ cfg.IntOpt('vrrp-rpc-port', default=VRRP_RPC_PORT, help='port for vrrp rpc interface')]) 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)
def __init__(self, *args, **kwargs): super(LocalControllerLib, self).__init__(*args, **kwargs) self.name = 'local_lib' self.server_addr = None self.server_port = None self.is_active = False self.agent_id = -1 self.send_q = hub.Queue(16) self.hosts = {} self.cross_domain_links = [] self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def __init__(self, test_setup, launch_successful_future): """ If verification fails throw an exception, don't start ryu apps """ if test_setup.integ_test is False: hub.patch(thread=True) assert_pipelined_not_running() self._test_setup = test_setup self.keep_running = True self.done = False self.event_queue = hub.Queue() thread = threading.Thread(target=self.start_ryu_apps, args=(launch_successful_future, )) thread.daemon = True thread.start()
def __init__(self, *args, **kwargs): super(LocalController, self).__init__(*args, **kwargs) self.topo = {} self.status = False self.client_id = 1 self.send_queue = hub.Queue(16) self.socket = socket.socket() self.start_serve('127.0.0.1', 9999) self.time = 0 logger.init( '/root/ez-segway/logs/local-muc/locallog%d' % (self.client_id + 1), logging.INFO)
def lookup(self): queue = hub.Queue() def get_stats(): self._tc.ryu_query_lookup( _generate_ryu_req(self._table_id, self._match, self._cookie), queue) hub.joinall([hub.spawn(get_stats)]) flows = queue.get(block=True) return [ FlowStats(flow.packet_count, flow.byte_count, flow.duration_sec, flow.cookie) for flow in flows ]
def __init__(self, server, sock, addr): self.server = server self.sock = sock self.addr = addr self.logger = server.logger self.is_active = False self._threads = [] self.send_q = hub.Queue(16) # Zebra protocol version self.zserv_ver = CONF.server_version # Zebra route type distributed by client (not initialized yet) self.route_type = None
def send_request(self, req): """ Make a synchronous request. Set req.sync to True, send it to a Ryu application specified by req.dst, and block until receiving a reply. Returns the received reply. The argument should be an instance of EventRequestBase. """ assert isinstance(req, EventRequestBase) req.sync = True req.reply_q = hub.Queue() self.send_event(req.dst, req) # going to sleep for the reply return req.reply_q.get()