def compressed_files_can_be_unzipped_successfully(dir_name, files_name):
"""This keyword is to unzip the compressed files using gzip
| Parameters | Man. | Description |
| dir_name | Yes | the directory name |
| files_name | Yes | the array of files name |
| Return value | new_files_name |
Example
| compressed files can be unzipped successfully | monster_test | ["test0.gz","test1.gz"] |
"""
error_log = "not in gzip format"
new_files_name = []
files_len = len(files_name)
for i in range(files_len):
_file_should_exist(dir_name, files_name[i])
command = "gzip -l /var/log/%s/%s" % (dir_name, files_name[i])
output = connections.execute_mml_without_check(command)
if (output.count(error_log) > 0):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The compressed file can not be unzipped.")
command = "gzip -d -f /var/log/%s/%s" % (dir_name, files_name[i])
output = connections.execute_mml_without_check(command)
if (output.count(error_log) > 0):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The compressed file can not be unzipped.")
new_files_name.append(files_name[i].replace('.gz', ''))
return new_files_name
def message_count_is_correct_in_the_monitored_files(dir_name, files_name,
total_message_count):
"""This keyword is to use readste to check the message count is correct for the monitored files.
| Parameters | Man. | Description |
| output_dir | Yes | the directory name |
| output_files | Yes | the array of files name |
| total_message_count | Yes | total message count |
| Return value | None |
Example
| message count is correct in the monitored files | monster_test | ["test1","test2"] | 300 |
"""
files_name_len = len(files_name)
check_message_count = 0
for i in range(files_name_len):
_file_should_exist(dir_name, files_name[i])
file_name = "/var/log/%s/%s" % (dir_name, files_name[i])
command = "readste -i %s -a summary" % (file_name)
output = connections.execute_mml_without_check(command)
result_list = output.splitlines()
result_list_len = len(result_list)
for i in range(result_list_len):
if result_list[i].count('message frames'):
check_message_count = check_message_count + int(
result_list[i].split()[0])
print 'Total message count in files is: %s.' % (str(check_message_count))
if (check_message_count <> int(total_message_count)):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monitored message count is not correct.")
def list_name_of_name_server(service_name):
"""This keyword is to get the service pid by the service name
#COMMAND: nasext ls service_name
| Parameters | Man. | Description |
| service_name | Yes | The name of the service
| Return value |call detail information (CommonItem)
Example
| Get Service Pid Of Name Server | test_service |
"""
command = "nasext ls " + service_name
output = connections.execute_mml(command)
item = """Service_Name:([a-zA-Z0-9\-_]+)"""
match = re.search(item, output)
if match is not None:
service_pid = CommonItem()
service_pid.Name = match.group(1)
return service_pid
else:
exceptions.raise_ILError("ILCommandExecuteError", output)
def check_bottom_values(msg_buf,omu_phy_addr, omu_logical_address='7002'):
"""This keyword is to check decoded msg bottom vlaues
| Parameters | Man. | Description |
| msg_buf | Yes | The decoded msg values |
| Return value | success, if the bottom values are correct |
Example
| result | check bottom values | ${msg_buf} |
"""
if (msg_buf.find("Bottom:") == -1):
exceptions.raise_ILError("ILCommandExecuteError", "failed to get msg bottom")
msg_list = []
msg_buf = msg_buf[msg_buf.find("time of day (dword):"):]
msg_text = msg_buf.split("Bottom:")
for msg in msg_text:
print msg
match = re.search(r"control \(byte\):\s*([0-9]*)", msg, re.I)
msg_info = CommonItem()
msg_info.control = match.group(1)
match = re.search(r"hop_count \(byte\):\s*([0-9]*)\s*", msg, re.I)
msg_info.hop = match.group(1)
match = re.search(r"\s*msg number \(word\):\s*([0-9]*)\s*", msg, re.I)
msg_info.msgnum = match.group(1)
match = re.search(r"\s*next phys computer \(word\):\s*([0-9]*)\s*", msg, re.I)
msg_info.nextcomp = match.group(1)
match = re.search(r"\s*computer_addr \(word\):\s*([0-9]*)\s*", msg, re.I)
msg_info.comp = match.group(1)
match = re.search(r"\s*phys_computer \(word\):\s*([0-9]*)\s*", msg, re.I)
msg_info.phycomp = match.group(1)
msg_list.append(msg_info)
print msg_list
omu_phy_addr = omu_phy_addr.split('X')[1]
omu_phy_addr = atoi(omu_phy_addr,16)
omu_logical_address = atoi(omu_logical_address,16)
result = misc.select_entries_from_list(msg_list,'msgnum=9901')
for msg in result:
msg.nextcomp = atoi(msg.nextcomp,16)
msg.phycomp = atoi(msg.phycomp,16)
msg.comp = atoi(msg.comp,16)
if ( msg.control <> '08' ) or (msg.hop <> '01') or (msg.comp <> omu_logical_address) or ((msg.nextcomp <> omu_phy_addr) and (msg.nextcomp <> omu_logical_address)) or ((msg.phycomp <> omu_phy_addr) and (msg.phycomp <> omu_logical_address)):
return 'failure'
result = misc.select_entries_from_list(msg_list,'msgnum=6034')
for msg in result:
msg.comp = atoi(msg.comp,16)
msg.nextcomp = atoi(msg.nextcomp,16)
msg.phycomp = atoi(msg.phycomp,16)
if ( msg.control <> '80' and msg.control <> '00' and msg.control <> '08' ) or (msg.hop <> '04' and msg.hop <> '01') or (msg.comp <> omu_phy_addr) or (msg.nextcomp <> omu_phy_addr) or (msg.phycomp <> omu_phy_addr):
return 'failure'
if msg.control == '80' and msg.hop <> '04':
return 'failure'
if msg.control == '00' and msg.hop <> '01':
return 'failure'
if msg.control == '08' and msg.hop <> '01':
return 'failure'
return 'success'
def select_random_IP_address_and_recovery_group_ADA(ip_addr_num_str):
"""
This keyword is used to select ip addresses randomly in ADA environment
#COMMAND: fsclish -c "show networking instance default address"
| Parameters | Man. | Description |
| ip_addr_num_str | Yes | the number of IP addresses which needed |
| Return value | an Instance of list with common item element instance |
Example
| result | select_random_IP_address_and_recovery_group | 5 |
"""
eitp_ip_pool = []
ip_addr_num = atoi(ip_addr_num_str)
eitp_ip_list = _get_available_ip_with_sepcified_recovery_group_type('GFCP')
for list_item in eitp_ip_list:
eitp_ip_pool.extend(list_item)
if len(eitp_ip_pool) < ip_addr_num:
exceptions.raise_ILError("ILOutputParseError",
"Not enough IP Address with requirement")
random.shuffle(eitp_ip_pool)
return eitp_ip_pool[0:ip_addr_num]
def select_different_IP_address_in_different_recovery_group(ip_addr_num_str):
"""
This keyword is used to select ip addresses from different recovery groups randomly
#COMMAND: fsclish -c "show networking instance default address"
| Parameters | Man. | Description |
| ip_addr_num_str | Yes | the number of IP addresses which needed |
| Return value | an Instance of list with common item element instance |
Example
| result | select_different_IP_address_in_different_recovery_group | 5 |
"""
eitp_ip_list = _get_available_ip_with_sepcified_recovery_group_type('QNUP')
ip_addr_num = atoi(ip_addr_num_str)
if len(eitp_ip_list) < ip_addr_num:
exceptions.raise_ILError(
"ILOutputParseError",
"Not enough QNUP to provide IP Address with requirement")
random.shuffle(eitp_ip_list)
temp_eitp_ip_list = []
for info in eitp_ip_list[0:ip_addr_num]:
random.shuffle(info)
temp_eitp_ip_list.append(info[0])
return temp_eitp_ip_list
def nice_value_should_be_correct(top_nice_values, nice_value):
result = 0
nice_values_len = len(top_nice_values)
for i in range(nice_values_len):
if (top_nice_values[i] == nice_value):
result = 1
if (result == 0):
exceptions.raise_ILError("ILCommandExecuteError",
"The nice value is not correct.")
def monster_should_start_failed_with_invalid_nice_value(invalid_nice_value):
#Error: invalid -P parameter, the nice value should be in range [-20, 19]
command = 'monster -P %s' % (invalid_nice_value)
out = connections.execute_mml_without_check(command)
result_list = out.splitlines()
result_list_len = len(result_list)
for i in range(result_list_len):
print result_list[i]
if result_list[i].count(
'Error: invalid -P parameter, the nice value should be valid'
) > 0:
result = result_list[i]
return result
exceptions.raise_ILError(
"ILCommandExecuteError",
"The error output is not found for invalid nice value.")
def check_alarm_of_name_server(file_name):
"""This keyword is to add service of name server.
#COMMAND: cat file_name
| Parameters | Man. | Description |
| file_name | Yes | The alarm file
| Return value | name server alarm exists in the file or not |
Example
| Check Alarm Of Name Server | test.txt |
"""
command = "cat " + file_name
output = connections.execute_mml(command)
if output.count('SP=13') == 0:
exceptions.raise_ILError("ILCommandExecuteError", output)
def list_content_of_name_server(service_name):
"""This keyword is to get the service pid by the service name
#COMMAND: nasext g service_name
| Parameters | Man. | Description |
| service_name | Yes | The name of the service
| Return value |call detail information (CommonItem)
can support the following attributes:
*service_pid.Computer
*service_pid.Family
*service_pid.Process
*service_pid.Focus
*service_pid.Group
*service_pid.Delivery
*service_pid.Attr
Example
| Get Service Pid Of Name Server | test_service |
"""
command = "nasext lc " + service_name
output = connections.execute_mml(command)
item = 'Index\s*:\s*(\d+)\w+\s+Service name :\s*([a-zA-Z0-9\-_]+)\s*Real location :\s*(\d+)\s*Computer :\s*(\w+)\s*Family :\s*(\d+)\s*Process Id :\s*(\d+)\s*Focus :\s*(\d+)\s*Group service :\s*(\d+)\s*Local service :\s*(\d+)\s*Replaceable :\s*(\d+)\s*Msg group :\s*(\d+)\s*Delivery :\s*(\d+)\s*Attributes :\s*(\d+)\s*Number of use :\s*(\d+)\s*Token :\s*(\d+)\s*In use :\s*(\d+)\s*Can show :\s*(\d+)'
match = re.search(item, output)
print match
if match is not None:
service_pid = CommonItem()
service_pid.Name = match.group(2)
service_pid.Computer = match.group(4)
service_pid.Family = match.group(5)
service_pid.Process = match.group(6)
service_pid.Focus = match.group(7)
service_pid.Group = match.group(8)
service_pid.Local = match.group(9)
service_pid.Replace = match.group(10)
service_pid.GroupNum = match.group(11)
service_pid.Delivery = match.group(12)
service_pid.Attr = match.group(13)
return service_pid
else:
exceptions.raise_ILError("ILCommandExecuteError", output)
def _file_should_exist(dir_name, file_name):
"""This keyword is to check if the file exists
| Parameters | Man. | Description |
| dir_name | Yes | the directory name |
| file_name | Yes | the file name |
| Return value | file_length |
"""
file_length = 0
command = "ll /var/log/%s/%s" % (dir_name, file_name)
out = connections.execute_cli(command)
if (out.count('No such file or directory') > 0):
exceptions.raise_ILError("ILCommandExecuteError",
"The compressed file is not saved.")
else:
file_length = out.split()[4]
print file_length
return file_length
def show_ip_address(ipaddress):
"""
This keyword is used to show the ip address in SCLI
#COMMAND: fsclish -c "show show networking address ip-address <ip_addr>"
| Parameters | Man. | Description |
| ipaddress | Yes | IP address |
| Return value | command execution result |
Example
| result | show_ip_address | 12.0.0.1 |
"""
command = """fsclish -c "show networking address ip-address %s" """ % (
ipaddress)
print "Command: " + command
output = connections.execute_mml_without_check(command)
if output == "" or output == " ":
exceptions.raise_ILError("ILCommandExecuteError",
"ip address infomation doesn't exist")
if output.find("type") != -1:
pattern = re.compile(
"""\s+IP addresses in\s+\S+\s+instance:\s+(?P<inface>\S+)\s+type\s+:\s+(?P<type>\S+)\s+address\s+:\s+(?P<address>\S+)\s+owner\s+:\s+(?P<owner>\S+)\s+$"""
)
else:
pattern = re.compile(
"""\s+IP addresses in\s+\S+\s+instance:\s+(?P<inface>\S+)\s+address\s+:\s+(?P<address>\S+)\s+owner\s+:\s+(?P<owner>\S+)\s+$"""
)
match = re.match(pattern, output)
if match:
return match.groupdict()
else:
print "not match"
exceptions.raise_ILError("ILCommandExecuteError",
"ip address infomation doesn't exist")
return {}
def list_service_pid_of_name_server(service_name):
"""This keyword is to list the service PID of the speceified serivce name
#COMMAND: nasext lp service_name
| Parameters | Man. | Description |
| service_name | Yes | The name of the service
| Return value |call detail information (CommonItem)
can support the following attributes:
*service_pid.Computer
*service_pid.Family
*service_pid.Process
*service_pid.Focus
*service_pid.Group
*service_pid.Delivery
*service_pid.Attr
Example
| List Service Pid Of Name Server | test_service |
"""
command = "nasext lp " + service_name
output = connections.execute_mml(command)
item = '\s*Computer\s*:\s*(\w+)\s*Family\s*:\s*(\w+)\s*Process\s*Id\s*:\s*(\w+)\s*Focus\s*:\s*(\w+)\s*Group\s*number\s*:\s*(\w+)\s*Delivery\s*:\s*(\w+)\s*Attr\s*:\s*(\w+)\s*'
items = re.findall(item, output)
if items is None:
exceptions.raise_ILError("ILCommandExecuteError", output)
result = []
for item in items:
service_pid = CommonItem()
service_pid.Computer = item[0]
service_pid.Family = item[1]
service_pid.Process = item[2]
service_pid.Focus = item[3]
service_pid.Group = item[4]
service_pid.Delivery = item[5]
service_pid.Attr = item[6]
result.append(service_pid)
return result
def check_bin_header_is_correct(dir_name, files_name):
"""This keyword is to check whether the LIBGEN bin header is correct or not.
| Parameters | Man. | Description |
| dir_name | Yes | the directory name |
| files_name | Yes | the array of files name |
| Return value | None |
Example
| check bin header is correct | monster_test | ["test1-000.bin","test1-001.bin"] |
"""
bin_header_context = "0000000 0000 000c 0003 0000 0000 0000"
file_count = len(files_name)
for i in range(file_count):
command = "hexdump -n 16 /var/log/" + dir_name + "/" + files_name[i]
output = connections.execute_mml_without_check(command)
if (output.count(bin_header_context) <= 0):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The LIBGEN bin header is not correct for file: %s." %
files_name[i])
def select_different_IP_address_in_same_recovery_group(ip_addr_num_str):
"""
This keyword is used to select ip addresses from same recovery group randomly
#COMMAND: fsclish -c "show networking instance default address"
| Parameters | Man. | Description |
| ip_addr_num_str | Yes | the number of IP addresses which needed |
| Return value | an Instance of list with common item element instance |
Example
| result | select_different_IP_address_in_same_recovery_group | 5 |
"""
eitp_ip_list = _get_available_ip_with_sepcified_recovery_group_type('QNUP')
ip_addr_num = atoi(ip_addr_num_str)
random.shuffle(eitp_ip_list)
for list_item in eitp_ip_list:
if len(list_item) < ip_addr_num:
continue
random.shuffle(list_item)
return list_item[0:ip_addr_num]
exceptions.raise_ILError("ILOutputParseError",
"Not enough IP Address with requirement")
def get_pending_result_of_name_server():
"""This keyword is to get the pending request result from the result file
#COMMAND: cat file
| Parameters | Man. | Description |
| Return value |call detail information (CommonItem)
can support the following attributes:
*service_pid.Computer
*service_pid.Family
*service_pid.Process
*service_pid.Focus
*service_pid.Group
*service_pid.Delivery
*service_pid.Attr
Example
|${result} | Get Pending Result Of Name Server |
"""
command = 'cat ' + result_file
output = connections.execute_mml(command)
item = '\s*Computer\s*:\s*(\w+)\s*Family\s*:\s*(\w+)\s*Process\s*id\s*:\s*(\w+)\s*Focus\s*:\s*(\w+)\s*Group\s*:\s*(\w+)\s*Delivery\s*:\s*(\w+)\s*Attr\s*:\s*(\w+)\s*'
match = re.search(item, output)
if match is not None:
service_pid = CommonItem()
service_pid.Computer = match.group(1)
service_pid.Family = match.group(2)
service_pid.Process = match.group(3)
service_pid.Focus = match.group(4)
service_pid.Group = match.group(5)
service_pid.Delivery = match.group(6)
service_pid.Attr = match.group(7)
return service_pid
else:
exceptions.raise_ILError("ILCommandExecuteError", output)
def get_service_pid_of_name_server(service_name):
"""This keyword is to get the service pid by the service name
#COMMAND: nasext g service_name
| Parameters | Man. | Description |
| service_name | Yes | The name of the service
| Return value |call detail information (CommonItem)
can support the following attributes:
*service_pid.Computer
*service_pid.Family
*service_pid.Process
*service_pid.Focus
*service_pid.Group
*service_pid.Delivery
*service_pid.Attr
Example
| Get Service Pid Of Name Server | test_service |
"""
command = "nasext g " + service_name
output = connections.execute_mml(command)
item = '\s*Computer\s*:\s*(\w+)\s*Family\s*:\s*(\w+)\s*Process\s*id\s*:\s*(\w+)\s*Focus\s*:\s*(\w+)\s*Group\s*:\s*(\w+)\s*Delivery\s*:\s*(\w+)\s*Attr\s*:\s*(\w+)\s*'
match = re.search(item, output)
if match is not None:
service_pid = CommonItem()
service_pid.Computer = match.group(1)
service_pid.Family = match.group(2)
service_pid.Process = match.group(3)
service_pid.Focus = match.group(4)
service_pid.Group = match.group(5)
service_pid.Delivery = match.group(6)
service_pid.Attr = match.group(7)
return service_pid
else:
exceptions.raise_ILError("ILCommandExecuteError", output)
def check_value(self, message_type, version):
if (self.header_t_identifier <> "c5c5"):
exceptions.raise_ILError("ILCommandExecuteError",
"The header_t_identifier is not c5c5.")
if (self.header_t_message_type <> message_type):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The header_t_message_type is not %s." % message_type)
if (self.header_t_version <> version):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The header_t_version is not %s." % version)
def messages_can_be_read_successfully_from_file(dir_name,
files_name,
test_prb,
message_number,
total_message_count,
header_only='0'):
"""This keyword is to use readste to read the monitored files and check message prb, message number, total message count is correct.
| Parameters | Man. | Description |
| dir_name | Yes | the directory name |
| files_name | Yes | the array of files name |
| test_prb | Yes | test prb number |
| message_number | Yes | message number |
| total_message_count | Yes | total message count |
| Return value | None |
Example
| message can be read successfully from file | monster_test | ["test1","test2"] | C385 | 8000 | 10 |
"""
files_name_len = len(files_name)
check_test_prb = 0
check_message_number = 0
check_message_count = 0
test_prb = test_prb[2:6]
received_test_prb = "RECEIVED BY: %s" % (test_prb)
for i in range(files_name_len):
file_name = files_name[i]
_file_should_exist(dir_name, file_name)
file_name = "/var/log/%s/%s" % (dir_name, file_name)
if (header_only == '1'):
command = "readste -H -i %s" % (file_name)
else:
command = "readste -i %s" % (file_name)
output = connections.execute_mml_without_check(command)
l = get_msg_from_buf(output)
msg_list = [parse_msg(i) for i in l]
for msg in msg_list:
if msg['recv']['computer'] <> int(test_prb, 16):
print msg['recv']['computer'], int(test_prb, 16)
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monitored message family is not %s." % test_prb)
if msg['msg']['number'] <> int(message_number, 16):
print msg['msg']['number'], int(message_number, 16)
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monitored message number is not %s." % message_number)
check_message_count = check_message_count + len(msg_list)
print 'msg count: ', check_message_count
if (check_message_count <> int(total_message_count)):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The total message count is not %s." % total_message_count)
def release_iub_leg(call_id, leg_id="IN", computer="USCP-0"):
"""
This keyword is used to release iub leg
#COMMAND: lgutilgx RV:<computer>:<call_id>:<leg_id>
| Parameters | Man.| Description |
| call_id | Yes | call ID |
| leg_id | No | Leg ID |
| computer | No | recovery unit where the leg reserved, default is USCP-0 |
| Return value | an instance of CommonItem |
Example
| result | release_iub_leg | ${CALL_ID} | ${LEG_ID}| ${USCP-0} |
"""
command = """lgutilgx RV:%s:%s:%s""" % (computer, call_id, leg_id)
exec_output = connections.execute_mml_without_check(command)
if -1 == exec_output.find("RELEASING SUCCESSFUL"):
raise exceptions.raise_ILError("ILCommandExecuteError", exec_output)
return "success"
def release_iucs_leg(call_id, computer="USCP-0"):
"""
This keyword is used to release iucs leg
# COMMAND: lgutilgx RV:USCP-0:123:OUT
| Parameters | Man.| Description |
| call_id | Yes | IPBR ID |
| computer | No | recovery unit where the leg reserved, default is USCP-0 |
| Return value | string "success" when the operation success |
Example
| result | release_iucs_leg | ${CALL_ID} | ${USCP-0} |
"""
command = """lgutilgx RV:%s:%s:OUT""" %(computer, call_id)
print "execute command:", command
exec_output = connections.execute_mml_without_check(command)
if -1 == exec_output.find("RELEASING SUCCESSFUL"):
raise exceptions.raise_ILError("ILCommandExecuteError", exec_output)
return "success"
def release_specfied_call(call_id, computer, hand_id, focus_id):
"""
This keyword is used to release specified call with rm2prb hand's hand id and focus id
#COMMAND: lgutilgx RID:CSPU-0:123,OUT; lgutilgx RID:CSPU-0:123,IN-01
| Parameters | Man.| Description |
| call_id | Yes | Call ID |
| computer | Yes | CP name |
| hand_id | Yes | rm2prb hand's Hand ID of the call |
| focus_id | Yes | rm2prb hand's Focus ID of the call |
| Return value | None |
Example
| release_specfied_call | call_id | computer | hand_id | focus_id |
"""
release_flag = True
command = """lgutilgx RID:%s:%s,%s""" % (computer, hand_id, focus_id)
print "collect call info with command:", command
call_info_str = connections.execute_mml_without_check(command)
leg_pattern = re.compile("RES_TYPE\s+PRID\s+ENC\s+CAC_ALLOC\s+(\S+)")
leg_list = leg_pattern.findall(call_info_str)
for leg in leg_list:
if leg != "OUT":
command = "lgutilgx RV:%s:%s:%s" %(computer, call_id, leg)
result = connections.execute_mml_without_check(command)
if -1 == result.find("SUCCESSFUL"):
release_flag = False
if "OUT" in leg_list:
command = "lgutilgx RV:%s:%s:OUT" %(computer, call_id)
result = connections.execute_mml_without_check(command)
if -1 == result.find("SUCCESSFUL"):
release_flag = False
if release_flag == False:
raise exceptions.raise_ILError("ILCommandExecuteError", "release leg failed")
def check_value(self, phy_addr, log_addr, m_t_agent_type, m_t_montype,
m_t_spare):
if (self.monheader_t_ident <> "c6c6"):
exceptions.raise_ILError("ILCommandExecuteError",
"The monheader_t_ident is not c6c6.")
if (self.monheader_t_unitmbaddr <> phy_addr[2:6]):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monheader_t_unitmbaddr is not %s." % phy_addr[2:6])
if (self.monheader_t_unitlgaddr <> log_addr[2:6]):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monheader_t_unitlgaddr is not %s." % log_addr[2:6])
if (self.monheader_t_agenttype_t <> m_t_agent_type):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monheader_t_agenttype_t is not %s." % m_t_agent_type)
if (self.monheader_t_montype <> m_t_montype):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monheader_t_montype is not %s." % m_t_montype)
if (self.monheader_t_spare <> m_t_spare):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The monheader_t_spare is not %s." % m_t_spare)
def check_c6c6_headers_count(self, c6c6_count):
if self.c6c6_headers_count <> int(c6c6_count):
exceptions.raise_ILError(
"ILCommandExecuteError",
"The c6c6 headers count is not %s." % c6c6_count)
def monster_output_file_format_is_correct_according_givaxi_monitoring_interface(
dir_name, file_name, omu_phy_address, omu_log_address):
"""This keyword is to check that the file is saved correctly according to givaxi monitoring interface
| Parameters | Man. | Description |
| output_dir | Yes | the directory name |
| output_file | Yes | the file name |
| omu_phy_address | Yes | the omu physical address |
| omu_log_address | Yes | the omu logical address |
| Return value | all headers length(c5c5, c6c6) |
Example
| monster output file format is correct according to givaxi monitoring interface | monster_test | test.mgi | 0x0100 | 0x4002 |
"""
headers_length = []
_file_should_exist(dir_name, file_name)
output_givaxi_message = givaxi_message()
temp_file = "givaxi_file_temp.mgi"
command = "rm -f /var/log/%s/%s" % (dir_name, temp_file)
connections.execute_mml_without_check(command)
command = "cp -f /var/log/%s/%s /var/log/%s/%s" % (dir_name, file_name,
dir_name, temp_file)
connections.execute_mml_without_check(command)
#dump the c5c5 header
header_items = _dump_header_content_according_header_length(
dir_name, temp_file, "c5c5")
output_givaxi_message.set_c5c5_header_from_file(header_items)
header_length = str(
int(output_givaxi_message.c5c5_header.header_t_length, 16))
headers_length.append(header_length)
##remove the c5c5 header from the file
data_left = _remove_data_from_file(header_length, dir_name, temp_file)
if (data_left == 1):
c6c6_header_left = 1
else:
c6c6_header_left = 0
exceptions.raise_ILError(
"ILCommandExecuteError",
"There are no c6c6 headers found in the file.")
while (c6c6_header_left == 1):
header_items = _dump_header_content_according_header_length(
dir_name, temp_file, "c6c6")
c6c6_index = output_givaxi_message.set_c6c6_header_from_file(
header_items, omu_phy_address, omu_log_address)
header_length = str(
int(
output_givaxi_message.c6c6_headers[c6c6_index].
monheader_t_length, 16))
headers_length.append(header_length)
##remove the c6c6 header and data from the file
data_left = _remove_data_from_file(header_length, dir_name, temp_file)
if (data_left == 0):
c6c6_header_left = 0
output_givaxi_message.print_value()
command = "rm -f /var/log/%s/%s" % (dir_name, temp_file)
connections.execute_mml(command)
return headers_length