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 _parse_release_result(output):
#lines = output.strip().splitlines()
return_value = CommonItem()
if (-1 != output.lower().find("success")):
return_value.result = "success"
else:
return_value.result = "failed"
return return_value
def _cac_release_all_leg_objects(command):
exec_output = connections.execute_mml_without_check(command)
return_value = CommonItem()
if (-1 != exec_output.lower().find("success")):
return_value.result = "success"
else:
return_value.result = "failed"
return return_value
def get_feature_license(feature_name=''):
command = 'fsclish -c "show license all" '
result = connections.execute_mml_without_check(command)
lines = result.splitlines()
license_list = CommonDict()
key = '0'
for line in lines:
items = line.split(':')
if len(items) != 2:
continue
if items[0].strip() == 'Unique ID':
key = items[1].strip()
license_list[key] = CommonItem()
if key == '0':
print 'no key'
continue
setattr(license_list[key], items[0].strip().replace(' ', '_').lower(),
items[1].strip())
if not feature_name:
return license_list
for unique_id in license_list:
if license_list[unique_id].feature_name_list == feature_name:
return license_list[unique_id]
return
def get_counters_in_cac():
"""
This keyword is used to shows counters in CAC part.
#COMMAND: fsclish -c "show troubleshooting cac leg"
| Parameters | Man. | Description |
| NA | | |
| Return value | an Instance of list with legs number and capacity |
Example
| result | get_couters_in_cac | |
"""
command = """fsclish -c "show troubleshooting cac leg" """
print "Command: " + command
output = connections.execute_mml_without_check(command)
pattern = re.compile(
'''^.*
UDP\sleg\s:\s+(?P<udp_num>\d+)\s+
RTP\sleg\s:\s+(?P<rtp_num>\d+)\s+
GTP\sleg\s:\s+(?P<gtp_num>\d+)\s+
Capacities:\s+
UDP\sand\s+RTP\s+leg\s+:\s+(?P<udp_rtp_leg_capacity>\d+)\s+
GTP\sleg\s+:\s+(?P<gtp_leg_capacity>\d+)\s+
''', re.VERBOSE | re.DOTALL)
item = pattern.match(output)
leg_info = CommonItem()
if item:
leg_list = item.groupdict()
leg_info.udp_num = leg_list['udp_num']
leg_info.rtp_num = leg_list['rtp_num']
leg_info.gtp_num = leg_list['gtp_num']
leg_info.udp_rtp_leg_capacity = leg_list['udp_rtp_leg_capacity']
leg_info.gtp_leg_capacity = leg_list['gtp_leg_capacity']
return leg_info
def _search_vcp_connection_list_with_conn_id(conn_id):
command = """vcp_conn_list -c 0x%s""" %(conn_id)
exec_output = connections.execute_mml_without_check(command)
items = exec_output.strip().splitlines()
vcp_res = {}
for item in items:
infos = item.split("|")
if len(infos) == 10:
vcp_res = CommonItem()
vcp_res.index = infos[0].strip()
vcp_res.conn_id =infos[1].strip()
vcp_res.owner_id =infos[2].strip()
vcp_res.type =infos[3].strip()
local_ip = infos[4].strip().split(":")
vcp_res.local_ip=local_ip[1].strip()
vcp_res.local_port = local_ip[2].strip()
remote_ip = infos[5].strip().split(":")
vcp_res.remote_ip=remote_ip[1].strip()
vcp_res.remote_port=remote_ip[2].strip()
return vcp_res
def create_ipro_attribute_instance_with_specified_parameters(attribute_string):
attribute_items = attribute_string.split()
attribute_instance = CommonItem()
attribute_instance.ipbr_id = ''
attribute_instance.iface = ''
attribute_instance.ip_address = ''
attribute_instance.owner = ''
attribute_instance.mode = ''
attribute_instance.phb_set = ''
attribute_instance.vrf = ''
for attribute in attribute_items:
items = attribute.split('=')
if len(items) != 2:
continue
setattr(attribute_instance, items[0].lower().strip(), items[1].strip())
return attribute_instance
def search_iu_transport_info_in_tf_table(leg_info):
"""
This keyword is used to search transport information in TF routine table
#COMMAND: lgutilgx RID:USCP-0:1,2; vcp_conn_list -c 0x12345
| Parameters | Man.| Description |
| leg_info | Yes | Iu Leg info parsed by keyword create_iucs_leg_with_cac_params |
| Return value | two instance of CommonItem, transport info in RM2 and TF table |
Example
| result | search_iu_transport_info_in_tf_table | ${iu_leg_info} |
"""
command = """lgutilgx RID:%s:%s,%s""" % (leg_info.computer, leg_info.hand_id, leg_info.focus_id)
exec_output = connections.execute_mml_without_check(command)
pattern = re.compile("""CONNECTION\s+ID:(\S+)""")
leg_pattern = re.compile("""RES_TYPE\s+PRID\s+ENC\s+CAC_ALLOC\s+OUT\s+IPv4\s+(\S+):(\S+)""")
rg_pattern = re.compile("""PROVIDER\s+QNUP-(\S+)""")
conn_id = pattern.findall(exec_output)[0]
rg_index = rg_pattern.findall(exec_output)
result = leg_pattern.findall(exec_output)
rm2_info = CommonItem()
rm2_info.ip = result[0][0]
rm2_info.port = result[0][1]
eitpuptrm_list = upm_lib.class_all_units_info('QUNP')
eitpuptrm_key = 'QNUP-000%d' % (int(rg_index[0]))
print "QNUP key:",eitpuptrm_key
starter_fileparse.change_ru(eitpuptrm_list[eitpuptrm_key].moname)
vcp_info = _search_vcp_connection_list_with_conn_id(conn_id)
# if (connections.execute_mml('echo $HW_PLATFORM').count('BCN') > 0):
# ssh_eipu = 'ssh EIPU-%d' % (int(rg_index[0]))
# connections.execute_mml(ssh_eipu)
# for conn_id in result:
# vcp_info = _search_vcp_connection_list_with_conn_id(conn_id)
# connections.execute_mml('exit')
# else:
# vcp_info = _search_vcp_connection_list_with_conn_id(conn_id)
return rm2_info, vcp_info
def _get_available_ip_with_sepcified_recovery_group_type(rg_type):
command = 'fsclish -c "show networking instance default address"'
output = connections.execute_mml_without_check(command)
if output.find('type') != -1:
ip_addr_pattern_str = "(\w+)\s+type\s+:\s+(\w+)\s+address\s+:\s+(\d+.\d+.\d+.\d+)/(\d+)\s+owner\s+:\s+(\S+)"
iface_index = 0
addr_index = 2
owner_index = 4
else:
ip_addr_pattern_str = "(\w+)\s+address\s+:\s+(\d+.\d+.\d+.\d+)/(\d+)\s+owner\s+:\s+(\S+)"
iface_index = 0
addr_index = 1
owner_index = 3
ip_addr_list = re.findall(ip_addr_pattern_str, output)
eitp_ip_list = []
for ip_info in ip_addr_list:
if ip_info[addr_index].startswith('169.254'):
continue
if -1 == ip_info[owner_index].find(rg_type):
continue
temp_items = ip_info[owner_index].split('-')
if len(temp_items) == 1:
index = 0
else:
index = atoi(temp_items[1])
if index >= len(eitp_ip_list):
for i in range(len(eitp_ip_list), index + 1):
eitp_ip_list.append([])
ip_content = CommonItem()
ip_content.rg_name = ip_info[owner_index]
ip_content.ip_addr = ip_info[addr_index]
ip_content.iface = ip_info[iface_index]
eitp_ip_list[index].append(ip_content)
return eitp_ip_list
def get_leg_cac_info(ip_addr, port_id):
"""
This keyword is used to basic ipbr config information from CAC PRB
#COMMAND: iltrmcli -S -u <IP Address> <Port ID>
| Parameters | Man. | Description |
| ip_addr | Yes | IP address |
| port_id | Yes | port ID |
| Return value | an Instance of commonitem |
Example
| result | Get Leg CAC Info | 10.1.2.4 | 4000 |
"""
result = inquiry_udp_conn_resource_info(ip_addr, port_id)
ip_port = '%s:%s' % (ip_addr, port_id)
return_var = CommonItem()
if result.has_key(ip_port):
return_var.port = port_id
return_var.ipbr_id = result[ip_port]["ipbr_id"]
return_var.bw = result[ip_port]["reserve_bw"]
return return_var
def _parse_in_leg_creation_output(exec_output):
result = CommonItem()
if (-1 != exec_output.find("SUCCESSFUL")):
pattern = re.compile("""^.*IP-RESOURCE\s+(IN-\d+)\s+RESERVED\s+(\S+).*IPv4\s+Addr:\s+(\d+\.\d+\.\d+\.\d+)\s+:\s*(\d+).*$""", re.DOTALL)
match = re.match(pattern, exec_output)
if match:
result.result = "success"
result.leg_id = match.group(1)
result.ip = match.group(3)
result.port = match.group(4)
elif (-1 != exec_output.find("FAILED")):
pattern = re.compile("""^.*IP-RESOURCE\s+RESERVATION\s+(\S+),\s*EC=(\S+).*$""", re.DOTALL | re.VERBOSE)
match = re.match(pattern, exec_output)
if match:
result.result = "failed"
result.error_code = match.group(2)
else:
result.result = "failed"
return result
def release_all_udp_conn_resource():
"""
This keyword is used to release all UDP connection resource in CACPRB
#COMMAND: iltrmcli -D -u all
| Parameters | Man.| Description |
| | | |
| Return value | an instance of String, success or failed |
Example
| result | release all udp conn resource |
"""
command = "iltrmcli -D -u all"
print "Command:", command
exec_output = connections.execute_mml_without_check(command)
return_value = CommonItem()
if (-1 != exec_output.lower().find("success")):
return_value.result = "success"
else:
return_value.result = "failed"
return return_value
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 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 _parse_out_leg_creation_output(exec_output):
result = CommonItem()
if (-1 != exec_output.find("SUCCESSFUL")):
pattern = re.compile("""^.*CALL_ID\s+(\S+).*RM2\s+HAND\s+=\s+(\S+)\s+(\S+).*IPv4\s+Addr:\s+(\d+\.\d+\.\d+\.\d+)\s+:\s*(\d+).*$""", re.DOTALL)
match = re.match(pattern, exec_output)
if match:
result.result = "success"
result.call_id = match.group(1)
result.hand_id = match.group(2)
result.focus_id = match.group(3)
result.ip = match.group(4)
result.port = match.group(5)
else:
print "not match"
elif (-1 != exec_output.find("FAILED")):
pattern = re.compile("""^.*CALL_ID\s+(\S+).*EC=(\S+).*$""", re.DOTALL)
match = re.match(pattern, exec_output)
if match:
result.result = "failed"
result.call_id = match.group(1)
result.error_code = match.group(2)
return result
def get_specific_ipbr_info_in_cac(ipbr_id):
"""
This keyword is used to get ipbr resource information from CAC PRB
#COMMAND: fsclish -c "show troubleshooting cac ipbr ipbr-id <IPBR ID>"
| Parameters | Man. | Description |
| ipbr_id | Yes | IPBR ID |
| Return value | an Instance of commonitem with specific IPBR all information in CAC |
Example
| result | get_specific_ipbr_info_in_cac | 12 |
"""
command = """fsclish -c "show troubleshooting cac ipbr ipbr-id %s" """ % (
ipbr_id)
print "Command: " + command
output = connections.execute_mml_without_check(command)
if output.find('does not exist') != -1:
output = 'IPBR with ipbr-id (%s) does not exist in connection admission control part.' % (
ipbr_id)
return output
if output.find('NO WORKING') != -1:
return output
else:
pattern = re.compile(
'''^.*
IPBR\sID\s+:\s+(?P<ipbr_id>\d+)\s+
IPBR\sname\s+:\s+(?P<ipbr_name>\S+)\s+
Route\sbandwidth\s+:\s(?P<route_bw>\d+)\s+kbps\s+
Committed\sbandwidth\s+:\s(?P<cmmt_bw>\d+)\s+kbps\s+
Committed\sDCN\sbandwidth\s+:\s(?P<cmmt_dcn_bw>\d+)\s+kbps\s+
Committed\ssignaling\sbandwidth\s+:\s(?P<cmmt_sig_bw>\d+)\s+kbps\s+
Committed\suser\splane\sbandwidth\s+:\s(?P<up_bw>\d+)\s+kbps\s+
Reserved\sbandwidth\s+:\s(?P<res_bw>\S+)\s+kbps\s+
IFC\sNRTDCH\s+:\s+(?P<ifc_nrtdch>\S+)\s+
IFC\sNRTHSDPA\s+:\s+(?P<ifc_nrthsdpa>\S+)\s+
Scheduler\stype\s+:\s+(?P<scheduler_type>\S+)\s+
PHB\sprofile\sID\s+:\s+(?P<phb_profile>\d+)\s+
DSPM\sprofile\sID\s+:\s+(?P<dspm_profile>\d+)\s+
MUX\senable\s+:\s+(?P<mux_enable>\S+)\s+
Max\sMUX\spackets\snumber\s+:\s+(?P<max_mux_packet>\d+)\s+
Local\sMUX\sUDP\sport\s+:\s+(?P<local_mux_port>\d+)\s+
Remote\sMUX\sUDP\sport\s+:\s+(?P<remote_mux_port>\d+)\s+
MUX\sUDP\sDSCP\svalue\s+:\s+(?P<mux_udp_value>\d+)\s+
GTP\sleg\snumber\s+:\s+(?P<gtp_num>\d+)\s+
RTP\sleg\snumber\s+:\s+(?P<rtp_num>\d+)\s+
UDP\sleg\snumber\s+:\s+(?P<udp_num>\d+)\s+
IPBR\sstatus\s+:\s((?P<ipbr_status>\S+)\s+)
''', re.VERBOSE | re.DOTALL)
item = pattern.match(output)
ipbr_info = CommonItem()
if item:
ipbr_attr = item.groupdict()
ipbr_info.ipbr_id = ipbr_attr['ipbr_id']
ipbr_info.ipbr_name = ipbr_attr['ipbr_name']
ipbr_info.route_bw = ipbr_attr['route_bw']
ipbr_info.cmmt_bw = ipbr_attr['cmmt_bw']
ipbr_info.cmmt_dcn_bw = ipbr_attr['cmmt_dcn_bw']
ipbr_info.cmmt_sig_bw = ipbr_attr['cmmt_sig_bw']
ipbr_info.ifc_nrtdch = ipbr_attr['ifc_nrtdch']
ipbr_info.ifc_nrthsdpa = ipbr_attr['ifc_nrthsdpa']
ipbr_info.scheduler_type = ipbr_attr['scheduler_type']
ipbr_info.phb_profile = ipbr_attr['phb_profile']
ipbr_info.dspm_profile = ipbr_attr['dspm_profile']
ipbr_info.mux_enable = ipbr_attr['mux_enable']
ipbr_info.max_mux_packet = ipbr_attr['max_mux_packet']
ipbr_info.local_mux_port = ipbr_attr['local_mux_port']
ipbr_info.mux_udp_value = ipbr_attr['mux_udp_value']
ipbr_info.up_bw = ipbr_attr['up_bw']
ipbr_info.res_bw = "%d" % (atof(ipbr_attr['res_bw']) * 1000)
ipbr_info.free_bw = "%d" % (atof(ipbr_info.up_bw) -
atof(ipbr_info.res_bw))
ipbr_info.gtp_num = ipbr_attr['gtp_num']
ipbr_info.rtp_num = ipbr_attr['rtp_num']
ipbr_info.udp_num = ipbr_attr['udp_num']
ipbr_info.ipbr_status = ipbr_attr['ipbr_status']
ipbr_info.ip_list = []
else:
return ipbr_info
if output.find('No IP address bound with the IPBR.') != -1:
ipbr_info.ip_list = 'No IP address bound with the IPBR.'
else:
ip_pattern = re.compile('(\d+\.\d+\.\d+\.\d+)\s+(\d+)\s+(\S+)\s+(\S+)')
items = ip_pattern.findall(output)
for item in items:
ip_info = CommonItem()
ip_info.ip_addr = item[0]
ip_info.vrf_id = item[1]
ip_info.monitor = item[2]
ip_info.status = item[3]
ipbr_info.ip_list.append(ip_info)
return ipbr_info
def show_ipro(ipbr_id='', ip_address='', owner='', iface='', vrf=''):
"""
This keyword is used to show networking ipros
#COMMAND: fsclish -c "show networking ipro ipbr-id <ipbr id> iface <interface> ip-address <ip address> owner <owner recovery group>"
| Parameters | Man. | Description |
| owner | No | owner recovery group |
| ipbr_id | No | IPBR ID |
| iface | No | network interface |
| ip_addr | No | IP address |
| Return value | instance of dictionary |
| ${result} | show networking ipro | 123 | 12.0.0.1 | /EITPUPTRMRG | ether1_1 | VRF |
"""
ipro_attributes_list_str = _set_ipro_attributes_list_str(
ipbr_id=ipbr_id,
vrf=vrf,
ip_address=ip_address,
owner=owner,
iface=iface)
command = 'fsclish -c "show networking ipro %s"' % (
ipro_attributes_list_str)
print "Execute Command:", command
ipro_info_str = connections.execute_mml_without_check(command)
if ipro_info_str.upper().find('VRF') != -1:
pattern = re.compile(
'(\d+)\s+(\d+\.\d+\.\d+\.\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)')
else:
pattern = re.compile(
'(\d+)\s+(\d+\.\d+\.\d+\.\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+')
items = pattern.findall(ipro_info_str)
if len(items) == 0:
return {'result': 'FAILED', 'error_info': ipro_info_str.strip()}
ipro_list = {'result': 'SUCCESS'}
for item in items:
ipro_info = CommonItem()
ipro_info.ipbr_id = item[0]
ipro_info.ip_address = item[1]
ipro_info.owner = item[2]
ipro_info.iface = item[3]
ipro_info.phb_set = CommonItem()
if item[4].find('ALL') != -1:
ipro_info.phb_set.ef = 'on'
ipro_info.phb_set.af4 = 'on'
ipro_info.phb_set.af3 = 'on'
ipro_info.phb_set.af2 = 'on'
ipro_info.phb_set.af1 = 'on'
ipro_info.phb_set.be = 'on'
else:
ipro_info.phb_set.ef = 'on' if item[4].find('EF') != -1 else 'off'
ipro_info.phb_set.af4 = 'on' if item[4].find(
'AF4') != -1 else 'off'
ipro_info.phb_set.af3 = 'on' if item[4].find(
'AF3') != -1 else 'off'
ipro_info.phb_set.af2 = 'on' if item[4].find(
'AF2') != -1 else 'off'
ipro_info.phb_set.af1 = 'on' if item[4].find(
'AF1') != -1 else 'off'
ipro_info.phb_set.be = 'on' if item[4].find('BE') != -1 else 'off'
if ipro_info_str.upper().find('VRF') != -1:
ipro_info.vrf = item[5]
ipro_key = ipro_info.ipbr_id + "@" + ipro_info.ip_address + "@" + ipro_info.iface + "@" + ipro_info.owner
ipro_list[ipro_key] = ipro_info
return ipro_list
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 initialize_IP_based_route_attribute_with_default_value(attribute_string):
attribute_items = attribute_string.split()
attribute_instance = CommonItem()
attribute_instance.ipbr_id = ''
attribute_instance.ipbr_name = ''
attribute_instance.route_bw = '1000'
attribute_instance.commit_bw = '1000'
attribute_instance.commit_sig_bw = '0'
attribute_instance.commit_dcn_bw = '0'
attribute_instance.ifc_nrtdch = 'E-RED'
attribute_instance.ifc_nrthsdpa = 'E-RED'
attribute_instance.scheduler_type = 'none'
attribute_instance.phb_profile = '0'
attribute_instance.dspm_profile = '0'
attribute_instance.mux_flag = 'disable'
attribute_instance.max_mux_pkt_num = '30'
attribute_instance.mux_local_port = '65535'
attribute_instance.mux_remote_port = '65535'
attribute_instance.mux_udp_dscp = '46'
for attribute in attribute_items:
items = attribute.split('=')
if len(items) != 2:
continue
setattr(attribute_instance, items[0].lower().strip(), items[1].strip())
return attribute_instance
def create_ipbr_attribute_instance_with_specified_parameters(
attribute_string, operation):
attribute_items = attribute_string.split()
attribute_instance = CommonItem()
attribute_instance.ipbr_id = ''
if (operation == 'update'):
attribute_instance.ipbr_name = ''
attribute_instance.route_bw = ''
attribute_instance.commit_bw = ''
attribute_instance.commit_sig_bw = ''
attribute_instance.commit_dcn_bw = ''
else:
attribute_instance.ipbr_name = 'test-ipbr'
attribute_instance.route_bw = '1000'
attribute_instance.commit_bw = '1000'
attribute_instance.commit_sig_bw = '0'
attribute_instance.commit_dcn_bw = '0'
attribute_instance.ifc_nrtdch = ''
attribute_instance.ifc_nrthsdpa = ''
attribute_instance.scheduler_type = ''
attribute_instance.phb_profile = ''
attribute_instance.dspm_profile = ''
attribute_instance.mux_flag = ''
attribute_instance.max_mux_pkt_num = ''
attribute_instance.mux_local_port = ''
attribute_instance.mux_remote_port = ''
attribute_instance.mux_udp_dscp = ''
for attribute in attribute_items:
items = attribute.split('=')
if len(items) != 2:
continue
setattr(attribute_instance, items[0].lower().strip(), items[1].strip())
return attribute_instance
import os
from comm.communication.helper import CommonItem, CommonDict
from ilcallmgmt_subsystem_lib import library
#### OS Env
ENV = CommonItem()
ENV.HOSTIP = os.getenv('HOSTIP', '')
ENV.SRNC = os.getenv('HOSTIP', '')
ENV.DRNC = os.getenv('FGW2IP', '')
ENV.USERNAME = os.getenv('USERNAME', '')
ENV.PASSWD = os.getenv('PASSWD', '')
ENV.PORT = os.getenv('PORT', '')
ENV.FPCIP = os.getenv('FPCIP', '')
ENV.NODEBIP = os.getenv('FPCIP_ETH1', '')
ENV.RNC_IUB_IP = os.getenv('DSP0_IUB_IP', '')
ENV.RNC_IUR_IP = os.getenv('DSP0_IUR_IP', '')
ENV.RNC_IUCS_IP = os.getenv('DSP0_IUCS_IP', '')
ENV.RNC_IUPS_IP = os.getenv('DSP0_IUPS_IP', '')
#print 'ENV={%s}' % ENV
###########################################################################################
#### CM CALL MODEL ########################################################################
# CM VAR
CM_VAR = CommonItem()
CM_VAR.TESTDATA_PATH = '/home/public/SS_ILFT/TestData/NODEB'
#CM_VAR.USCP0 = os.getenv('USCP_TYPE_NAME', '') + '-' + os.getenv('USUP_0_INDEX', '')
#CM_VAR.CSCP0 = os.getenv('CSCP_TYPE_NAME', '') + '-' + os.getenv('CSUP_0_INDEX', '')
CM_VAR.USCP0 = 'USCP-0'
CM_VAR.CSCP0 = 'CSCP-0'
