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()
