def test_msg_dispatch_coreident_read(self):
print("########test_msg_dispatch_null_coreident_read##########")
try:
self.process.send_ipc_msg('error')
except SystemExit as e:
self.assertEqual(e.code, EX_DATAERR)
data_list = []
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_READ,
unittest=True)
sub_tlv = seq.CcapCoreIdentification.add_new_repeated()
seq.ipc_msg = None
data_list.append(seq)
self.process.hal_ipc.disconnected = False
self.process.hal_ipc.clientID = '12345'
self.process.send_ipc_msg({
"session": self.session,
"req_packet": 'tmp',
"gcp_msg": "tmp",
"req_data": data_list
})
def construct_eds_pkt_CcapCoreIdentification_AW(inital=CORE_STATE_INIT):
seq = None
# Set RCP sequence
if inital == TestOrchestrator.CORE_STATE_INIT:
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA, 0xffff,
rcp_tlv_def.RCP_OPERATION_TYPE_ALLOCATE_WRITE)
ccap = seq.parent_gpb.CcapCoreIdentification.add()
ccap.Index = 0
ccap.IsPrincipal = True
ccap.CoreMode = 1
ccap.CoreId = 'CoreId'
ccap.CoreIpAddress = '1.1.1.1'
ccap.CoreName = 'CoreName'
ccap.VendorId = 12
elif inital == TestOrchestrator.CORE_STATE_CFG_COMPLETE:
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA, 0xffff,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
ccap = seq.parent_gpb.CcapCoreIdentification.add()
ccap.Index = 1
ccap.InitialConfigurationComplete = True
elif inital == TestOrchestrator.CORE_STATE_MOVE_TO_OPTIONAL:
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA, 0xffff,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
ccap = seq.parent_gpb.CcapCoreIdentification.add()
ccap.Index = 1
ccap.MoveToOperational = True
else:
return
rcp_msg = RCPMessage(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA)
rcp_msg.sequences.append(seq)
gcp_msg = Message(gcp_msg_def.DataStructREQ)
# TODO implement correct setting of message fields
transaction_id = 0xffff
gcp_msg.msg_fields.TransactionID.set_val(transaction_id)
gcp_msg.msg_fields.Mode.set_val(0)
gcp_msg.msg_fields.Port.set_val(11)
gcp_msg.msg_fields.Channel.set_val(111)
gcp_msg.msg_fields.VendorID.set_val(1111)
gcp_msg.msg_fields.VendorIndex.set_val(254)
gcp_msg.tlv_data.rcp_msgs.append(rcp_msg)
pkt = RCPPacket()
pkt.transaction_identifier = transaction_id
pkt.protocol_identifier = RCP_PROTOCOL_ID
pkt.unit_id = 0
pkt.msgs.append(gcp_msg)
return [pkt, gcp_msg]
def test_fast_decode2(self):
for _ in range(0, X):
for buf in data_ira:
rcp_message_id = rcp_tlv_def.RCP_MSG_TYPE_IRA
rcp_seq = RCPSequence(gcp_msg_def.ManagementREQ,
rcp_message_id, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_NONE)
rcp_seq.buffer = buf
parent_fmt = rcp_tlv_def.RCP_SEQ_RCP_MSG_TLV_SET_MAPPING[
rcp_message_id]
parent_gpb = config()
ret = rcp_seq._fast_decode2(parent_fmt, parent_gpb, 0,
len(buf), 0)
self.assertEqual(ret, gcp_object.GCPObject.DECODE_DONE)
for buf in data_rex:
rcp_message_id = rcp_tlv_def.RCP_MSG_TYPE_REX
rcp_seq = RCPSequence(gcp_msg_def.ManagementREQ,
rcp_message_id, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_NONE)
rcp_seq.buffer = buf
parent_fmt = rcp_tlv_def.RCP_SEQ_RCP_MSG_TLV_SET_MAPPING[
rcp_message_id]
parent_gpb = config()
ret = rcp_seq._fast_decode2(parent_fmt, parent_gpb, 0,
len(buf), 0)
self.assertEqual(ret, gcp_object.GCPObject.DECODE_DONE)
def test_msg_with_tlvs_of_all_classes_only_subTLV(self):
seq = RCPSequence(gcp_msg_def.NotifyError,
rcp_tlv_def.RCP_MSG_TYPE_NTF,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('ABC')
msg = Message(gcp_msg_def.NotifyError)
rcp_msg = RCPMessage(gcp_msg_def.NotifyError,
rcp_tlv_def.RCP_MSG_TYPE_NTF)
msg.tlv_data.rcp_msgs.append(rcp_msg)
rcp_msg.sequences.append(seq)
msg.msg_fields.TransactionID.set_val(5)
msg.msg_fields.ReturnCode.set_val(
gcp_msg_def.GCP_RC_MESSAGE_FAILURE.rc)
buf = msg.encode()
self.assertIsNotNone(buf)
buf_str = binascii.hexlify(buf)
# C_RpdCapabilities_2 C2_RpdIdentification_19
vendor_name_pattern = "010003414243"
self.assertNotEqual(buf_str.find(vendor_name_pattern), -1)
def setUp(self):
create_db_conf()
start_redis()
RCPDB.DB_CFG_FILE = CONF_FILE
setup_logging(("PROVISION", "GCP"), filename="provision_rcp.log")
self.agent = RcpOverGcp()
self.agent.ccap_cores['CORE-1234567890'] = {"mgr": "MGR-1234567890", }
self.agent.rcp[('eth0', '1.1.1.1')] = {
"status": self.agent.DOWN,
"requester": ['CORE-1234567890', ],
"lastChangeTime": 1,
}
path = "ipc:///tmp/rcp.sock"
transport = Transport(
path, Transport.PUSHSOCK, Transport.TRANSPORT_CLIENT)
# Add the fsm to our internal database
self.agent.mgrs["MGR-1234567890"] = {
"transport": transport,
"name": "RCP",
"para": {},
"path": path,
}
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
1,
rcp_tlv_def.RCP_OPERATION_TYPE_READ,
unittest=True)
self.agent.rcp_req_group[(1, '1.1.1.1')] = (seq, None, 'transaction_identifier', 'trans_id', time.time() - 5)
def construct_eds_pkt_RpdGlobal():
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA, 0xffff,
rcp_tlv_def.RCP_OPERATION_TYPE_READ)
# Set RCP sequence
ctrl = seq.parent_gpb.RpdGlobal.EvCfg.EvControl.add()
ctrl.EvPriority = 1
ctrl.EvReporting = 1
rcp_msg = RCPMessage(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA)
rcp_msg.sequences.append(seq)
gcp_msg = Message(gcp_msg_def.DataStructREQ)
# TODO implement correct setting of message fields
transaction_id = 0xffff
gcp_msg.msg_fields.TransactionID.set_val(transaction_id)
gcp_msg.msg_fields.Mode.set_val(0)
gcp_msg.msg_fields.Port.set_val(11)
gcp_msg.msg_fields.Channel.set_val(111)
gcp_msg.msg_fields.VendorID.set_val(1111)
gcp_msg.msg_fields.VendorIndex.set_val(254)
gcp_msg.tlv_data.rcp_msgs.append(rcp_msg)
pkt = RCPPacket()
pkt.transaction_identifier = transaction_id
pkt.protocol_identifier = RCP_PROTOCOL_ID
pkt.unit_id = 0
pkt.msgs.append(gcp_msg)
return [pkt, gcp_msg]
def construct_eds_pkt_ActivePrincipalCore():
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA, 0xffff,
rcp_tlv_def.RCP_OPERATION_TYPE_READ)
seq.parent_gpb.ActivePrincipalCore = '1.1.1.1'
rcp_msg = RCPMessage(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA)
rcp_msg.sequences.append(seq)
gcp_msg = Message(gcp_msg_def.DataStructREQ)
# TODO implement correct setting of message fields
transaction_id = 0xffff
gcp_msg.msg_fields.TransactionID.set_val(transaction_id)
gcp_msg.msg_fields.Mode.set_val(0)
gcp_msg.msg_fields.Port.set_val(11)
gcp_msg.msg_fields.Channel.set_val(111)
gcp_msg.msg_fields.VendorID.set_val(1111)
gcp_msg.msg_fields.VendorIndex.set_val(254)
gcp_msg.tlv_data.rcp_msgs.append(rcp_msg)
pkt = RCPPacket()
pkt.transaction_identifier = transaction_id
pkt.protocol_identifier = RCP_PROTOCOL_ID
pkt.unit_id = 0
pkt.msgs.append(gcp_msg)
return [pkt, gcp_msg]
def test_msg_with_tlvs_of_multi_core(self):
# Encode message with mandatory fields, decode buffer and compare objs
msg = Message(gcp_msg_def.DataStructError)
msg.msg_fields.TransactionID.set_val(5)
msg.msg_fields.ExceptionCode.set_val(
gcp_msg_def.GCP_RC_MESSAGE_FAILURE.rc)
seq = RCPSequence(gcp_msg_def.DataStructError,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
rcp_msg = RCPMessage(gcp_msg_def.DataStructError,
rcp_tlv_def.RCP_MSG_TYPE_REX)
msg.tlv_data.rcp_msgs.append(rcp_msg)
rcp_msg.sequences.append(seq)
resSet = seq.MultiCore.ResourceSet.add_new_repeated()
resSet.ResourceSetIndex.set_val(1)
resSet.CcapCoreOwner.set_val(
utils.Convert.mac_to_tuple_of_bytes("00:00:00:00:00:00"))
resSet.DsRfPortStart.set_val(0)
resSet.DsRfPortEnd.set_val(0)
dsChanGroup = resSet.DsChanGroup.add_new_repeated()
dsChanGroup.DsChanGroupIndex.set_val(1)
dsChanGroup.DsChanType.set_val(3)
dsChanGroup.DsChanIndexStart.set_val(0)
dsChanGroup.DsChanIndexEnd.set_val(10)
dsChanGroup = resSet.DsChanGroup.add_new_repeated()
dsChanGroup.DsChanGroupIndex.set_val(2)
dsChanGroup.DsChanType.set_val(4)
dsChanGroup.DsChanIndexStart.set_val(11)
dsChanGroup.DsChanIndexEnd.set_val(12)
resSet.UsRfPortStart.set_val(0)
resSet.UsRfPortEnd.set_val(1)
usChanGroup = resSet.UsChanGroup.add_new_repeated()
usChanGroup.UsChanGroupIndex.set_val(0)
usChanGroup.UsChanType.set_val(5)
usChanGroup.UsChanIndexStart.set_val(0)
usChanGroup.UsChanIndexEnd.set_val(2)
usChanGroup = resSet.UsChanGroup.add_new_repeated()
usChanGroup.UsChanGroupIndex.set_val(1)
usChanGroup.UsChanType.set_val(6)
usChanGroup.UsChanIndexStart.set_val(3)
usChanGroup.UsChanIndexEnd.set_val(4)
buf = msg.encode()
self.assertNotEqual(buf, None)
msg_dec = Message(gcp_msg_def.DataStructError)
self.assertEqual(msg_dec.decode(buf, offset=0, buf_data_len=len(buf)),
msg_dec.DECODE_DONE)
def test_tlv_data(self):
print "Test test_tlv_data...."
seq = RCPSequence(gcp_msg_def.NotifyREQ, rcp_tlv_def.RCP_MSG_TYPE_NTF,
1234, rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
print "Test test_tlv_data...."
seq.RpdCapabilities.NumBdirPorts.set_val(4)
alloc_ds =\
seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
alloc_ds.DsPortIndex.set_val(1)
alloc_ds.AllocatedDsOfdmChannels.set_val(11)
alloc_ds.AllocatedDsScQamChannels.set_val(111)
alloc_ds = \
seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
alloc_ds.DsPortIndex.set_val(2)
alloc_ds.AllocatedDsOfdmChannels.set_val(22)
alloc_ds.AllocatedDsScQamChannels.set_val(222)
alloc_ds = \
seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
alloc_ds.DsPortIndex.set_val(3)
alloc_ds.AllocatedDsOfdmChannels.set_val(33)
alloc_ds.AllocatedDsScQamChannels.set_val(333)
buf = seq.encode()
self.assertIsNotNone(buf)
seq_dec = RCPSequence(gcp_msg_def.NotifyREQ,
rcp_tlv_def.RCP_MSG_TYPE_NTF, 11,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
self.assertEqual(seq_dec.decode(buf, offset=0, buf_data_len=len(buf)),
seq_dec.DECODE_DONE)
def test_msg_with_unexpected_tlvs(self):
# Encode message with mandatory fields, decode buffer and compare objs
msg = Message(gcp_msg_def.NotifyREQ)
seq = RCPSequence(gcp_msg_def.NotifyREQ, rcp_tlv_def.RCP_MSG_TYPE_NTF,
123, rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
rcp_msg = RCPMessage(gcp_msg_def.NotifyREQ,
rcp_tlv_def.RCP_MSG_TYPE_NTF)
msg.tlv_data.rcp_msgs.append(rcp_msg)
rcp_msg.sequences.append(seq)
# Try to fill TLV, which is not expected
with self.assertRaises(AttributeError):
seq.CcapCoreIdentification.Index.set_val(6)
def test_fuzzing_fast_decode2(self):
if ENABLE_FUZZING <= 0:
return
class Logger:
def error(self, *args):
pass
def warn(self, *args):
pass
for n in [0, 0xFF] + range(
1, 0xFE): # run edge cases, then intermediate values
for ref_data in data_ira + data_rex + data_ntf:
l = len(ref_data)
for i in reversed(range(0, l)):
buf = ref_data[:] # copy data
buf[i] = n # mutate
# Decode
rcp_message_id = rcp_tlv_def.RCP_MSG_TYPE_REX
rcp_seq = RCPSequence(gcp_msg_def.ManagementREQ,
rcp_message_id, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_NONE)
rcp_seq.buffer = buf
rcp_seq.logger = Logger()
parent_fmt = rcp_tlv_def.RCP_SEQ_RCP_MSG_TLV_SET_MAPPING[
rcp_message_id]
parent_gpb = config()
#print(n, i)
ret = rcp_seq._fast_decode2(parent_fmt, parent_gpb, 0,
len(buf), 0)
#if ret is gcp_object.GCPObject.DECODE_FAILED:
# print(n, i)
self.assertTrue(ret in [
gcp_object.GCPObject.DECODE_DONE,
gcp_object.GCPObject.DECODE_FRAGMENTED
])
def create_cfg_read_sequence():
seq = RCPSequence(gcp_msg_def.DataStructREQ, rcp_tlv_def.RCP_MSG_TYPE_IRA,
0, rcp_tlv_def.RCP_OPERATION_TYPE_READ)
# seq.RpdCapabilities.set_is_used()
# seq.RpdCapabilities.NumBdirPorts.set_is_used()
# seq.RpdCapabilities.NumAsyncVideoChannels.set_is_used()
seq.RpdCapabilities.NumBdirPorts.set_val(1)
# seq.RpdCapabilities.RpdIdentification.VendorName.set_val('31')
# seq.RpdCapabilities.RpdIdentification.VendorId.set_val('32')
# seq.RpdCapabilities.RpdIdentification.DeviceMacAddress.set_val(
# (0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56))
# seq.RpdCapabilities.RpdIdentification.SerialNumber.set_val('33')
return seq
def test_tlv_data_repeated_negative(self):
seq = RCPSequence(gcp_msg_def.NotifyREQ, rcp_tlv_def.RCP_MSG_TYPE_NTF,
1, rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
seq.RpdCapabilities.NumBdirPorts.set_val(4)
seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
buf = seq.encode()
self.assertIsNotNone(buf)
seq_dec = RCPSequence(gcp_msg_def.NotifyREQ,
rcp_tlv_def.RCP_MSG_TYPE_NTF, 2,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
self.assertEqual(seq_dec.decode(buf, offset=0, buf_data_len=len(buf)),
seq_dec.DECODE_DONE)
self.assertFalse(seq._ut_compare(seq_dec))
def test_msg_with_tlvs_of_all_classes_find_TVL(self):
seq = RCPSequence(gcp_msg_def.NotifyError,
rcp_tlv_def.RCP_MSG_TYPE_NTF, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('ABC')
msg = Message(gcp_msg_def.NotifyError)
rcp_msg = RCPMessage(gcp_msg_def.NotifyError,
rcp_tlv_def.RCP_MSG_TYPE_NTF)
msg.tlv_data.rcp_msgs.append(rcp_msg)
rcp_msg.sequences.append(seq)
msg.msg_fields.TransactionID.set_val(10)
msg.msg_fields.ReturnCode.set_val(
gcp_msg_def.GCP_RC_MESSAGE_FAILURE.rc)
seq.RpdCapabilities.NumBdirPorts.set_val(11)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('ABC')
seq.RpdCapabilities.RpdIdentification.DeviceMacAddress.set_val(
(0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56))
sub_tlv = seq.CcapCoreIdentification.add_new_repeated()
sub_tlv.Index.set_val(0x34)
sub_tlv.CoreIpAddress.set_val(
(0xA1, 0xA2, 0xA3, 0xA4, 0xB1, 0xB2, 0xB3, 0xB4, 0xC1, 0xC2, 0xC3,
0xC4, 0xD1, 0xD2, 0xD3, 0xD4))
buf3 = msg.encode()
self.assertIsNotNone(buf3)
buf3_str = binascii.hexlify(buf3)
num_bidir_ports_pattern = "010002000b"
vendor_name_pattern = "010003414243"
device_mac_address_pattern = "040006abcdef123456"
index_pattern = "01000134"
core_ip_address_pattern = "030010a1a2a3a4b1b2b3b4c1c2c3c4d1d2d3d4"
self.assertNotEqual(buf3_str.find(num_bidir_ports_pattern), -1)
self.assertNotEqual(buf3_str.find(vendor_name_pattern), -1)
self.assertNotEqual(buf3_str.find(device_mac_address_pattern), -1)
self.assertNotEqual(buf3_str.find(index_pattern), -1)
self.assertNotEqual(buf3_str.find(core_ip_address_pattern), -1)
def test_msg_with_tlv(self):
# Encode message with mandatory fields, decode buffer and compare objs
msg = Message(gcp_msg_def.NotifyREQ)
msg.msg_fields.TransactionID.set_val(5)
msg.msg_fields.EventCode.set_val(1)
msg.msg_fields.Mode.set_val(0b10000000)
msg.msg_fields.Status.set_val(2)
seq = RCPSequence(gcp_msg_def.NotifyREQ, rcp_tlv_def.RCP_MSG_TYPE_NTF,
0, rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
rcp_msg = RCPMessage(gcp_msg_def.NotifyREQ,
rcp_tlv_def.RCP_MSG_TYPE_NTF)
msg.tlv_data.rcp_msgs.append(rcp_msg)
rcp_msg.sequences.append(seq)
seq.RpdCapabilities.NumBdirPorts.set_val(1)
buf = msg.encode()
self.assertIsNotNone(buf)
msg_dec = Message(gcp_msg_def.NotifyREQ)
self.assertEqual(msg_dec.decode(buf, offset=0, buf_data_len=len(buf)),
msg_dec.DECODE_DONE)
def construct_eds_pkt_CcapCoreIdentification(
need_info=False, op=rcp_tlv_def.RCP_OPERATION_TYPE_READ):
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA, 0xffff, op)
# Set RCP sequence
ccap = seq.parent_gpb.CcapCoreIdentification.add()
ccap.Index = 1
if need_info:
ccap.IsPrincipal = True
ccap.CoreMode = 1
ccap.CoreId = 'CoreId'
ccap.CoreIpAddress = '1.1.1.1'
ccap.CoreName = 'CoreName'
ccap.VendorId = 12
rcp_msg = RCPMessage(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_IRA)
rcp_msg.sequences.append(seq)
gcp_msg = Message(gcp_msg_def.DataStructREQ)
# TODO implement correct setting of message fields
transaction_id = 0xffff
gcp_msg.msg_fields.TransactionID.set_val(transaction_id)
gcp_msg.msg_fields.Mode.set_val(0)
gcp_msg.msg_fields.Port.set_val(11)
gcp_msg.msg_fields.Channel.set_val(111)
gcp_msg.msg_fields.VendorID.set_val(1111)
gcp_msg.msg_fields.VendorIndex.set_val(254)
gcp_msg.tlv_data.rcp_msgs.append(rcp_msg)
pkt = RCPPacket()
pkt.transaction_identifier = transaction_id
pkt.protocol_identifier = RCP_PROTOCOL_ID
pkt.unit_id = 0
pkt.msgs.append(gcp_msg)
return [pkt, gcp_msg]
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 create_test_sequence(operation=rcp_tlv_def.RCP_OPERATION_TYPE_WRITE, seq_num=0):
seq = RCPSequence(gcp_msg_def.DataStructREQ, rcp_tlv_def.RCP_MSG_TYPE_REX,
seq_num, operation, unittest=True)
seq.RpdCapabilities.NumBdirPorts.set_val(1)
# TODO this can be uncommented when conflicting numbering is solved
# seq.RpdCapabilities.NumAsyncVideoChannels.set_val(2)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('31')
seq.RpdCapabilities.RpdIdentification.VendorId.set_val(9)
seq.RpdCapabilities.RpdIdentification.DeviceMacAddress.set_val(
(0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56))
seq.RpdCapabilities.RpdIdentification.SerialNumber.set_val('33')
sub_tlv = \
seq.RpdCapabilities.LcceChannelReachability.add_new_repeated()
sub_tlv.EnetPortIndex.set_val(4)
sub_tlv.ChannelType.set_val(
rcp_tlv_def.CHANNEL_TYPE_1_DsScQa_downstream_QAM[0])
sub_tlv.EndChannelIndex.set_val(5)
sub_tlv.RfPortIndex.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.NumCwToneGens.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.QamAsPilot.set_val(1)
sub_tlv = seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
sub_tlv.DsPortIndex.set_val(8)
sub_tlv.AllocatedNdfChannels.set_val(9)
sub_tlv = seq.RpdCapabilities.AllocUsChanResources.add_new_repeated()
sub_tlv.UsPortIndex.set_val(10)
sub_tlv.AllocatedNdrChannels.set_val(11)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
sub_tlv.DsRfPort.AdminState.set_val(1)
sub_tlv.DsRfPort.BasePower.set_val(30)
sub_tlv.DsRfPort.RfMute.set_val(0)
sub_tlv.DsRfPort.TiltSlope.set_val(8)
sub_tlv.DsRfPort.TiltMaximumFrequency.set_val(15)
sub_tlv = seq.RfChannel.add_new_repeated()
sub_tlv.RfChannelSelector.RfChannelIndex.set_val(0)
sub_tlv.DsScQamChannelConfig.AdminState.set_val(1)
sub_tlv.DsScQamChannelConfig.RfMute.set_val(1)
sub_tlv.DsScQamChannelConfig.TSID.set_val(2)
sub_tlv.DsScQamChannelConfig.CenterFrequency.set_val(98000000)
sub_tlv.DsScQamChannelConfig.OperationalMode.set_val(2)
sub_tlv.DsScQamChannelConfig.Modulation.set_val(4)
sub_tlv.DsScQamChannelConfig.InterleaverDepth.set_val(1)
sub_tlv.DsScQamChannelConfig.Annex.set_val(4)
sub_tlv.DsScQamChannelConfig.SyncInterval.set_val(10)
sub_tlv.DsScQamChannelConfig.SymbolFrequencyDenominator.set_val(4)
sub_tlv.DsScQamChannelConfig.SymbolFrequencyNumerator.set_val(250)
sub_tlv.DsScQamChannelConfig.SymbolRateOverride.set_val(260)
sub_tlv.DsScQamChannelConfig.SpectrumInversionEnabled.set_val(0)
sub_tlv.DsScQamChannelConfig.PowerAdjust.set_val(17)
seq.RdtiConfig.RpdRdtiMode.set_val(2)
seq.RdtiConfig.RpdPtpDefDsDomainNumber.set_val(44)
seq.RdtiConfig.RpdPtpProfileVersion.set_val('10-11-12')
sub_tlv = seq.RdtiConfig.RpdPtpPortConfig.add_new_repeated()
sub_tlv.RpdEnetPortIndex.set_val(0)
sub_tlv.RpdPtpPortIndex.set_val(0)
sub_tlv.RpdPtpPortAdminState.set_val(4)
sub_tlv.RpdPtpPortClockSource.set_val((10, 74, 21, 216))
sub_tlv.RpdPtpPortDsLogSyncInterval.set_val(-7)
sub_tlv.RpdPtpPortDsLogAnnounceInterval.set_val(-3)
sub_tlv.RpdPtpPortDsAnnounceReceiptTimeout.set_val(60)
return seq
def test_rcp_msg_cb_event(self):
print '############test rcp_msg_cb event case#############'
RCPDB.DB_CFG_FILE = CONF_FILE
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)
# reboot
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_REBOOT
ccap_core_para = {'addr_remote': '1.1.1.1', 'interface_local': 'eth1', 'info': "test"}
rcp_msg.parameter = json.dumps(ccap_core_para)
self.agent.rcp_msg_cb(rcp_msg)
# redirect
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.REDIRECT_NOTIFICATION
ccap_core_para = {'addr_remote': '1.1.1.1', 'interface_local': 'eth0', 'info': "test"}
rcp_msg.parameter = json.dumps(ccap_core_para)
rcp_msg.RedirectCCAPAddresses.append('3.3.3.3')
self.agent.rcp[('eth0', '1.1.1.1')]['status'] = self.agent.UP
self.agent.rcp_msg_cb(rcp_msg)
# configuration
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_CONFIGURATION
cfg = rcp_msg.RpdDataMessage.RpdData
rcp_msg.parameter = 'eth0'
capability = cfg.CcapCoreIdentification.add()
capability.Index = 1
capability.CoreId = 'CoreId'
capability.CoreIpAddress = '1.1.1.1'
capability.IsPrincipal = True
capability.CoreMode = 1
capability.CoreName = "CiscoRPD"
capability.VendorId = 1
capability.InitialConfigurationComplete = True
capability.MoveToOperational = True
capability.CoreFunction = 1
capability.ResourceSetIndex = 2
self.agent.rcp[('eth0', '1.1.1.1')]['status'] = self.agent.DOWN
self.agent.rcp_msg_cb(rcp_msg)
# RedundantCoreIpAddress
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_CONFIGURATION
cfg = rcp_msg.RpdDataMessage.RpdData
rcp_msg.parameter = 'eth0'
red = cfg.RedundantCoreIpAddress.add()
red.ActiveCoreIpAddress = '1.1.1.1'
red.StandbyCoreIpAddress = '1.1.1.3'
self.agent.rcp_msg_cb(rcp_msg) # no must field
desc1 = 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_1 = RCPSlaveSession(desc1, self.agent.process.dispatcher,
orch.session_initiate_cb,
orch.session_timeout_cb,
orch.session_connecting_timeout_cb)
self.agent.process.orchestrator.sessions_active[desc1.get_uniq_id()] = session_1
caps1 = CcapCoreIdentification(index=1,
core_id="CoreId-1",
core_ip_addr='1.1.1.1',
is_principal=True,
core_name="SIM_GCPP",
vendor_id=0,
core_mode=True,
initial_configuration_complete=True,
move_to_operational=True,
core_function=1,
resource_set_index=2)
session_1.ccap_identification = caps1
desc2 = GCPSlaveDescriptor(
'1.1.1.3', port_master='8190', addr_local='1.1.1.2',
interface_local='eth0',
addr_family=socket.AF_INET)
orch = self.agent.process.orchestrator
session_2 = RCPSlaveSession(desc2, self.agent.process.dispatcher,
orch.session_initiate_cb,
orch.session_timeout_cb,
orch.session_connecting_timeout_cb)
# self.agent.process.orchestrator.add_sessions([desc2])
self.agent.process.orchestrator.sessions_active[desc2.get_uniq_id()] = session_2
caps2 = CcapCoreIdentification(index=1,
core_id="CoreId-2",
core_ip_addr='1.1.1.1',
is_principal=True,
core_name="SIM_GCPP",
vendor_id=0,
core_mode=True,
initial_configuration_complete=True,
move_to_operational=True,
core_function=1,
resource_set_index=2)
session_2.ccap_identification = caps2
caps1.is_active = False
caps2.is_active = True
red.Operation = ManagerProcess.OPERATION_ADD
self.agent.rcp_msg_cb(rcp_msg)
caps1.is_active = True
caps2.is_active = False
red.Operation = ManagerProcess.OPERATION_CHANGE
self.agent.rcp_msg_cb(rcp_msg)
# ConfiguredCoreTable
# miss operation field
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_CONFIGURATION
cfg = rcp_msg.RpdDataMessage.RpdData
cfg_core = cfg.ConfiguredCoreTable.add()
cfg_core.ConfiguredCoreIp = '1.1.1.1'
self.agent.rcp_msg_cb(rcp_msg)
cfg_core.Operation = 0
self.agent.rcp_msg_cb(rcp_msg)
# ActivePrincipalCore
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_CONFIGURATION
cfg = rcp_msg.RpdDataMessage.RpdData
cfg.ActivePrincipalCore = '1.1.1.1'
seq.ipc_msg = rcp_msg
self.agent.rcp_msg_cb(seq, (session, 'transaction_identifier', 'trans_id'))
# RPD_CONFIGURATION else
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_CONFIGURATION
cfg = rcp_msg.RpdDataMessage.RpdData
cfg_core = cfg.Ssd
cfg_core.SsdServerAddress = '1.1.1.1'
self.agent.rcp_msg_cb(rcp_msg)
# configuration done
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.RPD_CONFIGURATION_DONE
rcp_msg.parameter = ';'.join(['eth0', '1.1.1.1'])
self.agent.principal_core_interface = 'eth0'
self.agent.principal_core = '1.1.1.1'
self.agent.rcp_msg_cb(rcp_msg, (session, 'transaction_identifier', 'trans_id'))
# CONNECT_CLOSE_NOTIFICATION
rcp_msg = t_RcpMessage()
rcp_msg.RcpMessageType = rcp_msg.CONNECT_CLOSE_NOTIFICATION
ccap_core_para = {'addr_remote': '1.1.1.1', 'interface_local': 'eth0', "reconnect": True}
rcp_msg.parameter = json.dumps(ccap_core_para)
self.agent.ccap_cores.pop('CORE-1234567890')
self.agent.rcp_msg_cb(rcp_msg)
ccap_core_para = {'addr_remote': '1.1.1.1', 'interface_local': 'eth0', "reconnect": False}
rcp_msg.parameter = json.dumps(ccap_core_para)
self.agent.rcp_msg_cb(rcp_msg)
def create_testing_sequence_from_gpb(gcp_message_id, rcp_message_id,
gpb_message):
return RCPSequence(gcp_message_id, rcp_message_id, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE, gpb_message)
def create_testing_cfg_sequence(gcp_message_id, rcp_message_id):
seq = RCPSequence(gcp_message_id,
rcp_message_id,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
seq.RpdCapabilities.NumBdirPorts.set_val(1)
# TODO this can be uncommented when conflicting numbering is solved
# seq.RpdCapabilities.NumAsyncVideoChannels.set_val(2)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('31')
seq.RpdCapabilities.RpdIdentification.VendorId.set_val(32)
seq.RpdCapabilities.RpdIdentification.DeviceMacAddress.set_val(
(0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56))
seq.RpdCapabilities.RpdIdentification.SerialNumber.set_val('33')
sub_tlv =\
seq.RpdCapabilities.LcceChannelReachability.add_new_repeated()
sub_tlv.EnetPortIndex.set_val(4)
sub_tlv.ChannelType.set_val(
rcp_tlv_def.CHANNEL_TYPE_1_DsScQa_downstream_QAM[0])
sub_tlv.EndChannelIndex.set_val(5)
sub_tlv.RfPortIndex.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.NumCwToneGens.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.QamAsPilot.set_val(1)
sub_tlv = seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
sub_tlv.DsPortIndex.set_val(8)
sub_tlv.AllocatedNdfChannels.set_val(9)
sub_tlv = seq.RpdCapabilities.AllocUsChanResources.add_new_repeated()
sub_tlv.UsPortIndex.set_val(10)
sub_tlv.AllocatedNdrChannels.set_val(11)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
# sub_tlv.DsRfPort.PortIndex.set_val(14)
sub_tlv.DsRfPort.TiltMaximumFrequency.set_val(15)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
sub_tlv.UsRfPort.BaseTargetRxPower.set_val(10)
sub_tlv = seq.RfChannel.add_new_repeated()
sub_tlv.RfChannelSelector.RfChannelIndex.set_val(0)
# dMsg = binascii.a2b_hex("c200016af52b01e02f00000100219f7b66380158000003010200010d0401010108020401312d00038003f02833ebf02833ebf02833ebf02833ebf1642892a9974767da0417bbc2758f36ff5739350dc1871988d3d22b603f296b0df3dec0edf3dec0edf3dec0edf3dec0edf1642892a9974767da0417bbc2758f36ff5739350dc1871988d3d22b603f296b000000000000000000000000000000000000000000000000000000000000042501010101020102030200260402018c050100060110070201520801000901160a01010b01010425030101010201020302018004020006050105060122070201520801000901300a01010b01010425040101010201020302018004020006050105060122070201520801000901300a01010b0101042505010101020102030200400402018c05010306014c0702015208010c0901160a01020b0101042506010101020102030200400402018c0501090601e8070201520801fe0901160a01020b0101052506010101020102030200400402018c0501090601e8070201520801fe0901160a01020b01010640c0edf1642892a9974767da0417bbc2758f36ff5739350dc1871988d3d22b603f296b0000000000000000000000000000000000000000000000000000000000000701010801010901010a01010b0201010c0201010d0201010e090102030405060708090f0101100101110101120401020304130101140101151001020304050607080910111213141516160101")
# sub_tlv.DocsisMsg.set_val(dMsg)
sub_tlv.DsScQamChannelConfig.AdminState.set_val(1)
sub_tlv.DsScQamChannelConfig.PowerAdjust.set_val(17)
sub_tlv.DsOfdmChannelConfig.AdminState.set_val(2)
sub_tlv.DsOfdmChannelConfig.SubcarrierSpacing.set_val(1)
sub_tlv2 = sub_tlv.DsOfdmChannelConfig.DsOfdmSubcarrierType.add_new_repeated(
)
sub_tlv2.StartSubcarrierId.set_val(21)
sub_tlv2.EndSubcarrierId.set_val(22)
sub_tlv2.SubcarrierUsage.set_val(1)
sub_tlv2 = sub_tlv.DsOfdmProfile
sub_tlv2.ProfileId.set_val(15)
# sub_tlv3 = sub_tlv2.DsOfdmSubcarrierModulation.add_new_repeated()
# sub_tlv3.StartSubcarrierId.set_val(21)
# sub_tlv3.EndSubcarrierId.set_val(22)
# sub_tlv3.Modulation.set_val(1)
sub_tlv.UsScQamChannelConfig.AdminState.set_val(3)
sub_tlv.UsScQamChannelConfig.TargetRxPower.set_val(24)
sub_tlv2 = sub_tlv.UsScQamChannelConfig.IntervalUsageCode.add_new_repeated(
)
sub_tlv2.Code.set_val(14)
sub_tlv2.GuardTime.set_val(26)
sub_tlv.UsOfdmaChannelConfig.AdminState.set_val(4)
sub_tlv.UsOfdmaChannelConfig.TargetRxPowerAdjust.set_val(28)
sub_tlv.UsOfdmaInitialRangingIuc.NumSubcarriers.set_val(10)
sub_tlv.UsOfdmaInitialRangingIuc.Guardband.set_val(10)
sub_tlv.UsOfdmaFineRangingIuc.NumSubcarriers.set_val(14)
sub_tlv.UsOfdmaFineRangingIuc.Guardband.set_val(10)
sub_tlv2 = sub_tlv.UsOfdmaDataIuc.add_new_repeated()
sub_tlv2.DataIuc.set_val(5)
sub_tlv2.DataSymbolModulation.set_val(1)
sub_tlv2 = sub_tlv.UsOfdmaSubcarrierCfgState.add_new_repeated()
sub_tlv2.StartingSubcarrierId.set_val(0)
sub_tlv2.SubcarrierUsage.set_val(4)
return seq
def test_tlv_len_mismatch(self):
seq = "0900570a000200020b000105130001003c004701000100020004313233340300" \
+ "10262000002b107ffe00000000000000020400010105000843434150434f524506000" \
+ "2118b0700010108000100090001000a000200000b000100"
seq_buf = binascii.a2b_hex(seq)
print repr(seq_buf)
decoder = RCPSequence(gcp_msg_def.DataStructRSP,
rcp_tlv_def.RCP_MSG_TYPE_REX, 1,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE_RESPONSE)
decoder.decode(seq_buf, offset=0, buf_data_len=len(seq_buf))
# change vendor id to 1 byte
decoder = RCPSequence(gcp_msg_def.DataStructRSP,
rcp_tlv_def.RCP_MSG_TYPE_REX, 1,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE_RESPONSE)
seq = "0900560a000200020b000105130001003c004601000100020004313233340300102620" \
+ "00002b107ffe00000000000000020400010105000843434150434f52450600018b070001010" \
+ "8000100090001000a000200000b000100"
seq_buf = binascii.a2b_hex(seq)
decoder.decode(seq_buf, offset=0, buf_data_len=len(seq_buf))
# change vendor id to 3 byte
decoder = RCPSequence(gcp_msg_def.DataStructRSP,
rcp_tlv_def.RCP_MSG_TYPE_REX, 1,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE_RESPONSE)
seq = "0900570a000200020b000105130001003c00470100010002000431323334030010262000002b" \
+ "107ffe00000000000000020400010105000843434150434f524506000311118b0700010108000100" \
+ "090001000a000200000b000100"
seq_buf = binascii.a2b_hex(seq)
decoder.decode(seq_buf, offset=0, buf_data_len=len(seq_buf))
def create_testing_ds_cfg_sequence(gcp_message_id, rcp_message_id):
seq = RCPSequence(gcp_message_id,
rcp_message_id,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
seq.RpdCapabilities.NumBdirPorts.set_val(1)
# TODO this can be uncommented when conflicting numbering is solved
# seq.RpdCapabilities.NumAsyncVideoChannels.set_val(2)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('31')
seq.RpdCapabilities.RpdIdentification.VendorId.set_val(32)
seq.RpdCapabilities.RpdIdentification.DeviceMacAddress.set_val(
(0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56))
seq.RpdCapabilities.RpdIdentification.SerialNumber.set_val('33')
sub_tlv =\
seq.RpdCapabilities.LcceChannelReachability.add_new_repeated()
sub_tlv.EnetPortIndex.set_val(4)
sub_tlv.ChannelType.set_val(
rcp_tlv_def.CHANNEL_TYPE_1_DsScQa_downstream_QAM[0])
sub_tlv.EndChannelIndex.set_val(5)
sub_tlv.RfPortIndex.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.NumCwToneGens.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.QamAsPilot.set_val(1)
sub_tlv = seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
sub_tlv.DsPortIndex.set_val(8)
sub_tlv.AllocatedNdfChannels.set_val(9)
sub_tlv = seq.RpdCapabilities.AllocUsChanResources.add_new_repeated()
sub_tlv.UsPortIndex.set_val(10)
sub_tlv.AllocatedNdrChannels.set_val(11)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
sub_tlv.DsRfPort.AdminState.set_val(1)
sub_tlv.DsRfPort.BasePower.set_val(30)
sub_tlv.DsRfPort.RfMute.set_val(0)
sub_tlv.DsRfPort.TiltSlope.set_val(8)
sub_tlv.DsRfPort.TiltMaximumFrequency.set_val(15)
sub_tlv = seq.RfChannel.add_new_repeated()
sub_tlv.RfChannelSelector.RfChannelIndex.set_val(0)
sub_tlv.DsScQamChannelConfig.AdminState.set_val(1)
sub_tlv.DsScQamChannelConfig.RfMute.set_val(1)
sub_tlv.DsScQamChannelConfig.TSID.set_val(2)
sub_tlv.DsScQamChannelConfig.CenterFrequency.set_val(98000000)
sub_tlv.DsScQamChannelConfig.OperationalMode.set_val(2)
sub_tlv.DsScQamChannelConfig.Modulation.set_val(4)
sub_tlv.DsScQamChannelConfig.InterleaverDepth.set_val(1)
sub_tlv.DsScQamChannelConfig.Annex.set_val(4)
sub_tlv.DsScQamChannelConfig.SyncInterval.set_val(10)
sub_tlv.DsScQamChannelConfig.SymbolFrequencyDenominator.set_val(4)
sub_tlv.DsScQamChannelConfig.SymbolFrequencyNumerator.set_val(250)
sub_tlv.DsScQamChannelConfig.SymbolRateOverride.set_val(260)
sub_tlv.DsScQamChannelConfig.SpectrumInversionEnabled.set_val(0)
sub_tlv.DsScQamChannelConfig.PowerAdjust.set_val(17)
return seq
def test_msg_dispatch(self):
try:
self.process.send_ipc_msg('error')
except SystemExit as e:
self.assertEqual(e.code, EX_DATAERR)
self.process.send_ipc_msg({
"session": self.session,
"req_packet": None,
"req_data": "error"
})
timeout_msg = t_RcpMessage()
timeout_msg.RcpMessageType = timeout_msg.CONNECT_CLOSE_NOTIFICATION
self.process.send_ipc_msg({
"session": self.session,
"req_packet": None,
"req_data": timeout_msg
})
data_list = []
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
seq.RpdCapabilities.NumBdirPorts.set_val(1)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('31')
seq.RpdCapabilities.RpdIdentification.VendorId.set_val(9)
data_list.append(seq)
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
sub_tlv.DsRfPort.AdminState.set_val(1)
sub_tlv.DsRfPort.BasePower.set_val(30)
sub_tlv.DsRfPort.RfMute.set_val(0)
sub_tlv.DsRfPort.TiltSlope.set_val(8)
sub_tlv.DsRfPort.TiltMaximumFrequency.set_val(15)
data_list.append(seq)
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
seq.RpdConfigurationDone.set_val(1)
data_list.append(seq)
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
seq.ipc_msg = None
data_list.append(seq)
self.process.hal_ipc.disconnected = False
self.process.hal_ipc.clientID = '12345'
self.process.send_ipc_msg({
"session": self.session,
"req_packet": 'tmp',
"gcp_msg": "tmp",
"req_data": data_list
})
def test_msg_with_tlvs_of_all_classes(self):
# Encode message with mandatory fields, decode buffer and compare objs
msg = Message(gcp_msg_def.DataStructError)
msg.msg_fields.TransactionID.set_val(5)
msg.msg_fields.ExceptionCode.set_val(
gcp_msg_def.GCP_RC_MESSAGE_FAILURE.rc)
seq = RCPSequence(gcp_msg_def.DataStructError,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
rcp_msg = RCPMessage(gcp_msg_def.DataStructError,
rcp_tlv_def.RCP_MSG_TYPE_REX)
msg.tlv_data.rcp_msgs.append(rcp_msg)
rcp_msg.sequences.append(seq)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('ABC')
seq.RpdCapabilities.NumBdirPorts.set_val(1)
# TODO this can be uncommented when conflicting numbering is solved
# seq.RpdCapabilities.NumAsyncVideoChannels.set_val(2)
seq.RpdCapabilities.RpdIdentification.VendorName.set_val('31')
seq.RpdCapabilities.RpdIdentification.VendorId.set_val(9)
seq.RpdCapabilities.RpdIdentification.DeviceMacAddress.set_val(
(0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56))
seq.RpdCapabilities.RpdIdentification.SerialNumber.set_val('33')
sub_tlv =\
seq.RpdCapabilities.LcceChannelReachability.add_new_repeated()
sub_tlv.EnetPortIndex.set_val(4)
sub_tlv.EndChannelIndex.set_val(5)
seq.RpdCapabilities.PilotToneCapabilities.NumCwToneGens.set_val(6)
seq.RpdCapabilities.PilotToneCapabilities.QamAsPilot.set_val(1)
sub_tlv = seq.RpdCapabilities.AllocDsChanResources.add_new_repeated()
sub_tlv.DsPortIndex.set_val(8)
sub_tlv.AllocatedNdfChannels.set_val(9)
sub_tlv = seq.RpdCapabilities.AllocUsChanResources.add_new_repeated()
sub_tlv.UsPortIndex.set_val(10)
sub_tlv.AllocatedNdrChannels.set_val(11)
sub_tlv = seq.CcapCoreIdentification.add_new_repeated()
sub_tlv.Index.set_val(12)
sub_tlv.CoreIpAddress.set_val((0x01, 0x02, 0x03, 0x04))
sub_tlv.VendorId.set_val(13)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
# sub_tlv.DsRfPort.PortIndex.set_val(14)
sub_tlv.DsRfPort.TiltMaximumFrequency.set_val(15)
sub_tlv = seq.RfChannel.add_new_repeated()
sub_tlv.RfChannelSelector.RfChannelIndex.set_val(0)
sub_tlv.DsScQamChannelConfig.AdminState.set_val(1)
sub_tlv.DsScQamChannelConfig.PowerAdjust.set_val(17)
sub_tlv.DsOfdmChannelConfig.AdminState.set_val(2)
sub_tlv.DsOfdmChannelConfig.SubcarrierSpacing.set_val(1)
sub_tlv2 = sub_tlv.DsOfdmChannelConfig.DsOfdmSubcarrierType.add_new_repeated(
)
sub_tlv2.StartSubcarrierId.set_val(21)
sub_tlv2.EndSubcarrierId.set_val(22)
sub_tlv2.SubcarrierUsage.set_val(1)
sub_tlv2 = sub_tlv.DsOfdmProfile
sub_tlv2.ProfileId.set_val(15)
# sub_tlv3 = sub_tlv2.DsOfdmSubcarrierModulation.add_new_repeated()
# sub_tlv3.StartSubcarrierId.set_val(21)
# sub_tlv3.EndSubcarrierId.set_val(22)
# sub_tlv3.Modulation.set_val(1)
sub_tlv.UsScQamChannelConfig.AdminState.set_val(3)
sub_tlv.UsScQamChannelConfig.TargetRxPower.set_val(24)
sub_tlv2 = sub_tlv.UsScQamChannelConfig.IntervalUsageCode.\
add_new_repeated()
sub_tlv2.Code.set_val(14)
sub_tlv2.GuardTime.set_val(26)
sub_tlv.UsOfdmaChannelConfig.AdminState.set_val(4)
sub_tlv.UsOfdmaChannelConfig.TargetRxPowerAdjust.set_val(28)
sub_tlv.UsOfdmaInitialRangingIuc.NumSubcarriers.set_val(10)
sub_tlv.UsOfdmaInitialRangingIuc.Guardband.set_val(10)
sub_tlv.UsOfdmaFineRangingIuc.NumSubcarriers.set_val(14)
sub_tlv.UsOfdmaFineRangingIuc.Guardband.set_val(10)
sub_tlv2 = sub_tlv.UsOfdmaDataIuc.add_new_repeated()
sub_tlv2.DataIuc.set_val(5)
sub_tlv2.DataSymbolModulation.set_val(1)
sub_tlv2 = sub_tlv.UsOfdmaSubcarrierCfgState.add_new_repeated()
sub_tlv2.StartingSubcarrierId.set_val(0)
sub_tlv2.SubcarrierUsage.set_val(4)
sub_tlv2 = sub_tlv.SidQos.add_new_repeated()
sub_tlv2.StartSid.set_val(100)
sub_tlv2.NumSids.set_val(10)
sub_tlv2.SidSfType.set_val(2)
sub_tlv2 = sub_tlv.SidQos.add_new_repeated()
sub_tlv2.StartSid.set_val(15800)
sub_tlv2.NumSids.set_val(5)
sub_tlv2.SidSfType.set_val(3)
buf = msg.encode()
self.assertNotEqual(buf, None)
msg_dec = Message(gcp_msg_def.DataStructError)
self.assertEqual(msg_dec.decode(buf, offset=0, buf_data_len=len(buf)),
msg_dec.DECODE_DONE)
def test_msg_dispatch_I08(self):
print("##################test_msg_dispatch_I08##################")
try:
self.process.send_ipc_msg('error')
except SystemExit as e:
self.assertEqual(e.code, EX_DATAERR)
self.process.send_ipc_msg({
"session": self.session,
"req_packet": None,
"req_data": "error"
})
timeout_msg = t_RcpMessage()
timeout_msg.RcpMessageType = timeout_msg.CONNECT_CLOSE_NOTIFICATION
self.process.send_ipc_msg({
"session": self.session,
"req_packet": None,
"req_data": timeout_msg
})
data_list = []
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
unittest=True)
sub_tlv = seq.CcapCoreIdentification.add_new_repeated()
sub_tlv.Index.set_val(1)
sub_tlv.CoreId.set_val('1234567890')
sub_tlv.CoreIpAddress.set_val(
Convert.ipaddr_to_tuple_of_bytes("127.0.0.1"))
sub_tlv.IsPrincipal.set_val(False)
sub_tlv.CoreMode.set_val(1)
sub_tlv.InitialConfigurationComplete.set_val(True)
sub_tlv.MoveToOperational.set_val(True)
sub_tlv.CoreFunction.set_val(1)
sub_tlv.ResourceSetIndex.set_val(2)
data_list.append(seq)
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_ALLOCATE_WRITE,
unittest=True)
sub_tlv = seq.RfPort.add_new_repeated()
sub_tlv.RfPortSelector.RfPortIndex.set_val(0)
sub_tlv.DsRfPort.AdminState.set_val(1)
sub_tlv.DsRfPort.BasePower.set_val(30)
sub_tlv.DsRfPort.RfMute.set_val(0)
sub_tlv.DsRfPort.TiltSlope.set_val(8)
sub_tlv.DsRfPort.TiltMaximumFrequency.set_val(15)
data_list.append(seq)
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX,
0,
rcp_tlv_def.RCP_OPERATION_TYPE_ALLOCATE_WRITE,
unittest=True)
seq.RpdConfigurationDone.set_val(1)
data_list.append(seq)
seq = RCPSequence(gcp_msg_def.DataStructREQ,
rcp_tlv_def.RCP_MSG_TYPE_REX, 0,
rcp_tlv_def.RCP_OPERATION_TYPE_ALLOCATE_WRITE)
seq.ipc_msg = None
data_list.append(seq)
self.process.hal_ipc.disconnected = False
self.process.hal_ipc.clientID = '12345'
self.process.send_ipc_msg({
"session": self.session,
"req_packet": 'tmp',
"gcp_msg": "tmp",
"req_data": data_list
})
def create_vendor_tlvs_sequence(self, gcp_message_id, rcp_message_id,
operation):
""" This functions create a RCPSequence object, and set t_VendorSpecificExtension()
with appropriate values.
: param gcp_message_id: GCP Message ID
: param rcp_message_id: RCP Message ID
: param operation: TLV Operation of this RCP Sequence
: return: seq
"""
seq = RCPSequence(gcp_message_id=gcp_message_id,
rcp_message_id=rcp_message_id,
operation=operation)
if None is seq:
return None
# use the RCP TLV standard operation values instead of enum t_RpdDataOperation.
if None is not seq.ipc_msg:
if operation == rcp_tlv_def.RCP_OPERATION_TYPE_READ:
seq.ipc_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_READ
elif operation == rcp_tlv_def.RCP_OPERATION_TYPE_WRITE:
seq.ipc_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_WRITE
elif operation == rcp_tlv_def.RCP_OPERATION_TYPE_DELETE:
seq.ipc_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_DELETE
elif operation == rcp_tlv_def.RCP_OPERATION_TYPE_ALLOCATE_WRITE:
seq.ipc_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_CFG_ALLOCATE_WRITE
else:
seq.ipc_msg.RpdDataMessage.RpdDataOperation = t_RpdDataMessage.RPD_OPER_NONE
VspTlv = seq.VendorSpecificExtension
VspTlv.VendorId.set_val(self.VendorID)
if operation in [
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE,
rcp_tlv_def.RCP_OPERATION_TYPE_ALLOCATE_WRITE
]:
# Driver could use this to verify its FW/HW before applying...
VspTlv.FWVersion.set_val(0x0101)
VspTlv.HWVersion.set_val(0x0A05)
# Fill some data for OpenRpdDriver to write to HW
rfChannel = VspTlv.RfChannel.add_new_repeated()
rfChannel.RfChannelSelector.RfPortIndex.set_val(3)
rfChannel.RfChannelSelector.RfChannelType.set_val(2)
rfChannel.RfChannelSelector.RfChannelIndex.set_val(1)
DsScQamChannelConfig = rfChannel.DsScQamChannelConfig
DsScQamChannelConfig.AdminState.set_val(
t_VendorSpecificExtension.t_RfChannel.t_DsScQamChannelConfig.
ADMIN_STATE_4_TESTING)
#DsScQamChannelConfig.CcapCoreOwner = ("\x00\x01\x02\x03\x04\x05")
DsScQamChannelConfig.RfMute.set_val(True)
DsScQamChannelConfig.TSID.set_val(6879)
DsScQamChannelConfig.CenterFrequency.set_val(1000000)
DsScQamChannelConfig.OperationalMode.set_val(
t_VendorSpecificExtension.t_RfChannel.t_DsScQamChannelConfig.
OPERATIONAL_MODE_2_CHANNEL_AS_DOCSIS_CHANNEL)
DsScQamChannelConfig.Modulation.set_val(
t_VendorSpecificExtension.t_RfChannel.t_DsScQamChannelConfig.
MODULATION_57__4_QAM256)
DsScQamChannelConfig.InterleaverDepth.set_val(
t_VendorSpecificExtension.t_RfChannel.t_DsScQamChannelConfig.
INTERLEAVER_DEPTH_4_TAPS16INCREMENT8)
DsScQamChannelConfig.Annex.set_val(
t_VendorSpecificExtension.t_RfChannel.t_DsScQamChannelConfig.
ANNEX_3_ANNEX_A)
DsScQamChannelConfig.SyncInterval.set_val(0xa5)
#DsScQamChannelConfig.SyncMacAddress = ("\x00\x01\x02\x03\x04\x05")
DsScQamChannelConfig.SymbolFrequencyDenominator.set_val(0x12)
DsScQamChannelConfig.SymbolFrequencyNumerator.set_val(0x34)
DsScQamChannelConfig.SymbolRateOverride.set_val(0x56)
DsScQamChannelConfig.SpectrumInversionEnabled.set_val(False)
DsScQamChannelConfig.PowerAdjust.set_val(0x89)
elif (operation == rcp_tlv_def.RCP_OPERATION_TYPE_READ):
# Driver should write its current values here so the requester knows...
VspTlv.FWVersion.set_val(0x0)
VspTlv.HWVersion.set_val(0x0)
return seq
def test_value_constraint(self):
# Same like previous test, but we set TLV with limited range of values
seq = RCPSequence(gcp_msg_def.NotifyREQ, rcp_tlv_def.RCP_MSG_TYPE_NTF,
1, rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
# Bool constraint
with self.assertRaises(ValueError):
seq.RpdCapabilities.SupportsUdpEncap.set_val(2)
sub_tlv = \
seq.RpdCapabilities.LcceChannelReachability.add_new_repeated()
# Range constraint less than <1,10>
with self.assertRaises(ValueError):
sub_tlv.ChannelType.set_val(0)
# Range constraint greater than <1,10>
with self.assertRaises(ValueError):
sub_tlv.ChannelType.set_val(15)
buf = seq.encode()
self.assertEqual(len(buf), RCP_SEQUENCE_MIN_LEN)
self.assertIsNotNone(buf)
seq.offset = 0
seq.buf_data_len = 0
seq.buffer = None
# Range constraint <1,10> - valid value
sub_tlv.ChannelType.set_val(10)
buf = seq.encode()
dec_seq = RCPSequence(gcp_msg_def.NotifyREQ,
rcp_tlv_def.RCP_MSG_TYPE_NTF, 2,
rcp_tlv_def.RCP_OPERATION_TYPE_WRITE)
self.assertEqual(dec_seq.decode(buf, offset=0, buf_data_len=len(buf)),
dec_seq.DECODE_DONE)
self.assertTrue(dec_seq._ut_compare(seq))
