def test_scenario_from_init_to_todfail(self):
self.assertTrue(self.set_mgr_ready_for_tod())
startupcore = self.get_startup_core()
print "First tod fail"
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_TOD
event_request_rsp.mgr_event.data = 'tod_first_failed/0' + '|' + '1.1.1.1'
self.mgr._handle_mgr_tod_event(msg=event_request_rsp.mgr_event)
self.assertEquals(ManagerProcess.SYSTEM_TIME_CONFIRM,
t_TpcMessage.FIRST_ATTEMPT_FAILED)
print "All tod fail"
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_TOD
event_request_rsp.mgr_event.data = 'tod_failed/' + '' + '|' + '1.1.1.1'
self.mgr._handle_mgr_tod_event(msg=event_request_rsp.mgr_event)
self.assertEquals(self.mgr.tod_retry, 1)
self.assertEquals(ManagerProcess.SYSTEM_TIME_CONFIRM,
t_TpcMessage.ALL_ATTEMPTS_FAILED)
print "Second tod fail"
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_TOD
event_request_rsp.mgr_event.data = 'tod_failed/' + '' + '|' + '1.1.1.1'
self.mgr._handle_mgr_tod_event(msg=event_request_rsp.mgr_event)
self.assertEquals(self.mgr.fsm.current, self.mgr.fsm.STATE_FAIL)
def test_interface_status_event(self):
context = zmq.Context()
sock1 = context.socket(zmq.PUSH)
sock1.connect(ProcessAgent.SockPathMapping[
ProcessAgent.AGENTTYPE_INTERFACE_STATUS]['pull'])
sock = context.socket(zmq.REQ)
sock.connect(ProcessAgent.SockPathMapping[
ProcessAgent.AGENTTYPE_INTERFACE_STATUS]['api'])
sock2 = context.socket(zmq.PULL)
sock2.bind("ipc:///tmp/sock4.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "abcd"
reg.action = pb2.msg_manager_register.REG
reg.path_info = "ipc:///tmp/sock4.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.event_id = 1
event_request.action.parameter = "eth0"
event_request.action.action = pb2.msg_event.START
sock1.send(event_request.SerializeToString())
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.event_id = 1
event_request.action.parameter = "eth0"
event_request.action.action = pb2.msg_event.STOP
# sock1.send(event_request.SerializeToString())
while True:
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
def _send_ka_notification(self, mgr_id, status, reason):
"""This is a private function, used to send the event notification.
TODO paramaters dont match
:param ccap_id: ccap core ID
:param status: FAIL/OK
:param reason: The fail reason
:param result: The success result.
:return: Node
"""
msg_event_notification = process_agent_pb2.msg_event_notification()
msg_ka_rsp = process_agent_pb2.msg_ka_rsp()
msg_ka_rsp.id = mgr_id
msg_ka_rsp.status = status
msg_ka_rsp.reason = reason
msg_ka_rsp.agent_id = self.id
msg_event_notification.ka_rsp.CopyFrom(msg_ka_rsp)
# Get the transport
if mgr_id in self.mgrs:
transport = self.mgrs[mgr_id]['transport']
transport.sock.send(msg_event_notification.SerializeToString(),
flags=zmq.NOBLOCK)
self.logger.debug("Process an event action for id %s, return:%s" %
(mgr_id, msg_ka_rsp))
else:
self.logger.warn(
"mgr id %s is not in mgr db of process agent %s " %
(mgr_id, self.__class__))
return
def scan_available_interface(self, _):
interface_up = list()
stats = net_if_stats()
for interface in stats.keys():
if interface != 'lo':
if SysTools.is_if_oper_up(interface):
interface_up.append(interface)
# need to check redefined interface proto is provision or not for RPD
interface_ret = self.filter_proto_interface("'provision'", interface_up)
# prepare for startup
if self.init_start:
for interface in interface_ret:
SysTools.set_protocol(interface)
self.init_start = False
for idx in self.mgrs:
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = idx
event_request_rsp.mgr_event.event_id = self.id
event_request_rsp.mgr_event.data = json.dumps(interface_ret)
try:
self.mgrs[idx]['transport'].sock.send(
event_request_rsp.SerializeToString(), flags=zmq.NOBLOCK)
except zmq.ZMQError as ex:
self.logger.error("failed to send to manager: %s" % str(ex))
def build_mgr_event(mgrid, agentid, msg_str, data):
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgrid
event_request_rsp.mgr_event.event_id = agentid
event_request_rsp.mgr_event.data = json.dumps(msg_str + "/" +
json.dumps(data))
return event_request_rsp.mgr_event
def set_mgr_principal_found(self, core_ip='1.1.1.1'):
self.assertTrue(self.set_mgr_ready_for_ipsec())
for gcpcore in CCAPCore.ccap_core_db.values():
if isinstance(gcpcore, CCAPCore) and isinstance(gcpcore.fsm, CCAPFsm) \
and (gcpcore.ccap_core_network_address == core_ip):
break
try:
self.set_core_ready_for_tcp(coreid=gcpcore.ccap_core_id)
print "Manager receive core identification"
caps = {
"index": 1,
"is_active": True,
"ccap_core": gcpcore.ccap_core_network_address,
'interface': gcpcore.interface,
"is_principal": True
}
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_GCP
event_request_rsp.mgr_event.data = json.dumps("role/" +
json.dumps(caps))
self.mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
self.assertEquals(self.mgr.fsm.current,
self.mgr.fsm.STATE_PRINCIPAL_FOUND)
self.assertIsNone(self.mgr.principal_core_seek_timer)
self.assertIsNotNone(self.mgr.principal_core)
return True
except Exception as e:
raise e
def set_mgr_ready_for_ipsec(self,
tod_server="1.1.1.1",
timestamp="15234215315"):
self.assertTrue(self.set_mgr_ready_for_tod())
print "Manager and startup core TOD OK"
startupcore = self.get_startup_core()
startupcore.fsm.TRIGGER_TOD_OK()
self.assertEquals(startupcore.fsm.current,
startupcore.fsm.STATE_TOD_OK)
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_TOD
event_request_rsp.mgr_event.data = 'success/' + timestamp + \
'|' + tod_server
self.mgr._handle_mgr_tod_event(msg=event_request_rsp.mgr_event)
self.assertTrue(self.mgr.is_system_time_confirmed())
self.assertIsNotNone(self.mgr.operational_timer)
self.assertIsNotNone(self.mgr.core_orchestrator.orchestrator_timer)
self.assertIsNone(self.mgr.principal_core_seek_timer)
self.assertEquals(len(CCAPCore.ccap_core_db), 2)
for gcpcore in CCAPCore.ccap_core_db.values():
if isinstance(gcpcore, CCAPCore) and isinstance(
gcpcore.fsm, CCAPFsm):
break
self.assertIsInstance(gcpcore, CCAPCore)
print "GCP core startup OK"
gcpcore.fsm.TRIGGER_Startup()
self.assertEquals(gcpcore.fsm.current, gcpcore.fsm.STATE_INIT_IPSEC)
return True
def set_mgr_ready_for_tod(self):
self.assertTrue(self.set_mgr_ready_for_dhcp())
startupcore = self.get_startup_core()
print "Manager DHCP OK"
msg = TestCCAPCoreClass.build_event_notification(
ccap_id=startupcore.ccap_core_id,
status=process_agent_pb2.msg_core_event_notification.OK,
reason="test",
result="UP",
agentid=provision_pb2.AGENTTYPE_DHCP)
startupcore._handle_core_dhcp_event(msg)
self.assertEqual(startupcore.fsm.current, CCAPFsmStartup.STATE_DHCP_OK)
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_DHCP
event_request_rsp.mgr_event.data = \
json.dumps(
{'CCAPCores': ['1.1.1.1', '2.2.2.2'],
'TimeServers': ['1.1.1.1', '2.2.2.2'],
'TimeOffset': 12800,
'CreatedTime': 22222,
'LogServers': ['1.1.1.1', '2.2.2.2'],
'initiated_by': startupcore.ccap_core_id,
'Interface': startupcore.interface})
self.mgr._handle_mgr_dhcp_event(msg=event_request_rsp.mgr_event)
self.assertEquals(self.mgr.fsm.current,
self.mgr.fsm.STATE_PRINCIPLE_PROVISION)
return True
def _send_event_notification(self, ccap_id, status, reason, result="DOWN"):
"""This is a private function, used to send the event notification.
:param ccap_id: ccap core ID
:param status: FAIL/OK
:param reason: The fail reason
:param result: The success result.
:return: Node
"""
msg_event_notification = process_agent_pb2.msg_event_notification()
msg_event_notification.core_event.id = ccap_id
msg_event_notification.core_event.ccap_core_id = ccap_id
msg_event_notification.core_event.status = status
msg_event_notification.core_event.reason = reason
msg_event_notification.core_event.event_id = self.id
msg_event_notification.core_event.result = result
# Get the transport
if ccap_id in self.ccap_cores:
ccap_core = self.ccap_cores[ccap_id]
transport = self.mgrs[ccap_core["mgr"]]['transport']
transport.sock.send(msg_event_notification.SerializeToString(),
flags=zmq.NOBLOCK)
self.logger.debug("Process an event action for id %s, return:%s" %
(ccap_id, msg_event_notification))
else:
self.logger.warn(
"ccap id %s is not in core db of process agent %s " %
(ccap_id, self.__class__))
return
def scan_available_interface(self, _):
self.logger.debug("Scanning available interface ...")
for idx in self.mgrs:
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = idx
event_request_rsp.mgr_event.event_id = self.id
event_request_rsp.mgr_event.data = self.Fake_Parameter[self.id]
try:
self.mgrs[idx]['transport'].sock.send(
event_request_rsp.SerializeToString(), flags=zmq.NOBLOCK)
except zmq.ZMQError as ex:
self.logger.error("failed to send to manager: %s" % str(ex))
def test_handle_mgr_8021x_event(self):
print '*' * 80
print "start to test _handle_mgr_8021x_event"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_8021X
mgr._handle_mgr_8021x_event(event_request_rsp.mgr_event)
mgr.fsm.Error(msg='test fsm error')
def PtpNotifyHandler(self, new_status):
if self.ptp_status == self.SYNC and self.ptp_status == new_status:
pass
else:
self.logger.debug("The new status:%s, old status:%s" %
(new_status, self.ptp_status))
if self.ptp_status != new_status:
self.ptp_status = new_status
if self.ptp_status == self.SYNC:
self.PtpClient.ptp_result = t_GeneralNotification.PTPSYNCHRONIZED
else:
self.PtpClient.ptp_result = t_GeneralNotification.PTPACQUIRE
if len(self.ptp_requester):
self.PtpClient.sendNotificationMsg(MsgTypeRoutePtpStatus,
self.ptp_status)
gen_ntf_msg = t_GeneralNotification()
gen_ntf_msg.NotificationType = t_GeneralNotification.PTPRESULTNOTIFICATION
gen_ntf_msg.PtpResult = self.PtpClient.ptp_result
self.PtpClient.sendNotificationMsg(
MsgTypeGeneralNtf, gen_ntf_msg.SerializeToString())
else:
self.logger.info(
"No ccap core started yet, ccap cores:%s, requesters:%s" %
(self.ccap_cores, self.ptp_requester))
for id in self.ptp_requester:
if id not in self.ccap_cores:
self.ptp_requester.remove(id)
continue
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.core_event.id = id
event_request_rsp.core_event.ccap_core_id = id
event_request_rsp.core_event.status = protoDef.msg_core_event_notification.OK
event_request_rsp.core_event.reason = "Status changed"
event_request_rsp.core_event.event_id = self.id
event_request_rsp.core_event.result = self.ptp_status_to_result[
self.ptp_status]
ccap_core = self.ccap_cores[id]
transport = self.mgrs[ccap_core["mgr"]]['transport']
try:
transport.sock.send(event_request_rsp.SerializeToString(),
flags=zmq.NOBLOCK)
self.logger.info("Send status change to id %s, msg:%s" %
(id, event_request_rsp))
except zmq.Again as e:
pass
except Exception as e:
self.logger.error("Cannot send the event, reason:%s" %
str(e))
def test_gcp_roel(self):
print '*' * 80
print "start to test _handle_mgr_gcp_event role"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_GCP
ccap_core = CCAPCore.ccap_core_db.values()
ccap_core[0].interface = 'eth0'
ccap_core[0].ccap_core_network_address = '1.1.1.5'
# ccap_core[0].is_principal = CoreDescription.CORE_ROLE_PRINCIPAL
# ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE
# not exist core
caps = {
"is_active": False,
"ccap_core": '1.1.1.10',
'interface': 'eth0',
"is_principal": False
}
event_request_rsp.mgr_event.data = json.dumps("role/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# principal active
caps = {
"is_active": True,
"ccap_core": '1.1.1.5',
'interface': 'eth0',
"is_principal": True
}
event_request_rsp.mgr_event.data = json.dumps("role/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# auxiliary standby
caps = {
"is_active": False,
"ccap_core": '1.1.1.5',
'interface': 'eth0',
"is_principal": False
}
event_request_rsp.mgr_event.data = json.dumps("role/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr.fsm.Error(msg='test fsm error')
def test_handle_mgr_ipsec_event(self):
print '*' * 80
print "start to test _handle_mgr_ipsec_event"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_IPSEC
mgr._handle_mgr_ipsec_event(event_request_rsp.mgr_event)
keys = CCAPCore.ccap_core_db.keys()
for key in keys:
CCAPCore.ccap_core_db.pop(key)
mgr.fsm.Error(msg='test fsm error')
def test_remove_principal_from_operational(self):
self.assertTrue(self.set_mgr_operational())
print "Manager receive core identification"
caps = {
"index": 1,
"is_active": True,
"ccap_core": self.mgr.principal_core.ccap_core_network_address,
'interface': self.mgr.principal_core.interface,
"is_principal": False
}
event_request_rsp = process_agent_pb2.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = self.mgr.mgr_id
event_request_rsp.mgr_event.event_id = provision_pb2.AGENTTYPE_GCP
event_request_rsp.mgr_event.data = json.dumps("role/" +
json.dumps(caps))
self.mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
self.assertIsNone(self.mgr.principal_core)
def build_event_notification(ccap_id, status, reason, result, agentid):
"""This is a private function, used to send the event notification.
:param ccap_id: ccap core ID
:param status: FAIL/OK
:param reason: The fail reason
:param result: The success result.
:return: Node
"""
msg_event_notification = process_agent_pb2.msg_event_notification()
msg_event_notification.core_event.id = ccap_id
msg_event_notification.core_event.ccap_core_id = ccap_id
msg_event_notification.core_event.status = status
msg_event_notification.core_event.reason = reason
msg_event_notification.core_event.event_id = agentid
msg_event_notification.core_event.result = result
return msg_event_notification.core_event
def test_handle_mgr_tod_event(self):
print '*' * 80
print "start to test _handle_mgr_tod_event"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_TOD
event_request_rsp.mgr_event.data = 'tod_first_failed/0'
mgr._handle_mgr_tod_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = 'tod_failed/'
mgr._handle_mgr_tod_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = 'tod_failed/'
mgr.tod_retry = mgr.TOD_RETRY_CNT
mgr._handle_mgr_tod_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = 'else/'
mgr._handle_mgr_tod_event(event_request_rsp.mgr_event)
mgr.fsm.Error(msg='test fsm error')
def dhcp_msg_cb(self, fd, eventmask):
"""Callback function for received zmq msg.
:param fd: zmq socket instance.
:param eventmask: events.
:return: None
"""
for interface in self.dhcp:
transport = self.dhcp[interface]["transport"]
if transport.sock == fd:
break
else:
self.logger.warn(
"Cannot find the fd in internal interface DB, receive and ignore it."
)
ipc_msg = fd.recv(flags=zmq.NOBLOCK)
if ipc_msg:
dhcp_msg = t_DhcpMessage()
dhcp_msg.ParseFromString(ipc_msg)
self.logger.warn(
"Received DHCP message from unexpected interface:%s",
dhcp_msg)
return
# Receive the msg from the remote
if eventmask == 0:
self.logger.debug("Got a fake process event, ignore it")
return
if eventmask & self.dispatcher.EV_FD_ERR:
self.logger.warn("Got an FD_ERR event.")
return
if transport.sock.getsockopt(zmq.EVENTS) != zmq.POLLIN:
self.logger.debug("Got a fake event, the receive is not ready!")
return
try:
ipc_msg = transport.sock.recv(flags=zmq.NOBLOCK)
dhcp_msg = t_DhcpMessage()
dhcp_msg.ParseFromString(ipc_msg)
self.logger.debug("DHCP status received %s[%s] from %s",
dhcp_msg.InterfaceName,
dhcp_msg.t_Status.Name(dhcp_msg.Status),
dhcp_msg.t_Client.Name(dhcp_msg.Client))
status_changed = False
interface = dhcp_msg.InterfaceName
src_client = dhcp_msg.Client
if interface not in self.processes:
self.logger.debug(
"Ignore this message, %s process doesn't started.",
interface)
return
if src_client == dhcp_msg.DHCPV4 and self.processes[interface][
'name'] != 'dhcpv4':
self.logger.debug("Ignore this message, it's unexpected...")
return
elif src_client == dhcp_msg.DHCPV6 and self.processes[interface][
'name'] != 'dhcpv6':
self.logger.debug("Ignore this message, it's unexpected...")
return
if dhcp_msg.Status == dhcp_msg.UPDATED:
if not len(dhcp_msg.DHCPData.CCAPCores):
self.notify.critical(
rpd_event_def.RPD_EVENT_DHCP_CORE_LIST_MISSING[0],
interface)
return
self.dhcp_data = dhcp_msg.DHCPData
CreatedTime = RpdInfoUtils.getSysUpTime()
if self.dhcp[interface]['status'] != self.UP:
status_changed = True
self.dhcp[interface]['status'] = self.UP
self.dhcp[interface]['initiated'] = True
# when dhcpv6 process change to state UP, check if any duplicated ipv6 address event need to be reported
if self.processes[interface]['name'] == 'dhcpv6':
self.check_and_report_ipv6_event(interface)
self.delete_dhcp_data()
self.verify_dhcp_data()
# ignore this message if no core care about it
if len(self.dhcp[interface]['requester']) == 0:
timer = self.processes[interface]["timer"]
if timer:
self.dispatcher.timer_unregister(timer)
self.processes[interface]["timer"] = None
self.logger.debug(
"No requester care about DHCP update message received: %s",
dhcp_msg.t_Status.Name(dhcp_msg.Status))
return
# send mgr message to mgr process
for idx in self.mgrs:
data = self.db_adapter.get_leaf(self.dhcp_data_path)
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = idx
event_request_rsp.mgr_event.event_id = self.id
event_request_rsp.mgr_event.data = \
json.dumps(
{'CCAPCores': [ccap for ccap in data.CCAPCores],
'TimeServers': [ts for ts in data.TimeServers],
'TimeOffset': data.TimeOffset,
'CreatedTime': CreatedTime,
'LogServers': [ls for ls in data.LogServers],
'initiated_by': self.dhcp[interface]['initiated_by'],
'Interface': interface,
'Slaac': data.Slaac})
self.mgrs[idx]['transport'].sock.send(
event_request_rsp.SerializeToString(),
flags=zmq.NOBLOCK)
self.logger.debug("Send status change to id %s, msg:%s" %
(idx, event_request_rsp))
self._dhcp_timer_unregister(interface)
elif dhcp_msg.Status == dhcp_msg.FAILED:
self._dhcp_timer_unregister(interface)
ret = self._dhcp_no_lease(interface)
if not ret and self.dhcp[interface]['status'] != self.DOWN:
status_changed = True
self.dhcp[interface]['status'] = self.DOWN
else:
self.logger.error("Unexpected status received from DHCP")
self._dhcp_timer_unregister(interface)
return
# Find out from which DHCP process is running (who sent it)
dhcp_proc = self.processes[interface]["process"]
# dhcpv6 process can be started atomically
if not dhcp_proc:
self.logger.debug("DHCP client process is terminated")
if self.dhcp[interface]['status'] != self.DOWN:
status_changed = True
self.dhcp[interface]['status'] = self.DOWN
# send the status change to the requester
if not status_changed:
return
popup_list = list()
for ccap_core_id in self.dhcp[interface]["requester"]:
if ccap_core_id not in self.ccap_cores:
popup_list.append(ccap_core_id)
continue
self._send_event_notification(
ccap_core_id,
protoDef.msg_core_event_notification.OK,
"Status changed",
result=self.dhcp[interface]["status"])
for idx in popup_list:
self.dhcp[interface]['requester'].remove(idx)
except zmq.Again as e:
pass
except Exception as e:
self.logger.error("Cannot process the event, reason:%s" % str(e))
def test_handle_mgr_dhcp_event(self):
print '*' * 80
print "start to test _handle_mgr_dhcp_event"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_DHCP
ccap_core = CCAPCore.ccap_core_db.values()
ccap_core[0].interface = 'eth0'
# no data field
mgr._handle_mgr_dhcp_event(event_request_rsp.mgr_event)
# with core list
event_request_rsp.mgr_event.data = json.dumps({
'CCAPCores': [
'1.1.1.1',
],
'TimeServers': [
'1.1.1.1',
],
'TimeOffset':
100,
'LogServers': [
'1.1.1.1',
],
'initiated_by':
None,
'Interface':
'eth0'
})
mgr._handle_mgr_dhcp_event(event_request_rsp.mgr_event)
# eth0 already in dhcp_parameters, update it
event_request_rsp.mgr_event.data = json.dumps({
'CCAPCores': ['1.1.1.1', '1.1.1.7'],
'TimeServers': [
'1.1.1.1',
],
'TimeOffset':
100,
'LogServers': [
'1.1.1.1',
],
'initiated_by':
None,
'Interface':
'eth0'
})
mgr._handle_mgr_dhcp_event(event_request_rsp.mgr_event)
# no update
event_request_rsp.mgr_event.data = json.dumps({
'CCAPCores': ['1.1.1.1', '1.1.1.7'],
'TimeServers': [
'1.1.1.1',
],
'TimeOffset':
100,
'LogServers': [
'1.1.1.1',
],
'initiated_by':
None,
'Interface':
'eth0'
})
mgr._handle_mgr_dhcp_event(event_request_rsp.mgr_event)
# no core list
event_request_rsp.mgr_event.data = json.dumps({
'CCAPCores': [],
'TimeServers': [
'1.1.1.1',
],
'TimeOffset':
100,
'LogServers': [
'1.1.1.1',
],
'initiated_by':
None,
'Interface':
'eth0'
})
mgr._handle_mgr_dhcp_event(event_request_rsp.mgr_event)
mgr.fsm.Error(msg='test fsm error')
def test_ike_event(self):
context = zmq.Context()
sock1 = context.socket(zmq.PUSH)
sock1.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_8021X]['pull'])
sock = context.socket(zmq.REQ)
sock.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_8021X]['api'])
sock2 = context.socket(zmq.PULL)
sock2.bind("ipc:///tmp/sock4.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "abcd"
reg.action = pb2.msg_manager_register.REG
# reg.path_info = "ipc:///tmp/sock4.sock"
reg.path_info = ProcessAgent.SockPathMapping[
ProcessAgent.AGENTTYPE_8021X]['api']
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
# core register
register_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.ccap_core_id = 'abcd'
reg.mgr_id = 'abcd'
reg.action = pb2.msg_core_register.REG
register_request.core_reg.CopyFrom(reg)
data = register_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.ccap_core_id = "abcd"
event_request.action.event_id = ppb2.AGENTTYPE_8021X
# msg = t_TodMessage()
# msg.TimeServers.extend(['127.0.0.1', ])
# msg.TimeOffset = 0
# parameter = msg.SerializeToString()
parameter = "enp0s3"
event_request.action.parameter = parameter
event_request.action.action = pb2.msg_event.START
sock1.send(event_request.SerializeToString())
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.event_id = ppb2.AGENTTYPE_8021X
event_request.action.parameter = parameter
event_request.action.action = pb2.msg_event.STOP
# sock1.send(event_request.SerializeToString())
while True:
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
def test_dhcp_start_checkStatus_stop(self):
print 'test dhcp start and stop action'
context = zmq.Context()
sock_push = context.socket(zmq.PUSH)
sock_push.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_DHCP]['pull'])
sock_api = context.socket(zmq.REQ)
sock_api.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_DHCP]['api'])
sock_pull = context.socket(zmq.PULL)
sock_pull.bind("ipc:///tmp/test_dhcp_agent.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.REG
reg.path_info = "ipc:///tmp/test_dhcp_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.REG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_DHCP
event_request.action.parameter = "lo"
event_request.action.action = pb2.msg_event.START
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# start a second core request in the same interface
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core_2"
reg.action = pb2.msg_core_register.REG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.ccap_core_id = "test_ccap_core_2"
event_request.action.event_id = ProcessAgent.AGENTTYPE_DHCP
event_request.action.parameter = "lo"
event_request.action.action = pb2.msg_event.START
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# test dhcp client send message to the agent
print 'DHCP client send the dhcp message to agent'
dhcp_msg = t_DhcpMessage()
dhcp_msg.InterfaceName = 'lo'
dhcp_msg.Status = dhcp_msg.UPDATED
dhcp_msg.Client = dhcp_msg.DHCPV4
dhcp_data = dhcp_msg.DHCPData
dhcp_data.TimeServers.extend(['2.2.2.2', '1.1.1.1'])
dhcp_data.LogServers.extend(['2.2.2.2', '1.1.1.1'])
dhcp_data.CCAPCores.extend([
'2.2.2.2',
])
dhcp_data.TimeOffset = 0
self.dhcp_client_transport.sock.send(dhcp_msg.SerializeToString())
time.sleep(5)
dhcp_msg.InterfaceName = 'eth0'
dhcp_msg.Status = dhcp_msg.UPDATED
self.dhcp_client_transport.sock.send(dhcp_msg.SerializeToString())
time.sleep(5)
dhcp_msg.Status = dhcp_msg.FAILED
self.dhcp_client_transport.sock.send(dhcp_msg.SerializeToString())
time.sleep(5)
dhcp_msg.Status = dhcp_msg.INITIATED
self.dhcp_client_transport.sock.send(dhcp_msg.SerializeToString())
time.sleep(5)
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_DHCP
event_request.action.parameter = "lo"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.action = pb2.msg_event.STOP
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# unregister the ccapcore
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.UNREG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# unregister the mgr
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.UNREG
reg.path_info = "ipc:///tmp/test_dhcp_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
if local_ip in self.ike and remote_ip in self.ike[local_ip]:
old_status = self.ike[local_ip][remote_ip]['status']
if ike_status == self.IKE_UP:
self.ike[local_ip][remote_ip]["status"] = self.UP
else:
self.ike[local_ip][remote_ip]["status"] = self.DOWN
# fault management notify
if ike_status == self.DOWN:
self.notify.error(RPD_EVENT_MUTUAL_AUTH_ERROR[0],
"Certificate Failed(%s %s)" % (local_ip, remote_ip), "")
# Notify Mgr FSM
if old_status != self.ike[local_ip][remote_ip]["status"]:
id = self.ike[local_ip][remote_ip]["id"]
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.core_event.id = id
event_request_rsp.core_event.ccap_core_id = id
event_request_rsp.core_event.status = protoDef.msg_core_event_notification.OK
event_request_rsp.core_event.reason = "Status changed"
event_request_rsp.core_event.event_id = self.id
event_request_rsp.core_event.result = self.ike[local_ip][remote_ip]["status"]
ccap_core = self.ccap_cores[id]
transport = self.mgrs[ccap_core["mgr"]]['transport']
try:
transport.sock.send(
event_request_rsp.SerializeToString(),
flags=zmq.NOBLOCK)
self.logger.debug(
"Send status change to id %s, msg:%s" %
def test_tod_start_checkStatus_stop(self):
context = zmq.Context()
sock_push = context.socket(zmq.PUSH)
sock_push.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_TOD]['pull'])
sock_api = context.socket(zmq.REQ)
sock_api.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_TOD]['api'])
sock_pull = context.socket(zmq.PULL)
sock_pull.bind("ipc:///tmp/test_tod_agent.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.REG
reg.path_info = "ipc:///tmp/test_tod_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.REG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_TOD
event_request.action.parameter = "127.0.0.1/10|127.0.0.1"
event_request.action.action = pb2.msg_event.START
sock_push.send(event_request.SerializeToString())
# we want to receive 2 notifications, 1 for check status initial, 2 for the status update
# but it's waste time if there is no time server, as tpc client will
# retry
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
# same parameter resend
# event_request.action.ccap_core_id = "test_ccap_core"
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_TOD
event_request.action.parameter = "127.0.0.1/10|127.0.0.1"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.action = pb2.msg_event.STOP
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
# test wrong ccap core id
event_request = pb2.msg_event_request()
event_request.action.id = "test_wrong_ccap_id"
event_request.action.event_id = ProcessAgent.AGENTTYPE_TOD
event_request.action.parameter = "0.0.0.1/10|0.0.0.1"
event_request.action.ccap_core_id = "test_wrong_ccap_id"
event_request.action.action = pb2.msg_event.START
sock_push.send(event_request.SerializeToString())
# test no parameter
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_TOD
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.action = pb2.msg_event.STOP
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
# test no timeoffset and no log server
event_request.action.parameter = "10.0.0.1/|"
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print(rsp)
# test illegal parameter
event_request.action.parameter = "hahaha"
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print(rsp)
# test ipc_msg_call back
# simulate tpc send to tod_agent
kill_cmd = "kill -9 `pgrep -f tpc.py`"
call(kill_cmd, shell=True)
tod_sock_push = context.socket(zmq.PUSH)
tod_sock_push.connect(TimeOfDay.SOCK_ADDRESS)
tpc_msg = t_TpcMessage()
tpc_msg.Status = tpc_msg.INITIATED
msg_str = tpc_msg.SerializeToString()
tod_sock_push.send(msg_str)
time.sleep(2)
tpc_msg.Status = tpc_msg.SUCCESS
msg_str = tpc_msg.SerializeToString()
tod_sock_push.send(msg_str)
time.sleep(2)
tpc_msg.Timestamp = 500
msg_str = tpc_msg.SerializeToString()
tod_sock_push.send(msg_str)
time.sleep(2)
tpc_msg.Timestamp = 500
msg_str = tpc_msg.SerializeToString()
tod_sock_push.send(msg_str)
time.sleep(2)
tpc_msg.Status = tpc_msg.FIRST_ATTEMPT_FAILED
msg_str = tpc_msg.SerializeToString()
tod_sock_push.send(msg_str)
time.sleep(2)
tpc_msg.Status = tpc_msg.ALL_ATTEMPTS_FAILED
msg_str = tpc_msg.SerializeToString()
tod_sock_push.send(msg_str)
time.sleep(2)
tod_sock_push.close()
# unregister the ccapcore
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.UNREG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print(reg_rsp)
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# unregister the mgr
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.UNREG
reg.path_info = "ipc:///tmp/test_tod_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print(reg_rsp)
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
def test_ptp_start_checkStatus_stop(self):
context = zmq.Context()
sock_push = context.socket(zmq.PUSH)
sock_push.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_PTP]['pull'])
sock_api = context.socket(zmq.REQ)
sock_api.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_PTP]['api'])
sock_pull = context.socket(zmq.PULL)
sock_pull.bind("ipc:///tmp/test_ptp_agent.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.REG
reg.path_info = "ipc:///tmp/test_ptp_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.REG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_PTP
event_request.action.parameter = ''
event_request.action.action = pb2.msg_event.START
sock_push.send(event_request.SerializeToString())
if self.mastersim_pid is None:
self.start_mastersim()
# we want to receive 2 notifications, 1 for check status initial, 2 for
# the status update
timeout = time.time() + 60
i = 2
while i > 0 and time.time() < timeout:
try:
data = sock_pull.recv(flags=zmq.NOBLOCK)
except Exception as e:
print "Got exception: %s" % (str(e))
time.sleep(1)
continue
else:
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
i -= 1
self.assertEqual(i, 0)
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_PTP
event_request.action.parameter = ''
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.action = pb2.msg_event.STOP
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# unregister the ccapcore
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.UNREG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# unregister the mgr
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.UNREG
reg.path_info = "ipc:///tmp/test_ptp_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
def test_l2tp_start_checkStatus_stop(self):
context = zmq.Context()
sock_push = context.socket(zmq.PUSH)
sock_push.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_L2TP]['pull'])
sock_api = context.socket(zmq.REQ)
sock_api.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_L2TP]['api'])
sock_pull = context.socket(zmq.PULL)
sock_pull.bind("ipc:///tmp/test_l2tp_agent.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.REG
reg.path_info = "ipc:///tmp/test_l2tp_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.REG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_L2TP
event_request.action.parameter = "lo;127.0.0.1"
event_request.action.action = pb2.msg_event.START
sock_push.send(event_request.SerializeToString())
self.start_mastersim()
# we want to receive 2 notifications, 1 for check status initial, 2 for the status update
i = 2
while i > 0:
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
i -= 1
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "test_ccap_core"
event_request.action.event_id = ProcessAgent.AGENTTYPE_L2TP
event_request.action.parameter = "lo;127.0.0.1"
event_request.action.ccap_core_id = "test_ccap_core"
event_request.action.action = pb2.msg_event.STOP
sock_push.send(event_request.SerializeToString())
data = sock_pull.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# unregister the ccapcore
event_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.mgr_id = "test_mgr" # use a fake ccap id
reg.ccap_core_id = "test_ccap_core"
reg.action = pb2.msg_core_register.UNREG
event_request.core_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
# unregister the mgr
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "test_mgr" # use a fake ccap id
reg.action = pb2.msg_manager_register.UNREG
reg.path_info = "ipc:///tmp/test_l2tp_agent.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock_api.send(data)
data = sock_api.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
self.assertEqual(reg_rsp.reg_rsp.status, reg_rsp.reg_rsp.OK)
def test_handle_mgr_gcp_event(self):
print '*' * 80
print "start to test _handle_mgr_gcp_event"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_GCP
# interface set to ''
event_request_rsp.mgr_event.data = json.dumps("reboot/;1.1.1.1;info")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = json.dumps(
"connect_closed/;1.1.1.1;" + str(True))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = json.dumps(
"gcp_flapping/;1.1.1.1/recovering")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = json.dumps(
"redirect/1.1.1.3;/;1.1.1.1/")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# interface and ip valid
ccap_core = CCAPCore.ccap_core_db.values()
ccap_core[0].interface = 'eth0'
ccap_core[0].ccap_core_network_address = '1.1.1.5'
mgr.add_ip_to_core_map('eth0', ('1.1.1.5', '', 4))
mgr.principal_core = ccap_core[0]
second_core = CCAPCore('CORE-1234567890',
CoreDescription.CORE_ROLE_PRINCIPAL,
CoreDescription.CORE_MODE_ACTIVE,
mgr=mgr,
ccap_core_interface='eth0',
ccap_core_network_address='1.1.1.6')
CCAPCore.ccap_core_db[second_core.ccap_core_id] = second_core
event_request_rsp.mgr_event.data = json.dumps(
"reboot/eth0;1.1.1.5;info")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
ccap_core = CCAPCore('CORE-1234567890',
CoreDescription.CORE_ROLE_PRINCIPAL,
CoreDescription.CORE_MODE_ACTIVE,
mgr=mgr,
ccap_core_interface='eth0',
ccap_core_network_address='1.1.1.5')
CCAPCore.ccap_core_db[ccap_core.ccap_core_id] = ccap_core
event_request_rsp.mgr_event.data = json.dumps(
"connect_closed/eth0;1.1.1.5;" + str(True))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = json.dumps(
"gcp_flapping/eth0;1.1.1.5/recovering")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
event_request_rsp.mgr_event.data = json.dumps(
"gcp_flapping/eth0;1.1.1.5/done")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr.add_ip_to_core_map('eth0', ('1.1.1.5', '', 4))
event_request_rsp.mgr_event.data = json.dumps(
"redirect/1.1.1.3;/eth0;1.1.1.5")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr.add_ip_to_core_map('eth0', ('1.1.1.5', '', 4))
event_request_rsp.mgr_event.data = json.dumps(
"get_active_principal/3,1.1.1.1/")
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
def test_config_table(self):
print '*' * 80
print "start to test _handle_mgr_gcp_event config_table"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_GCP
# invalid ip
caps = {"ccap_core": '0.0.0.0', 'interface': 'eth0', "operation": 0}
event_request_rsp.mgr_event.data = json.dumps("config_table/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# add existed ip
ccap_core = CCAPCore.ccap_core_db.values()
ccap_core[0].interface = 'eth0'
ccap_core[0].ccap_core_network_address = '1.1.1.5'
ccap_core[0].is_principal = CoreDescription.CORE_ROLE_PRINCIPAL
ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE
# CCAPCore('CORE-1234567890', CoreDescription.CORE_ROLE_PRINCIPAL,
# CoreDescription.CORE_MODE_ACTIVE, mgr=mgr,
# ccap_core_interface='etho0', ccap_core_network_address='1.1.1.5')
caps = {
"ccap_core": '1.1.1.5',
'interface': 'eth0',
"operation": 0
} # add
event_request_rsp.mgr_event.data = json.dumps("config_table/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# add a new one
caps = {
"ccap_core": '1.1.1.6',
'interface': 'eth0',
"operation": 0
} # add
event_request_rsp.mgr_event.data = json.dumps("config_table/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
caps = {
"ccap_core": '1.1.1.5',
'interface': 'eth0',
"operation": 2
} # change
event_request_rsp.mgr_event.data = json.dumps("config_table/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr.add_ip_to_core_map('eth0', ('1.1.1.5', '', 4))
caps = {
"ccap_core": '1.1.1.5',
'interface': 'eth0',
"operation": 1
} # delete
event_request_rsp.mgr_event.data = json.dumps("config_table/" +
json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr.fsm.Error(msg='test fsm error')
def test_rcp_event(self):
context = zmq.Context()
sock1 = context.socket(zmq.PUSH)
sock1.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_GCP]['pull'])
sock = context.socket(zmq.REQ)
sock.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_GCP]['api'])
sock2 = context.socket(zmq.PULL)
sock2.bind("ipc:///tmp/sock4.sock")
rcp_sock = context.socket(zmq.PAIR)
rcp_sock.connect(RcpOverGcp.SOCK_ADDRESS)
mgr_sock = context.socket(zmq.REP)
mgr_sock.bind("ipc:///tmp/rpd_provision_manager_api.sock")
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "abcd"
reg.action = pb2.msg_manager_register.REG
reg.path_info = "ipc:///tmp/sock4.sock"
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
# core register
register_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.ccap_core_id = 'abcd'
reg.mgr_id = 'abcd'
reg.action = pb2.msg_core_register.REG
register_request.core_reg.CopyFrom(reg)
data = register_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print reg_rsp
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.ccap_core_id = "abcd"
event_request.action.event_id = pb2.AGENTTYPE_GCP
event_request.action.parameter = '127.0.0.1'
event_request.action.action = pb2.msg_event.START
sock1.send(event_request.SerializeToString())
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.ccap_core_id = "abcd"
event_request.action.event_id = pb2.AGENTTYPE_GCP
event_request.action.parameter = '127.0.0.1'
event_request.action.action = pb2.msg_event.STOP
# sock1.send(event_request.SerializeToString())
# send rcp message
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = t_RcpMessage.REDIRECT_NOTIFICATION
rcp_msg.RedirectCCAPAddresses.extend(['1.1.1.1'])
rcp_sock.send(rcp_msg.SerializeToString())
data = mgr_sock.recv()
red_rsp = pb2.msg_magager_api()
red_rsp.ParseFromString(data)
print red_rsp
while True:
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
def test_gcp_Ha(self):
print '*' * 80
print "start to test _handle_mgr_gcp_event HA"
mgr = ManagerProcess(simulator=False)
mgr.fsm.INTERFACE_SCAN(interface='eth0')
mgr.fsm.STARTUP_DHCP_OK(interface='eth0')
event_request_rsp = protoDef.msg_event_notification()
event_request_rsp.mgr_event.mgr_id = mgr.mgr_id
event_request_rsp.mgr_event.event_id = ProcessAgent.AGENTTYPE_GCP
ccap_core = CCAPCore.ccap_core_db.values()
ccap_core[0].interface = 'eth0'
ccap_core[0].ccap_core_network_address = '1.1.1.5'
print 'Redundant core Add'
# invalid ip
caps = {
"ActiveCoreIpAddress": '0.0.0.0',
"StandbyCoreIpAddress": '1.1.1.10',
'interface': 'eth0',
"operation": 0
}
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# not exist core
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.11',
'interface': 'eth0',
"operation": 0
}
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# active core mode active
caps = {
"ActiveCoreIpAddress": '1.1.1.5',
"StandbyCoreIpAddress": '1.1.1.11',
'interface': 'eth0',
"operation": 0
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# active core mode standby
caps = {
"ActiveCoreIpAddress": '1.1.1.5',
"StandbyCoreIpAddress": '1.1.1.11',
'interface': 'eth0',
"operation": 0
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_STANDBY
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# standby core mode active
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.5',
'interface': 'eth0',
"operation": 0
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# standby core mode standby
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.5',
'interface': 'eth0',
"operation": 0
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_STANDBY
mgr.add_ip_to_core_map('eth0', ('1.1.1.5', '', 0))
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
print 'Redundant core Change'
ccap_core[0].is_principal = CoreDescription.CORE_ROLE_PRINCIPAL
# standby core mode active
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.5',
'interface': 'eth0',
"operation": 2
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# standby core mode standby
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.5',
'interface': 'eth0',
"operation": 2
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_STANDBY
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
print 'Redundant core Delete'
# standby core mode active
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.5',
'interface': 'eth0',
"operation": 1
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_ACTIVE
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
# standby core mode standby
caps = {
"ActiveCoreIpAddress": '1.1.1.10',
"StandbyCoreIpAddress": '1.1.1.5',
'interface': 'eth0',
"operation": 1
}
ccap_core[0].is_active = CoreDescription.CORE_MODE_STANDBY
event_request_rsp.mgr_event.data = json.dumps("Ha/" + json.dumps(caps))
mgr._handle_mgr_gcp_event(event_request_rsp.mgr_event)
mgr.fsm.Error(msg='test fsm error')
def test_dhcp_event(self):
context = zmq.Context()
sock1 = context.socket(zmq.PUSH)
sock1.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_DHCP]['pull'])
sock = context.socket(zmq.REQ)
sock.connect(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_DHCP]['api'])
sock2 = context.socket(zmq.PULL)
# sock2.bind("ipc:///tmp/sock4.sock")
sock2.bind(
ProcessAgent.SockPathMapping[ProcessAgent.AGENTTYPE_DHCP]['push'])
dhcp_sock = context.socket(zmq.PUSH)
dhcp_sock.connect(DhcpAgent.SOCK_ADDRESS)
# test the successfully register
event_request = pb2.api_request()
reg = pb2.msg_manager_register()
reg.id = "abcd"
reg.action = pb2.msg_manager_register.REG
reg.path_info = ProcessAgent.SockPathMapping[
ProcessAgent.AGENTTYPE_DHCP]['push']
event_request.mgr_reg.CopyFrom(reg)
data = event_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print 'mgr reg:', reg_rsp
# core register
register_request = pb2.api_request()
reg = pb2.msg_core_register()
reg.ccap_core_id = 'abcd'
reg.mgr_id = 'abcd'
reg.action = pb2.msg_core_register.REG
register_request.core_reg.CopyFrom(reg)
data = register_request.SerializeToString()
sock.send(data)
data = sock.recv()
reg_rsp = pb2.api_rsp()
reg_rsp.ParseFromString(data)
print 'core reg:', reg_rsp
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.ccap_core_id = "abcd"
event_request.action.event_id = pb2.AGENTTYPE_DHCP
event_request.action.parameter = 'eth1'
event_request.action.action = pb2.msg_event.START
sock1.send(event_request.SerializeToString())
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
# test stop
event_request = pb2.msg_event_request()
event_request.action.id = "abcd"
event_request.action.ccap_core_id = "abcd"
event_request.action.event_id = pb2.AGENTTYPE_DHCP
event_request.action.parameter = 'eth1'
event_request.action.action = pb2.msg_event.STOP
# sock1.send(event_request.SerializeToString())
# data = sock2.recv()
# red_rsp = pb2.msg_event_notification()
# red_rsp.ParseFromString(data)
# print red_rsp
# send dhcp failed message
hostip = '127.0.0.1'
dhcp_msg = t_DhcpMessage()
dhcp_msg.InterfaceName = "eth1"
dhcp_msg.Status = dhcp_msg.FAILED
# dhcp_sock.send(dhcp_msg.SerializeToString())
# send dhcp success message
dhcp_msg.Status = dhcp_msg.UPDATED
dhcp_data = dhcp_msg.DHCPData
dhcp_data.TimeServers.extend([hostip, '1.1.1.1'])
dhcp_data.LogServers.extend([hostip, '1.1.1.1'])
dhcp_data.CCAPCores.extend([
hostip,
])
dhcp_data.TimeOffset = 0
# dhcp_sock.send(dhcp_msg.SerializeToString())
while True:
data = sock2.recv()
rsp = pb2.msg_event_notification()
rsp.ParseFromString(data)
print rsp
