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 test_set_operational_mode(self):
led_msg = t_LED()
led_msg.setLed.ledType = led_msg.LED_TYPE_STATUS
led_msg.setLed.color = led_msg.LED_COLOR_GREEN
led_msg.setLed.action = led_msg.LED_ACTION_LIT
payload = led_msg.SerializeToString()
cfgMsg = HalMessage("HalConfig",
SrcClientID="testRpdFM",
SeqNum=322,
CfgMsgType=MsgTypeSetLed,
CfgMsgPayload=payload)
self.fm.fault_ipc.set_operational_mode(cfgMsg.msg.CfgMsgPayload)
led_msg.setLed.action = led_msg.LED_ACTION_DARK
payload = led_msg.SerializeToString()
cfgMsg = HalMessage("HalConfig",
SrcClientID="testRpdFM",
SeqNum=322,
CfgMsgType=MsgTypeSetLed,
CfgMsgPayload=payload)
self.fm.fault_ipc.set_operational_mode(cfgMsg.msg.CfgMsgPayload)
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 test_lcceId_bad_recvCfgMsgRspCb_NOTSUUPPORT(self):
self.conn.fsm.recvGoodSCCRQ()
self.conn.fsm.recvGoodSCCCN()
rsp = L2tpv3Hal_pb2.t_l2tpLcceAssignmentReq()
rsp.lcce_id = self.conn.localConnID
rsp.lcce_info.local_ip = "10.79.41.138"
rsp.lcce_info.remote_ip = "10.79.41.139"
rsp.lcce_info.local_mac = L2tpHalClient.get_mac_of_ip(rsp.lcce_info.local_ip)
rsp.lcce_info.remote_mac = L2tpHalClient.get_mac_of_ip(rsp.lcce_info.remote_ip)
rsp.lcce_info.mtu = 2342
rsp.msg_type = L2tpv3Hal_pb2.t_l2tpLcceAssignmentReq.ADD_L2TPv3_LCCE
payload = rsp.SerializeToString()
msg = HalMessage("HalConfigRsp", SrcClientID="123", SeqNum=3,
Rsp={
"Status": HalCommon_pb2.NOTSUPPORTED,
"ErrorDescription": ""
},
CfgMsgType=HalConfigMsg.MsgTypeL2tpv3LcceIdAssignment,
CfgMsgPayload=payload)
ret = self.hal_client.recvCfgMsgRspCb(msg)
self.assertFalse(ret)
# case exception
fake_msg = HalMessage("HalClientRegisterRsp",
Rsp={
"Status": HalCommon_pb2.NOTSUPPORTED,
"ErrorDescription": ""
},
ClientID="214")
ret = self.hal_client.recvCfgMsgRspCb(cfg=fake_msg)
self.assertFalse(ret)
def sendNotificationMsg(self, notificationType, notificationPayload):
"""Send a notification to Hal.
:param notificationType: The notification type, the client must
declare the notification type to Hal first
:param notificationPayload: the string payload, Hal will not touch
this part
:return:
"""
self.logger.debug("send a a notification message to Hal")
if self.disconnected:
self.logger.warning(
"The client is on disconnected state,"
" skip to send the message, notification type:%s",
notificationType)
return
if notificationType is None or not isinstance(notificationPayload,
str):
self.logger.warning("Cannot send a None or incorrect type to HAL, "
"str is required for msg.")
return
notification = HalMessage("HalNotification",
ClientID=self.drvID,
HalNotificationType=notificationType,
HalNotificationPayLoad=notificationPayload)
self.send(notification.Serialize())
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 cfgMsgTimeoutCb(self, args):
"""
:param args: the callback parameters, we need the srcClient agent, original message
:return:
"""
agent = args["agent"]
cfgMsg = args["originalMsg"].msg
self.logger.warn(
"Send a timeout message to client [%s] for message %s" %
(agent.clientID, cfgMsg))
seqNum = cfgMsg.SeqNum if hasattr(cfgMsg, "SeqNum") else 0
msg = HalMessage(
"HalConfigRsp",
SrcClientID=cfgMsg.SrcClientID,
SeqNum=seqNum,
Rsp={
"Status":
HalCommon_pb2.TIMEOUT,
"ErrorDescription":
'timeout happened when sending the msg to dstClient, is dstClient dead :(?'
},
CfgMsgType=cfgMsg.CfgMsgType,
CfgMsgPayload=cfgMsg.CfgMsgPayload)
# Do some stats here
agent.stats.NrErrorMsgs += 1
agent.stats.NrCfgRspMsgs += 1
agent.stats.NrTimeoutMsgs += 1
agent.transportPush.send(msg.Serialize())
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 sendHalMsg(self, cfgMsg):
hal_ipc = self.cli.hal_ipc
if hal_ipc.disconnected:
hal_ipc.logger.error("The client is on disconencted state,"
"skip to send the message.")
return
if cfgMsg is None:
hal_ipc.logger.error("Cannot send a None or incorrect type to HAL")
return
for desc, value in cfgMsg.ListFields():
if desc.name not in self.CfgMsgId_dict:
hal_ipc.logger.error("Cannot not find %s" % desc.name)
return
msg = HalMessage("HalConfig",
SrcClientID=hal_ipc.clientID,
SeqNum=hal_ipc.seqNum,
CfgMsgType=self.CfgMsgId_dict[desc.name],
CfgMsgPayload=cfgMsg.SerializeToString())
hal_ipc._send(msg.Serialize())
seq = hal_ipc.seqNum
hal_ipc.seqNum += 1
return seq
def register(self, driverID):
"""Send a register message to Hal and get the client ID from the Hal.
:return:
"""
if driverID is None:
registerMsg = HalMessage(
"HalClientRegister",
ClientName=self.drvname,
ClientDescription=self.drvDesc,
ClientVersion=self.drvVer,
ClientSupportedMessages=self.supportedMsgType,
ClientSupportedNotificationMessages=self.
supportedNotificationMsgs)
else:
registerMsg = HalMessage(
"HalClientRegister",
ClientName=self.drvname,
ClientDescription=self.drvDesc,
ClientVersion=self.drvVer,
ClientSupportedMessages=self.supportedMsgType,
ClientSupportedNotificationMessages=self.
supportedNotificationMsgs,
ClientID=driverID)
if self.mgrConnection is None:
errMsg = "Cannot send the register since the mgr connection is not setup"
self.logger.error(errMsg)
raise HalDriverClientError(errMsg)
self.logger.debug("Send the register msg to Hal...")
self.mgrConnection.send(registerMsg.Serialize())
def sendCfgMsg(self, cfgMsgType, cfgMsgContent):
"""The configutaion response routine, the driver implementor should
fill sth into this function.
:param cfg: The original configuration message
:return:
"""
self.logger.debug("Send a config message to HAL: %r", cfgMsgContent)
if self.disconnected:
self.logger.warn(
"The client is on disconencted state, skip to send the message."
)
return
if cfgMsgContent is None or not isinstance(cfgMsgContent, str):
self.logger.error(
"Cannot send a None or incorrect type to HAL, str is required for msg"
)
return
msg = HalMessage("HalConfig",
SrcClientID=self.drvID,
SeqNum=self.seqNum,
CfgMsgType=cfgMsgType,
CfgMsgPayload=cfgMsgContent)
self._sendMsg(msg.Serialize())
seq = self.seqNum
self.seqNum += 1
return seq
def test_Deserialize(self):
"""test HalMessage#DeSerialize,
check the string message can't be
deserialized, if not case fail
check the unnormal binary HalMessage
can't be deserialized, if not case fail.
:keyword:HalMessage#DeSerialize
:exception:"The input binary is None",
"Cannot parse the message since the msgType"
:parameter:
:return:
"""
try:
mas = HalMessage.DeSerialize("a")
except Exception as e:
self.assertEqual("The input binary is None", str(e))
try:
msg = HalMessage.DeSerialize(
"00000))))))00000))))))00000))))))00000))))))00000))))))00000))))))00000)))))"
")00000))))))00000))))))")
except Exception as e:
self.assertEqual(
str(e).startswith(
"Cannot parse the message since the msgType"), True)
def sendMsg(self, cfgMsg):
"""
The configutaion response routine, the driver implementor should fill
sth into this function
:param cfg: The original configutaion message
:return:
"""
if self.disconnected:
self.logger.error("The client is on disconencted state,"
" skip to send the message.")
return
if cfgMsg is None or not isinstance(cfgMsg, t_CliMessage):
self.logger.error("Cannot send a None or incorrect type to HAL")
return
for desc, value in cfgMsg.CliData.ListFields():
if desc.name not in self.CfgMsgId_dict:
self.logger.error("Cannot not find %s" % desc.name)
return
msg = HalMessage("HalConfig", SrcClientID=self.clientID,
SeqNum=self.seqNum,
CfgMsgType=self.CfgMsgId_dict[desc.name],
CfgMsgPayload=cfgMsg.SerializeToString())
self._send(msg.Serialize())
seq = self.seqNum
self.seqNum += 1
return seq
def dispatchCfgMessage(self, sendAgent, cfg):
"""Dispatch the client cfg msg.
:param sendAgent: the agent that sends the configuration message.
:param cfg: the HalMessage type.
:return: -1 for error, should add it to resend list;
0 for normal process
"""
# check the CfgMsgType and routing it to the correct dstClient
cfgMsg = cfg.msg
if cfg.msg.CfgMsgType not in HalGlobal.gMsgTypeClientMapping:
self.logger.warn(
"There is no client support this config message currently, will resend it later: %s.",
cfgMsg)
sendAgent.stats.NrErrorMsgs += 1 # the message cannot be supported, will resend it later
return -1
agent_list = HalGlobal.gMsgTypeClientMapping[cfgMsg.CfgMsgType]
cfgMsg.SeqNum = cfgMsg.SeqNum if cfgMsg.HasField("SeqNum") else 0
cfgMsg.SrcClientID = sendAgent.clientID
for agent_obj in agent_list:
agent = agent_obj["agent"]
if agent is sendAgent:
self.logger.warn("agent %s: Cannot send seq %d to itself",
agent.clientID, cfgMsg.SeqNum)
msg = HalMessage("HalConfigRsp",
SrcClientID=cfgMsg.SrcClientID,
SeqNum=cfgMsg.SeqNum,
Rsp={
"Status":
HalCommon_pb2.FAILED,
"ErrorDescription":
'Cannot send configuration msg to itself'
},
CfgMsgType=cfgMsg.CfgMsgType,
CfgMsgPayload=cfgMsg.CfgMsgPayload)
agent.transportPush.send(msg.Serialize())
continue
client_id = agent_obj["clientID"]
cfgMsg.DstClientID = client_id
# we should rewrite the srcClientID
agent.transportPush.send(cfg.Serialize())
sendAgent.addToRuntimeObjList(cfgMsg.SeqNum, sendAgent.timeout,
(self.cfgMsgTimeoutCb, {
"agent": sendAgent,
"originalMsg": cfg
}))
agent.stats.NrCfgMsgs += 1
self.logger.debug(
"Dispatching the msg[%d] from srcClient[%s] to dstClient[%s]" %
(cfgMsg.CfgMsgType, cfgMsg.SrcClientID, cfgMsg.DstClientID))
return 0
def sayHelloToHal(self):
"""
Send a hello message to verify the agent path is correct
:return:
"""
self.logger.debug("Send a Hello message to Hal")
helloMsg = HalMessage("HalClientHello", ClientID=self.clientID)
self._send(helloMsg.Serialize())
def send_cfg_msg(self, cfgMsgType, payload):
msg = HalMessage("HalConfig",
SrcClientID=self.drvID,
CfgMsgType=cfgMsgType,
SeqNum=self.seqNum,
CfgMsgPayload=payload)
self.logger.debug("sending config - type: %d, msg: %s" %
(cfgMsgType, msg))
self.pushSock.send(msg.Serialize())
self.seqNum += 1
return
def sayHelloToHal(self):
"""Send a hello message to verify the agent path is correct.
:return:
"""
self.logger.debug(" ".join([
str(self.drvname),
str(self.drvID), ":Send a Hello message to Hal"
]))
helloMsg = HalMessage("HalClientHello", ClientID=self.drvID)
self.send(helloMsg.Serialize())
def processResendList(self, test=False):
"""go through the resend list, find the timeout ones and send a
unsupported message to client.
for the un-timeout ones, we will send the message to the dispatcher, if the dispatch successfully process the
message, we will remove from the list
:return:
"""
if len(self.resendList) <= 0:
return
self.logger.debug(
"Process the resend list, and send the msg to driver")
removeList = list()
for i in xrange(len(self.resendList)):
msg = self.resendList[i]
seq = msg["seq"]
if msg["time"] < time():
# send a timeout msg to the original sender
cfgMsg = msg["msg"].msg
unSupportedMsg = HalMessage(
"HalConfigRsp",
SrcClientID=cfgMsg.SrcClientID,
SeqNum=seq,
Rsp={
"Status":
HalCommon_pb2.NOTSUPPORTED,
"ErrorDescription":
'No Driver can handle this message, please check '
'if the driver has registered, or if the registered'
' driver can supported this message type'
},
CfgMsgType=cfgMsg.CfgMsgType,
CfgMsgPayload=cfgMsg.CfgMsgPayload)
if not test:
msg["sendAgent"].transportPush.send(
unSupportedMsg.Serialize())
removeList.append(msg)
continue
# invoke dispatcher
ret = HalGlobal.gDispatcher.dispatchCfgMessage(
msg["sendAgent"], msg["msg"])
if ret == 0:
removeList.append(msg)
# Process the removeList
for msg in removeList:
self.resendList.remove(msg)
def sendNotificationMsg(self, notificationType, notificationPayload):
"""Send a notification to Hal.
:param notificationType: The notification type, the client must declare the notification type to Hal first
:param notificationPayload: the string payload, Hal will not touch this part
:return:
"""
self.logger.debug("send a a notification message to Hal")
notfication = HalMessage("HalNotification",
ClientID=self.drvID,
HalNotificationType=notificationType,
HalNotificationPayLoad=notificationPayload)
self.send(notfication.Serialize())
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_cfgMsgTimeoutCb(self):
"""Construct client agent msg and original msg."""
try:
self.clientMgr.handleRegisterRequest(None)
except Exception as e:
self.assertEqual(
"Cannot handle the client register "
"request since the register msg is None", str(e))
# Create a client msg
agent = HalAgentClient(self.poller,
clientID="123",
disconnectHandler=None,
reuseIndex=None)
# Create a original message
oricfgMsg = HalMessage("HalConfig",
SrcClientID="123",
SeqNum=33,
CfgMsgType=1,
CfgMsgPayload="test HalDispatcher")
# Test cfgMsgTimeoutCb
currentErrorMsgs = HalGlobalStats.NrErrorMsgs
self.halDispatcher.cfgMsgTimeoutCb(
args={"agent": agent, "originalMsg": oricfgMsg})
self.assertEqual(HalGlobalStats.NrErrorMsgs, currentErrorMsgs + 1)
def openrpd_drv_hal_cb(self, sock, mask):
self.logger.debug("Driver received hal cb event")
if self.pushSock is not None and sock == self.pushSock.monitor:
self.pushSock.monitorHandler(recv_monitor_message(sock))
return
if self.pullSock is not None and sock == self.pullSock.monitor:
self.pullSock.monitorHandler(recv_monitor_message(sock))
return
if sock == self.mgrConnection.monitor:
self.mgrConnection.monitorHandler(recv_monitor_message(sock))
return
while sock.getsockopt(zmq.EVENTS) and zmq.POLLIN:
try:
bin = sock.recv(flags=zmq.NOBLOCK)
msg = HalMessage.DeSerialize(bin)
self.logger.debug("Got a zmq msg:%s type:%s" %
(msg.msg, msg.type))
if msg.type in self.HalMsgsHandler:
handler = self.HalMsgsHandler[msg.type]
handler(msg)
except zmq.ZMQError as e:
self.logger.debug(
"Got an error when trying with nonblock read:" + str(e))
break
except Exception as e:
self.logger.error("Got an un-expected error:%s", str(e))
break
def fault_management_cb(self, sock, mask): # pragma: no cover
"""Fault management callback.
:param sock: zmq socket
:param mask: event mask
:return:
"""
if self.pushSock is not None and sock == self.pushSock.monitor:
self.pushSock.monitorHandler(recv_monitor_message(sock))
return
if self.pullSock is not None and sock == self.pullSock.monitor:
self.pullSock.monitorHandler(recv_monitor_message(sock))
return
if self.mgrConnection is not None and sock == self.mgrConnection.monitor:
self.mgrConnection.monitorHandler(recv_monitor_message(sock))
return
while sock.getsockopt(zmq.EVENTS) and zmq.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)
except zmq.ZMQError as e:
self.logger.debug(
"Getting an error when trying with nonblock read:" +
str(e))
break
except Exception as e:
self.logger.error("Error happens, reason:%s" % str(e))
break
def test_HandleUnnormalConfigRsp(self):
"""test the method of halAgentClient#HandleConfigRsp check the
HalConfigRsp HalMessage can be handle with specific exception, once
catch the error message, case pass.
:keyword:halAgentClient#HandleConfigRsp
:exception:"Cannot create a msg since we can not find the msg definition"
"""
try:
self.halAgentClient.handleConfigRsp(None)
except Exception as e:
self.assertEqual(str(e),
"Cannot handle a none config response message")
# try:
tmp = HalGlobalStats.NrErrorMsgs
cfgMsg = HalMessage("HalConfigRsp",
SrcClientID="0123456789",
SeqNum=0,
Rsp={
"Status": HalCommon_pb2.FAILED,
"ErrorDescription": "test"
},
CfgMsgType=123,
CfgMsgPayload="Hello")
self.halAgentClient.handleConfigRsp(cfgMsg)
self.assertEqual(HalGlobalStats.NrErrorMsgs, tmp + 1)
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 provmgr_cb(self, sock, mask):
if self.pushSock is not None and sock == self.pushSock.monitor:
self.pushSock.monitorHandler(recv_monitor_message(sock))
return
if self.pullSock is not None and sock == self.pullSock.monitor:
self.pullSock.monitorHandler(recv_monitor_message(sock))
return
if self.mgrConnection is not None and sock == self.mgrConnection.monitor:
self.mgrConnection.monitorHandler(recv_monitor_message(sock))
return
while sock.getsockopt(zmq.EVENTS) and zmq.POLLIN:
try:
bin = sock.recv(flags=zmq.NOBLOCK)
msg = HalMessage.DeSerialize(bin)
if msg.type in self.HalMsgsHandler:
handler = self.HalMsgsHandler[msg.type]
handler(msg)
except zmq.ZMQError as e:
self.logger.debug(
"Got an error when trying with non-block read:" + str(e))
break
except Exception as e:
self.logger.warn(
"Exception happens when provmgr hal recv socket, reason:%s"
% str(e))
break
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 sendInterestedNotifications(self, notifications):
"""
Send the notifications to the HAL
:param notifications:
:return:
"""
self.logger.debug("Send a Interested notification configuration msg to HAL")
if notifications is not None and not isinstance(notifications, tuple) and not isinstance(notifications, list):
self.logger.error("Cannot set an notification with wrong type, you can pass a tuple or list to it ")
return
configMsg = HalMessage("HalClientInterestNotificationCfg", ClientID=self.clientID,
ClientNotificationMessages=notifications)
self.mgrConnection.send(configMsg.Serialize())
# REQ/RSP
bin = self.mgrConnection.recv()
return bin
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 test_GCPP_recvCfgMsgRspCb_FAILED(self):
self.fwdCfg = StaticL2tpProvision()
staticPwCfg = StaticPwConfig_pb2.t_StaticPwConfig()
self.fwdCfg.add_commStaticSession(staticPwCfg, 11, 0x80001111, 3,
32768, False)
self.fwdCfg.add_dsStaticSession(staticPwCfg, 11, False, False)
ses = StaticL2tpSession(11)
ses.updateFwdStaticPseudowire(staticPwCfg)
ses.updateComStaticPseudowire(staticPwCfg)
ses.write()
self.assertTrue(self.fwdCfg.check_StaticSession(staticPwCfg, ses))
rsp = L2tpv3Hal_pb2.t_l2tpSessionRsp()
rsp.session_selector.local_ip = \
L2tpv3GcppSession.L2tpv3GcppProvider.getLocalIp(
"127.0.0.1")
rsp.session_selector.remote_ip = "127.0.0.1"
rsp.session_selector.lcce_id = 0
rsp.session_selector.local_session_id = 0x80001111
rsp.session_selector.remote_session_id = 0x80001111
rsp.result = True
payload = rsp.SerializeToString()
msg = HalMessage("HalConfigRsp", SrcClientID="123", SeqNum=2,
Rsp={"Status": HalCommon_pb2.FAILED,
"ErrorDescription": ""},
CfgMsgType=HalConfigMsg.MsgTypeL2tpv3SessionReqUsAtdma,
CfgMsgPayload=payload)
ret = self.hal_client.recvCfgMsgRspCb(msg)
self.assertFalse(ret)
