def processCfgMsg(self, cfgMsg): rsp = t_RcpMessage() # rsp.ParseFromString(cfgMsg.CfgMsgPayload) req = t_RcpMessage() req.ParseFromString(cfgMsg.CfgMsgPayload) rsp.RpdDataMessage.RpdDataOperation = req.RpdDataMessage.RpdDataOperation rsp.RcpMessageType = req.RcpMessageType # load the rpd host resources information hr = rsp.RpdDataMessage.RpdData.HostResources hr.hrMemorySize = self.getMemorySize() hr.hrProcessorLoad = self.getProcessorLoad() self.getStorages(hr.hrStorages) self.getProcesses(hr.hrProcesses) rsp.RcpDataResult = t_RcpMessage.RCP_RESULT_OK payload = rsp.SerializeToString() msg = HalMessage("HalConfigRsp", SrcClientID=cfgMsg.SrcClientID, SeqNum=cfgMsg.SeqNum, Rsp={ "Status": HalCommon_pb2.SUCCESS, "ErrorDescription": "" }, CfgMsgType=cfgMsg.CfgMsgType, CfgMsgPayload=payload) return msg
def sendCfgRspMsg(self, cfg): cfgMsg = cfg.msg self.logger.debug("RPDInfo configuration message:" + str(cfg.msg)) if cfgMsg.CfgMsgType == MsgTypeRpdSysUpTime: rsp = t_RcpMessage() req = t_RcpMessage() req.ParseFromString(cfgMsg.CfgMsgPayload) rsp.RpdDataMessage.RpdDataOperation = req.RpdDataMessage.RpdDataOperation rsp.RcpMessageType = req.RcpMessageType self.logger.debug("%s" % str(req)) req.RpdDataMessage.RpdData.RpdSysUptime = self.getSysUpTime() rsp = req rsp.RcpDataResult = t_RcpMessage.RCP_RESULT_OK self.logger.debug("%s"%str(rsp)) payload = rsp.SerializeToString() msg = HalMessage( "HalConfigRsp", SrcClientID=cfgMsg.SrcClientID, SeqNum=cfgMsg.SeqNum, Rsp={ "Status": HalCommon_pb2.SUCCESS, "ErrorDescription": "" }, CfgMsgType=cfgMsg.CfgMsgType, CfgMsgPayload=payload) if self.pushSock: self.pushSock.send(msg.Serialize())
def vsp_tlv_handler(cfg): logger = get_msg_handler_logger() logger.info("Receive Vsp TLV from %s, Seq num: %d" % (cfg.msg.SrcClientID, cfg.msg.SeqNum)) """ Vendor should check for t_RcpMessage().t_RpdDataMessage().RpdDataOperation: (RPD_CFG_WRITE/RPD_CFG_READ/RPD_CFG_DELETE) and build a response based on these. Vendor should check for t_RcpMessage().t_RpdDataMessage().RpdData.VendorSpecificExtension.VendorId: Matched with his Vendor ID """ rsp = t_RcpMessage() rsp.ParseFromString(cfg.msg.CfgMsgPayload) rcp_vsp_tlv = rsp.RpdDataMessage.RpdData.VendorSpecificExtension dataOp = rsp.RpdDataMessage.RpdDataOperation logger.info("vsp_tlv_handler ClientID: %s, VSP Data %s, dataOp %d" % (cfg.msg.SrcClientID, rsp.RpdDataMessage.RpdData, dataOp)) rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RCP_MESSAGE_TYPE_NONE rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK if rcp_vsp_tlv.VendorId != DEFAULT_VENDOR_ID: rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_GENERAL_ERROR logger.info("vsp_tlv_handler: vid NOT matched. %d" % (rcp_vsp_tlv.VendorId)) rpd_data_msg = t_RpdDataMessage() rpd_data_msg.RpdDataOperation = dataOp # If Vendor ID matched, and dataOp == READ, then fill the Values of all TLVs if (rcp_msg.RcpDataResult == t_RcpMessage.RCP_RESULT_OK): if (dataOp == t_RpdDataMessage.RPD_CFG_READ): # Vendor should fill the sub-TLVs. rpd_data_msg.RpdData.CopyFrom(rsp.RpdDataMessage.RpdData) vsp_tlv = rpd_data_msg.RpdData.VendorSpecificExtension vsp_tlv.FWVersion = 0x0101 vsp_tlv.HWVersion = 0x0A0B rfChannel = vsp_tlv.RfChannel.add() rfChannel.RfChannelSelector.RfPortIndex = 1 rfChannel.RfChannelSelector.RfChannelType = 2 rfChannel.RfChannelSelector.RfChannelIndex = 3 rfChannel.DsScQamChannelPerf.outDiscards = 1024 rfChannel.DsScQamChannelPerf.outErrors = 2048 rfChannel.DsOfdmChannelPerf.outDiscards = 1024 * 3 rfChannel.DsOfdmChannelPerf.outErrors = 2048 * 3 rfChannel.DsOfdmChannelPerf.DsOfdmProfilePerf.ProfileIndex = 3 rfChannel.DsOfdmChannelPerf.DsOfdmProfilePerf.outCodewords = 123456789 elif (dataOp == t_RpdDataMessage.RPD_CFG_WRITE): # Apply the values of RfChannel TVL. logger.info("vsp_tlv_handler: RPD_CFG_WRITE. Perform WRITE...") pass rcp_msg.RpdDataMessage.CopyFrom(rpd_data_msg) cfg.msg.CfgMsgPayload = rcp_msg.SerializeToString() return cfg
def getRpdPtpState(self, cfg): rsp = t_RcpMessage() rsp.ParseFromString(cfg.msg.CfgMsgPayload) config = rsp.RpdDataMessage.RpdData try: config.RpdState.LocalPtpSyncStatus = \ True if self.ptp_result == t_GeneralNotification.PTPSYNCHRONIZED else False cfg.CfgMsgPayload = config.SerializeToString() rsp.RpdDataMessage.RpdData.CopyFrom(config) rsp.RcpDataResult = t_RcpMessage.RCP_RESULT_OK payload = rsp.SerializeToString() self.logger.info("Send rpd state LocalPtpSyncStatus response, %s" % rsp) msg = HalMessage("HalConfigRsp", SrcClientID=cfg.msg.SrcClientID, SeqNum=cfg.msg.SeqNum, Rsp={ "Status": HalCommon_pb2.SUCCESS, "ErrorDescription": "PTP LOCALPTPSYNCSTATUS query success" }, CfgMsgType=cfg.msg.CfgMsgType, CfgMsgPayload=payload) self.pushSock.send(msg.Serialize()) except Exception as e: self.logger.error("excpetipn:%s", str(e)) return
def _ipc_msg_cb(self, fd, eventmask): # pragma: no cover del eventmask try: while self.ipc_sock.getsockopt(zmq.EVENTS) and zmq.POLLIN: zmq_msg = self.ipc_sock.recv(flags=zmq.NOBLOCK) self.logger.debug("IPC message from manager received, len[%d]", len(zmq_msg)) if len(zmq_msg) > 0: msg = t_RcpMessage() msg.ParseFromString(zmq_msg) self.logger.info( "RCP message type: %s", msg.t_RcpMessageType.Name(msg.RcpMessageType)) if msg.RcpMessageType == msg.ADD_CCAP_CORES: self.add_ccap_cores(msg.RedirectCCAPAddresses) elif msg.RcpMessageType == msg.REMOVE_ALL_CCAP_CORES: self.orchestrator.remove_sessions_all() elif msg.RcpMessageType == msg.RPD_CONFIGURATION: # call the registered response callback try: self.ipc_rsp_callback(msg) except Exception as ex: self.logger.error( "IPC RCP callback call failed: %s", ex) else: raise DecodeError("Unexpected message type received") except zmq.Again: # Ignore ... retry handled by dispatcher return except DecodeError as exception: self.logger.error("Malformed IPC message, dropping ...: %s", exception.message) return
def test_rpdinfo_utils(self): ipaddr = { 'addrtype': RpdInfoUtils.INETADDRESSTYPE_IPV4, 'ip': '60.10.10.3', 'mask': 64, 'status': RpdInfoUtils.IPADDR_STATUS_1_PREFERRED, 'origin': RpdInfoUtils.IPADDR_ORIGIN_4_DHCP, } rsp = t_RcpMessage() ipaddr_info = rsp.RpdDataMessage.RpdData.RpdInfo.IpAddress.add() RpdInfoUtils.set_ipaddr_info(ipaddr, ipaddr_info) self.assertEqual(RpdInfoUtils.ip_exchange_mask('255.0.0.0'), 8) self.assertEqual( RpdInfoUtils.ip_exchange_mask( 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), 128) self.assertEqual( RpdInfoUtils.convert_ipv6('fe80::204:9fff:fe31:231%vbh0'), 'fe80::204:9fff:fe31:231') self.assertEqual(RpdInfoUtils.get_ipv6_arp_retransmit_time('vbh0'), 1000) self.assertEqual(RpdInfoUtils.get_ipv6_arp_retransmit_time('eth0'), 1000) self.assertEqual(RpdInfoUtils.get_ipv6_arp_reachable_time('vbh0'), 30000) self.assertEqual(RpdInfoUtils.get_ipv6_arp_reachable_time('eth0'), 30000) print(RpdInfoUtils.get_ipaddr_info()) self.assertEqual(RpdInfoUtils.read_ipv6_scope('vbh0', 'ip'), 11)
def test_recvRpdServerCtrlMsgCb(self): rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_WRITE cfg_msg = config() rpdCtrl = cfg_msg.RpdCtrl rpdServerCtrlCfg = rpdCtrl.CrashDataServerCtrl rpdServerCtrlCfg.DestIpAddress = "127.0.0.1" rpdServerCtrlCfg.DestPath = "/bootflash/" rpdServerCtrlCfg.Protocol = 2 rcp_msg.RpdDataMessage.RpdData.CopyFrom(cfg_msg) cfg_payload = rcp_msg.SerializeToString() self.cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdRes", SeqNum=322, CfgMsgType=MsgTypeRpdCtrl, CfgMsgPayload=cfg_payload) crashFileCtrl = self.rpdhostres.crashFileCtrlHandler self.assertEqual(None, self.rpdhostres.recvCfgMsgCb(self.cfgMsg)) crashDataServerInfo = crashFileCtrl.get_server_info() self.assertEqual(crashDataServerInfo.destIpAddress, rpdServerCtrlCfg.DestIpAddress) self.assertEqual(crashDataServerInfo.destPath, rpdServerCtrlCfg.DestPath) self.assertEqual(crashDataServerInfo.protocol, rpdServerCtrlCfg.Protocol)
def test_L2tpv3Hall_GCPP(self): index = 0 rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = \ t_RpdDataMessage.RPD_CFG_WRITE cfg_msg = config() staticPwConfig = cfg_msg.StaticPwConfig self.retCfg = StaticL2tpProvision() self.retCfg.add_usStaticSession(staticPwConfig, index + 163, False, False) self.retCfg.add_commStaticSession(staticPwConfig, index + 163, 0x80007111 + index, index, 32768, True) rcp_msg.RpdDataMessage.RpdData.CopyFrom(cfg_msg) cfg_payload = rcp_msg.SerializeToString() staticL2tpMsg = HalMessage("HalConfig", SrcClientID="testGCPPL2Static", SeqNum=325, CfgMsgType=HalConfigMsg.MsgTypeGcppToL2tp, CfgMsgPayload=cfg_payload) self.hal_client.recvCfgMsgCb(staticL2tpMsg) ses = StaticL2tpSession(index + 163) ses.read() self.assertTrue(self.fwdCfg.check_StaticSession(staticPwConfig, ses))
def recMsgTypeRpdCapabilitiesRspCb(self, halrspmsg): try: # Check the status if halrspmsg.msg.Rsp.Status != HalCommon_pb2.SUCCESS: # yes, we recv a error message from HAL self.logger.warning("Receive a hal fail message:%s" % halrspmsg.msg) return False cfg_rsp = t_RcpMessage() cfg_rsp.ParseFromString(halrspmsg.msg.CfgMsgPayload) if cfg_rsp.RcpDataResult != t_RcpMessage.RCP_RESULT_OK: # yes we recv a error msg from driver self.logger.warning("Recv a driver fail message:%s" % str(cfg_rsp)) return False rcp_rpd_cap = cfg_rsp.RpdDataMessage.RpdData.RpdCapabilities if not self.valid_rpd_cap(rcp_rpd_cap): self.logger.debug( "Receive invalid RpdCapabilities rsp from driver") return False if not self.rpd_cap: self.rpd_cap = t_RpdCapabilities() self.rpd_cap.CopyFrom(rcp_rpd_cap) self.logger.debug("Receive RpdCapabilities rsp from driver") return True except Exception as e: self.logger.warning("cap fail %s", str(e)) return False
def test_read_notification_handler(self): rcp_msg = t_RcpMessage() rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION evcfg = config() # test PendingOrLocalLog 0 notify_req = evcfg.EventNotification.add() notify_req.PendingOrLocalLog = 0 rcp_msg.RpdDataMessage.RpdData.CopyFrom(evcfg) rcp_msg.RpdDataMessage.RpdDataOperation = 2 payload = rcp_msg.SerializeToString() ntMsg = HalMessage("HalConfig", SrcClientID="testRpdFM", SeqNum=322, CfgMsgType=MsgTypetEventNotification, CfgMsgPayload=payload) self.fm.fault_ipc.read_notification_handler(ntMsg) # test PendingOrLocalLog 1 notify_req.PendingOrLocalLog = 1 rcp_msg.RpdDataMessage.RpdData.CopyFrom(evcfg) rcp_msg.RpdDataMessage.RpdDataOperation = 2 payload = rcp_msg.SerializeToString() ntMsg = HalMessage("HalConfig", SrcClientID="testRpdFM", SeqNum=322, CfgMsgType=MsgTypetEventNotification, CfgMsgPayload=payload) self.fm.fault_ipc.read_notification_handler(ntMsg)
def sendRpdCapReq(self): try: if self.rpd_cap: self.logger.debug( "Already has Rpd cap in store, no need to send req") return True rcp_msg = t_RcpMessage() rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rpd_data_msg = t_RpdDataMessage() rpd_data_msg.RpdDataOperation = t_RpdDataMessage.RPD_CFG_READ rcp_cfg = config() sub_tlv = rcp_cfg.RpdCapabilities GCPObject.default_gpb(gpb=sub_tlv) rpd_data_msg.RpdData.CopyFrom(rcp_cfg) rcp_msg.RpdDataMessage.CopyFrom(rpd_data_msg) cfgMsgContent = rcp_msg.SerializeToString() msg = HalMessage("HalConfig", SrcClientID=self.drvID, SeqNum=self.seqNum, CfgMsgType=MsgTypeRpdCapabilities, CfgMsgPayload=cfgMsgContent) self.send(msg.Serialize()) self.seqNum += 1 self.logger.debug("send RPD capabilities req to hal driver") return True except Exception as e: self.logger.warning("send RPD cap req failed :%s", str(e)) return False
def config_rdti(self, cfg): rdti_config_data = t_RcpMessage() rdti_config_data.ParseFromString(cfg.msg.CfgMsgPayload) rdti_config_data.RcpDataResult = t_RcpMessage.RCP_RESULT_OK cfg.msg.CfgMsgPayload = rdti_config_data.SerializeToString() self.logger.debug("Recv ptp configuration message, %s" % rdti_config_data) self.sendCfgRspMsg(cfg)
def start(self): """Start polling the transport socket. :return: """ self.logger.debug("Start the driver client poll...") self.connectionSetup() self.register(self.drvID) lastTimeout = time() while True: # Todo we should support quit flag? socks = self.poller.poll(self.pollTimeout) if time() - lastTimeout > self.pollTimeout / 1000: lastTimeout = time() # self.logger.debug("Got a timeout event") if self.recvNtf: rcp_msg = t_RcpMessage() rcp_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_READ rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdData.CopyFrom(config()) payload = rcp_msg.SerializeToString() self.sendCfgMsg(1025, payload) self.recvNtf -= 1 if not socks: continue for sock in socks: if self.pushSock is not None and sock == self.pushSock.monitor: self.pushSock.monitorHandler(recv_monitor_message(sock)) continue if self.pullSock is not None and sock == self.pullSock.monitor: self.pullSock.monitorHandler(recv_monitor_message(sock)) continue if sock == self.mgrConnection.monitor: self.mgrConnection.monitorHandler( recv_monitor_message(sock)) continue if socks[sock] == HalPoller.POLLIN: try: bin = sock.recv(flags=zmq.NOBLOCK) msg = HalMessage.DeSerialize(bin) self.logger.debug("Got a zmq msg:%s" % msg.msg) if msg.type in self.HalMsgsHandler: handler = self.HalMsgsHandler[msg.type] handler(msg) else: self.logger.warn("Unsupported msg type:%s" % msg.type) except zmq.ZMQError as e: self.logger.debug( "Geting an error when trying with nonblock read:" + str(e)) except Exception as e: self.logger.debug("Geting an error:" + str(e)) continue
def processRpdCtrlCfgMsg(self, cfgMsg): rcp_msg = t_RcpMessage() rcp_msg.ParseFromString(cfgMsg.msg.CfgMsgPayload) status = HalCommon_pb2.SUCCESS_IGNORE_RESULT recv_rcp_msg = rcp_msg.RpdDataMessage.RpdData if recv_rcp_msg.HasField("RpdCtrl"): rpdCtrl = recv_rcp_msg.RpdCtrl op = rcp_msg.RpdDataMessage.RpdDataOperation rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK flag = False if rpdCtrl.HasField("CrashDataServerCtrl"): status = HalCommon_pb2.SUCCESS self.logger.debug("Recv an RpdCtrlCfgMsg op %d, %s:" % (op, rpdCtrl)) if op == t_RpdDataMessage.RPD_CFG_WRITE: self.crashFileCtrlHandler.save_crash_data_server( rpdCtrl.CrashDataServerCtrl) flag = True if op == t_RpdDataMessage.RPD_CFG_READ: self.crashFileCtrlHandler.get_crash_data_server( rpdCtrl.CrashDataServerCtrl) flag = True if len(rpdCtrl.CrashDataFileCtrl ) > 0 and op == t_RpdDataMessage.RPD_CFG_WRITE: flag = True index = 0 for crashDataCtrl in rpdCtrl.CrashDataFileCtrl: if crashDataCtrl.HasField("Index"): index = crashDataCtrl.Index else: rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_GENERAL_ERROR if crashDataCtrl.HasField("FileControl"): fileControl = crashDataCtrl.FileControl if not self.crashFileCtrlHandler.update_pending_file_idx_list( index, fileControl): status = HalCommon_pb2.FAILED rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_GENERAL_ERROR if not flag: status = HalCommon_pb2.SUCCESS_IGNORE_RESULT else: status = HalCommon_pb2.SUCCESS elif rcp_msg.RpdDataMessage.RpdDataOperation == t_RpdDataMessage.RPD_CFG_READ: status = HalCommon_pb2.SUCCESS_IGNORE_RESULT else: status = HalCommon_pb2.FAILED payload = rcp_msg.SerializeToString() msg = HalMessage("HalConfigRsp", SrcClientID=cfgMsg.msg.SrcClientID, SeqNum=cfgMsg.msg.SeqNum, Rsp={ "Status": status, "ErrorDescription": "Get Rpd Control rsp" }, CfgMsgType=cfgMsg.msg.CfgMsgType, CfgMsgPayload=payload) return msg
def test_recvCfgMsgCb(self): cfg = t_RcpMessage() cfg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION payload = cfg.SerializeToString() print payload self.cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdHostResources", SeqNum=322, CfgMsgType=MsgTypeHostResources, CfgMsgPayload=payload) self.assertEqual(None, self.rpdhostres.recvCfgMsgCb(self.cfgMsg))
def set_global_conf(self, cfg): """set event global configuration default value.""" config_data = t_RcpMessage() config_data.ParseFromString(cfg.msg.CfgMsgPayload) config = config_data.RpdDataMessage.RpdData self.logger.debug("Recv global event configuration message, %s" % config) rpd_event_def.RpdEventConfig.set_config(config) config_data.RcpDataResult = t_RcpMessage.RCP_RESULT_OK cfg.msg.CfgMsgPayload = config_data.SerializeToString() self.config_refreshed = True
def create_core(): # create a zmq and connect to socekt address context = zmq.Context.instance() ipc_sock = context.socket(zmq.PAIR) ipc_sock.bind(RPD_RCP_IPC_SOCK) rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = rcp_msg.ADD_CCAP_CORES rcp_msg.RedirectCCAPAddresses.extend(RPD_CORE_ADDRESS) msg_str = rcp_msg.SerializeToString() ipc_sock.send(msg_str)
def check_rcp(rpd_vm): msg = t_ItApiRpdMessage() msg.ItApiRpdMessageType = msg.IT_API_RPD_GET_RCP_CFG try: reply = rpd_vm.vm_command(msg) if (reply and reply.result == reply.IT_API_RESULT_OK): RcpContent = t_RcpMessage() RcpContent.ParseFromString(reply.ItMsgPayload) BasicITs.logger.info("Got Rcp config:%s", RcpContent) return True except: pass return False
def test_recvCfgMsgCb(self): cfg = t_RcpMessage() cfg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION cfg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_READ # cfg.RpdMacAddress = "111111111111" payload = cfg.SerializeToString() print payload self.cfgMsg = HalMessage("HalConfig", SrcClientID="435qwert22", SeqNum=322, CfgMsgType=MsgTypeRpdInfo, CfgMsgPayload=payload) self.assertEqual(None, self.rpdinfo.recvCfgMsgCb(self.cfgMsg))
def test_recvCfgMsgCb(self): cfg = t_RcpMessage() cfg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION payload = cfg.SerializeToString() self.cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdRes", SeqNum=322, CfgMsgType=MsgTypeHostResources, CfgMsgPayload=payload) cfg_rsp_msg = HalMessage("HalClientRegisterRsp") cfg_rsp_msg.msg.Rsp.Status = 2 self.rpdhostres.recvRegisterMsgCb(cfg_rsp_msg) self.assertTrue(self.rpdhostres.disconnected) self.assertEqual(None, self.rpdhostres.recvCfgMsgCb(self.cfgMsg))
def test_readRpdState(self): rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = \ t_RpdDataMessage.RPD_CFG_READ cfg_payload = rcp_msg.SerializeToString() queryPtpMsg = HalMessage("HalConfig", SrcClientID="testMsgTypeRpdState", SeqNum=325, CfgMsgType=HalConfigMsg.MsgTypeRpdState, CfgMsgPayload=cfg_payload) self.hal_client.recvCfgMsgCb(queryPtpMsg) self.assertTrue( self.hal_client.ptp_result == t_GeneralNotification.PTPACQUIRE)
def reset_rpd_log(self, cfg): """reset rpd pending and local log.""" rcp_msg = t_RcpMessage() rcp_msg.ParseFromString(cfg.msg.CfgMsgPayload) if rcp_msg is None: return { "Status": HalCommon_pb2.FAILED, "ErrorDescription": "DeSerialize ConfigMsgPayload fail" } recv_rcp_msg = rcp_msg.RpdDataMessage.RpdData if recv_rcp_msg.HasField("RpdCtrl") and recv_rcp_msg.RpdCtrl.HasField( "LogCtrl"): if rcp_msg.RpdDataMessage.RpdDataOperation == t_RpdDataMessage.RPD_CFG_WRITE: ctrl_log = recv_rcp_msg.RpdCtrl.LogCtrl reset_log = ctrl_log.ResetLog self.clear_rpd_log(reset_log) rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK cfg.msg.CfgMsgPayload = rcp_msg.SerializeToString() return { "Status": HalCommon_pb2.SUCCESS, "ErrorDescription": "Get Rpd Control success" } elif rcp_msg.RpdDataMessage.RpdDataOperation == t_RpdDataMessage.RPD_CFG_READ: return { "Status": HalCommon_pb2.SUCCESS_IGNORE_RESULT, "ErrorDescription": "Operation %d for Rpd Log Control Can Be Ignored" % rcp_msg.RpdDataMessage.RpdDataOperation } else: return { "Status": HalCommon_pb2.FAILED, "ErrorDescription": "Operation %d for LogCtrl is not supported" % rcp_msg.RpdDataMessage.RpdDataOperation } else: return { "Status": HalCommon_pb2.SUCCESS_IGNORE_RESULT, "ErrorDescription": "Rcp Msg Do Not Have RpdCtrl Field" }
def test_staticGcppSession_CFG_WRITE_l2tpsessinfo_DB(self): sessRec = L2tpSessionRecord() sessRec.deleteAll() self.fwdCfg = StaticL2tpProvision() rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = \ t_RpdDataMessage.RPD_CFG_WRITE cfg_msg = rcp_msg.RpdDataMessage.RpdData staticPwConfig = cfg_msg.StaticPwConfig self.fwdCfg.add_usStaticSession(staticPwConfig, 12, False) self.fwdCfg.add_commStaticSession(staticPwConfig, 12, 0x80001112, 3, 32768, True) cfg_payload = rcp_msg.SerializeToString() staticL2tpMsg = HalMessage("HalConfig", SrcClientID="testGCPPL2Static", SeqNum=325, CfgMsgType=HalConfigMsg.MsgTypeGcppToL2tp, CfgMsgPayload=cfg_payload) self.hal_client.recvCfgMsgCb(staticL2tpMsg) # cfg 2nd CFG_WRITE msg self.fwdCfg.add_usStaticSession(staticPwConfig, 12, False) self.fwdCfg.add_commStaticSession(staticPwConfig, 12, 0x80001113, 3, 32768, True) cfg_payload = rcp_msg.SerializeToString() staticL2tpMsg = HalMessage("HalConfig", SrcClientID="testGCPPL2Static", SeqNum=325, CfgMsgType=HalConfigMsg.MsgTypeGcppToL2tp, CfgMsgPayload=cfg_payload) self.hal_client.recvCfgMsgCb(staticL2tpMsg) # check DB record sessRec = L2tpSessionRecord() retlist = sessRec.get_all() listlen = 0 for sessRecord in retlist: listlen = listlen + 1 self.assertEqual(listlen, 1) self.assertEqual(sessRecord.index.l2tpSessionId, 0x80001113)
def test_recvCfgMsgCb(self): rcp_msg = t_RcpMessage() rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = 2 payload = rcp_msg.SerializeToString() # test normal cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdFM", SeqNum=322, CfgMsgType=MsgTypetEventNotification, CfgMsgPayload=payload) self.fm.fault_ipc.recvCfgMsgCb(cfgMsg) # test Exception cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdFM", SeqNum=322, CfgMsgType=MsgTypetEventNotification + 1000, CfgMsgPayload=payload) self.fm.fault_ipc.recvCfgMsgCb(cfgMsg)
def _onlog_done(self, event): """Remote logging is enabled, let's open connections to CCAP cores and do all GCP/RCP related work, we cannot continue without any CCAP core address -> reboot. :param event: unused :return: """ del event # FIXME: add a ccap core for cmc temperary debug self.dhcp_data.CCAPCores.append("127.0.0.1") if len(self.dhcp_data.CCAPCores) == 0: self.logger.error("No CCAP cores found") self.fsm.fatal_failure() return # Notify RCP process about new CCAP cores rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = rcp_msg.ADD_CCAP_CORES rcp_msg.RedirectCCAPAddresses.extend(self.dhcp_data.CCAPCores) self.send_msg_to_rcp(rcp_msg)
def test_http_ctrl_hal_msg(self): print("case: test_http_ctrl_hal_msg") if not self.tftp_pid: self.tftp_pid = subprocess.Popen(self.start_tftp_cmd, executable='bash', shell=True) if self.crashCtrlHandler.is_upload_process_alive(): self.crashCtrlHandler.stop_upload_process() time.sleep(self.ONE_SECOND) self.assertEquals(self.crashCtrlHandler.is_upload_process_alive(), False) os.system("rm -rf /tmp/crash/*") for fileName in self.nameList: file_object = open(self.crashCtrlHandler.CORE_FILE_PATH + fileName, 'w') file_object.write(self.text) file_object.close() self.crashCtrlHandler.update_crash_file_table(None) for key in CrashFileStatusInfo.get_keys(): crashFileStatusInfo = CrashFileStatusInfo(key) crashFileStatusInfo.read() rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = \ t_RpdDataMessage.RPD_CFG_WRITE cfg_msg = config() rpdCtrl = cfg_msg.RpdCtrl dataFileCtrl = rpdCtrl.CrashDataFileCtrl.add() dataFileCtrl.Index = crashFileStatusInfo.index dataFileCtrl.FileControl = CrashFileCtrlHandler.CONTROL_UPLOAD rpdCtrl.CrashDataServerCtrl.DestIpAddress = "" rpdCtrl.CrashDataServerCtrl.DestPath = "/tmp/crash/" rpdCtrl.CrashDataServerCtrl.Protocol = CrashFileCtrlHandler.PROTOCOL_HTTP rcp_msg.RpdDataMessage.RpdData.CopyFrom(cfg_msg) cfg_payload = rcp_msg.SerializeToString() rdpCtrlMsg = HalMessage("HalConfig", SrcClientID="testRpdCtrlMsg", SeqNum=325, CfgMsgType=HalConfigMsg.MsgTypeRpdCtrl, CfgMsgPayload=cfg_payload) self.halClient.recvCfgMsgCb(rdpCtrlMsg)
def test_rcp_msg_cb_basic(self): print '############test rcp_msg_cb basic case#############' # seq==None self.agent.rcp_msg_cb(None) seq = t_RcpMessage() self.agent.rcp_msg_cb(seq) seq = RCPSequence(gcp_msg_def.DataStructREQ, rcp_tlv_def.RCP_MSG_TYPE_REX, 1, rcp_tlv_def.RCP_OPERATION_TYPE_READ, unittest=True) desc = GCPSlaveDescriptor( '1.1.1.1', port_master='8190', addr_local='1.1.1.2', interface_local='eth0', addr_family=socket.AF_INET) orch = self.agent.process.orchestrator session = RCPSlaveSession(desc, self.agent.process.dispatcher, orch.session_initiate_cb, orch.session_timeout_cb, orch.session_connecting_timeout_cb) self.agent.rcp_msg_cb(seq, (session, 'transaction_identifier', 'trans_id'))
def _ondhcp_ack(self, event): """DHCP data are ready, parse msg with info from DCHP client. (without checking if mandatory data are here - these are checked during initialization process) and start with next step - get & set system time :param event: unused :return: """ del event # DHCP data updated - remove old CCAP Cores and close connections rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = rcp_msg.REMOVE_ALL_CCAP_CORES self.send_msg_to_rcp(rcp_msg) # Clear DHCP data from DB, if there are any from previous DHCP Ack self.delete_dhcp_data() self._verify_dhcp_data() if len(self.dhcp_data.TimeServers) == 0: self.logger.error("No time servers found") self.fsm.fatal_failure() return is_ipv6 = Convert.is_valid_ipv6_address(self.dhcp_data.TimeServers[0]) # Prepare TPC runtime arguments args = ['--ipv6'] if is_ipv6 else [] args.extend(['--offset', str(self.dhcp_data.TimeOffset)]) args.extend(['--servers'] + [ addr.encode('ascii', 'ignore') for addr in self.dhcp_data.TimeServers ]) # Start TPC # (continue in tpc_msg_cb or timeout_cb specified in process info) self.processes['tpc'].start(self.tpc_msg_cb, args)
def test_set_global_conf(self): print '*' * 80 print 'test Global TLV handling' print '*' * 80 RpdEventConfig.event_config_file = "test.config" # construct RpdGlobal config cfg_global = config() # cfg = t_RpdGlobal() cfg = cfg_global.RpdGlobal for lvl, _ in rcp_tlv_def.RPD_EVENT_LEVEL: ctrl = cfg.EvCfg.EvControl.add() ctrl.EvPriority = lvl if lvl <= rcp_tlv_def.RPD_EVENT_LEVEL_ERROR[0]: ctrl.EvReporting = RpdEventConfig.LOCAL_MAK + RpdEventConfig.PENDING_MARK else: ctrl.EvReporting = RpdEventConfig.PENDING_MARK cfg.EvCfg.EvThrottleAdminStatus = rcp_tlv_def.RPD_EVENT_THROTTLE_BELOW[ 0] cfg.EvCfg.EvThrottleThreshold = 10 cfg.EvCfg.EvThrottleInterval = 10 cfg.EvCfg.NotifyEnable = 1 rcp_msg = t_RcpMessage() rcp_msg.RcpDataResult = t_RcpMessage.RCP_RESULT_OK rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION payload = rcp_msg.SerializeToString() print payload cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdFM", SeqNum=322, CfgMsgType=MsgTypeRpdGlobal, CfgMsgPayload=payload) cfgMsg.msg.CfgMsgPayload = rcp_msg.SerializeToString() self.fm.fault_ipc.set_global_conf(cfgMsg)
def test_recvRpdServerCtrlMsgCbRead(self): rcp_msg = t_RcpMessage() rcp_msg.RcpMessageType = t_RcpMessage.RPD_CONFIGURATION rcp_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_READ cfg_msg = config() rpdCtrl = cfg_msg.RpdCtrl rcp_msg.RpdDataMessage.RpdData.CopyFrom(cfg_msg) cfg_payload = rcp_msg.SerializeToString() self.cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdRes", SeqNum=322, CfgMsgType=MsgTypeRpdCtrl, CfgMsgPayload=cfg_payload) self.assertEqual(None, self.rpdhostres.recvCfgMsgCb(self.cfgMsg)) rpdCtrl = cfg_msg.RpdCtrl rcp_msg.RpdDataMessage.RpdData.CopyFrom(cfg_msg) cfg_payload = rcp_msg.SerializeToString() self.cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdRes", SeqNum=322, CfgMsgType=MsgTypeRpdState, CfgMsgPayload=cfg_payload) self.assertEqual(None, self.rpdhostres.recvCfgMsgCb(self.cfgMsg)) rpdCtrl = cfg_msg.RpdCtrl crashDataServerCtrl = rpdCtrl.CrashDataServerCtrl crashDataServerCtrl.DestIpAddress = "127.0.0.1" rcp_msg.RpdDataMessage.RpdData.CopyFrom(cfg_msg) cfg_payload = rcp_msg.SerializeToString() self.cfgMsg = HalMessage("HalConfig", SrcClientID="testRpdRes", SeqNum=322, CfgMsgType=MsgTypeRpdCtrl, CfgMsgPayload=cfg_payload) self.assertEqual(None, self.rpdhostres.recvCfgMsgCb(self.cfgMsg))