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