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