def sz100_get_alarms(self, search_value, search_type="and"):
sz_get_alarm_url = ji.get_url(
self.sz_req_api_monitor_alarms % (search_type, search_value),
self.scg_mgmt_ip, self.scg_port)
recv_data = ji.get_json_data(sz_get_alarm_url, self.jsessionid)
al_list = recv_data['data']['list']
return al_list
def find_report_title(self, report_title='myreport'):
"""
API is used to Find REport Title
URI GET: '/wsg/api/scg/reports'
:param str report_title: Report Title
:return: dictionary containing report entry if Report Title Found else None
:rtype: dictionary
"""
try:
url = ji.get_url(self.req_api_reports, self.scg_mgmt_ip,
self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
for report_entry in recvd_data['data']['list']:
if report_entry['title'] == report_title:
return report_entry
return None
except Exception, e:
print traceback.format_exc()
return None
def get_license_count(self):
url = ji.get_url(self.LIC_UE_API,self.scg_mgmt_ip,self.scg_port)
lic_data = ji.get_json_data(url,self.jsessionid)
for licd in lic_data["data"]["licenseUsageList"]:
if licd["type"] == "UE":
ue_lic_consumed = licd["usedCount"]
def cluster_backup(self):
recvd_data = None
validate_data = None
self.json_url = "/wsg/api/scg/backup/cluster"
self.validate_status = "/wsg/api/scg/patches/upgrade/status"
try:
data = ''
url = ji.get_url(self.json_url, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.post_json_data(url, self.jsessionid, data)
#recvd_data=True
if not recvd_data:
return None
else:
while True:
validate_url = ji.get_url(self.validate_status,
self.scg_mgmt_ip, self.scg_port)
validate_data = ji.get_json_data(validate_url,
self.jsessionid)
if "data" in validate_data.keys():
if validate_data["data"]["previousOperationRecord"][
"success"] == True:
return True
print "Backup operation is in progress. Sleeping for 30 sec..."
time.sleep(30)
except Exception, e:
#print "COMING INSIDE EXCEPTION"
print traceback.format_exc()
return None
def get_control_blade_uuid(self, cblade_label='mylabel'):
is_entry_found = False
uuid = None
try:
url = ji.get_url(self.req_api_control_blade_uuid, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
if len(recvd_data['data']['list']) >= 1:
for data in recvd_data['data']['list']:
if data['label'] == cblade_label:
uuid = data['bladeUUID']
is_entry_found = True
break
else:
print "get_control_blade_uuid(): No data.list recvd"
return uuid
if not is_entry_found:
print "get_control_blade_uuid(): cblade_label: %s not found" % cblade_label
return uuid
except Exception, e:
print traceback.format_exc()
return uuid
def delete_snmpv3_agent(self, user='******'):
result = False
is_entry_found = False
snmp_agent_data = {}
delete_index = -1
try:
url = ji.get_url(self.req_api_snmp_agent, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
new_data = copy.deepcopy(recvd_data)
for i in range(len(new_data['data']['users'])):
if new_data['data']['users'][i]['userName'] == user:
delete_index = i
is_entry_found = True
break
if not is_entry_found:
print 'delete_snmpv3_agent(): user: %s does not exist' % user
return False
else:
del new_data['data']['users'][delete_index]
snmp_agent_data = new_data['data']
data_json = json.dumps(snmp_agent_data)
result = ji.put_json_data(url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def get_snmpv3_agent(self, user='******'):
result = None
is_entry_found = False
get_index = -1
try:
url = ji.get_url(self.req_api_snmp_agent, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
new_data = copy.deepcopy(recvd_data)
for i in range(len(new_data['data']['users'])):
if new_data['data']['users'][i]['userName'] == user:
get_index = i
is_entry_found = True
break
if not is_entry_found:
#print 'get_snmpv3_agent(): user: %s does not exist' % user
return None
else:
result = new_data['data']['users'][get_index]
except Exception, e:
print traceback.format_exc()
return None
def get_domain_uuid(self, domain_label='Administration Domain'):
"""
API used to find the domainUUID of given Domain Name
URI: GET /wsg/api/scg/session/currentUser/domainList?includeSelf=true
:param str domain_label: Name of the Domain
:return: domainUUID
:rtype: unicode
"""
is_entry_found = False
domain_uuid = None
url = ji.get_url(self.req_api_domains, self.scg_mgmt_ip, self.scg_port)
rcvd_data = ji.get_json_data(url, self.jsessionid)
if len(rcvd_data['data']['list']) >= 1:
for data in rcvd_data['data']['list']:
if data['label'] == domain_label:
domain_uuid = data['key']
is_entry_found = True
break
else:
raise Exception("get_domain_uuid(): No data.list recvd")
if not is_entry_found:
raise Exception("get_domain_uuid(): domain_label: %s not found" %
domain_label)
return domain_uuid
def snmpv3_add_trap_target(self, current_user='******',
trap_target_ip='1.2.3.4', trap_target_port='162'):
result = False
is_entry_found = False
snmp_agent_data = {}
update_index = -1
try:
url = ji.get_url(self.req_api_snmp_agent, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
new_data = copy.deepcopy(recvd_data)
for i in range(len(new_data['data']['users'])):
if new_data['data']['users'][i]['userName'] == current_user:
update_index = i
is_entry_found = True
break
if not is_entry_found:
print 'snmpv3_add_trap_target(): user: %s does not exist' % current_user
return False
else:
new_data['data']['users'][update_index]['traps'].append({'targetAddress' : trap_target_ip, 'targetPort' : trap_target_port})
snmp_agent_data = new_data['data']
data_json = json.dumps(snmp_agent_data)
result = ji.put_json_data(url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def verify_access_point_syslog_facility(self, ap_mac="", facility="-1"):
"""
Verify Access Point Syslog Facility
:param str ap_mac: AP mac
:param str facility: -1|16|17|18|19|20|21|22|23 (default : -1)
:return: True: if facility is selected
:rtype: boolean
"""
try:
req_ap_url = ji.get_url(self.req_api_update_ap % ap_mac,
self.scg_mgmt_ip, self.scg_port)
ap_profile_data = ji.get_json_data(req_ap_url, self.jsessionid)
ap_profile = ap_profile_data["data"]
print type(ap_profile["config"]["syslogFacility"])
if ap_profile["config"]["syslogFacility"] == int(facility):
return True
return False
except Exception, e:
print traceback.format_exc()
return False
def get_ap_fwversion_in_apzone(self, domain_label='Administration Domain', apzone_name='APZone-1'):
is_entry_found = False
domain_uuid = None
fwversion = None
try:
domain_uuid = self.get_domain_uuid(domain_label=domain_label)
if not domain_uuid:
print "get_domain_uuid(): domain_label: %s failed" % domain_label
return domain_uuid
url = ji.get_url(self.req_api_apzones % domain_uuid, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
if len(recvd_data['data']['list']) >= 1:
for data in recvd_data['data']['list']:
if data['mobilityZoneName'] == apzone_name:
fwversion = data['fmVersion']
is_entry_found = True
break
else:
print "get_ap_fwversion_in_apzone(): No data.list recvd"
return fwversion
if not is_entry_found:
print "get_ap_fwversion_in_apzone(): apzone: %s not found" % apzone_name
return fwversion
except Exception:
print traceback.format_exc()
return fwversion
return fwversion
def get_report_results(self, report_title='myreport'):
"""
API used to Get Report Results
URI GET: '/wsg/api/scg/reports/<report_uuid>/result'
:param str report_title: Report Title
:return: list of results if success else False
:rtype: list
"""
try:
report_uuid = self._get_report_uuid(report_title=report_title)
if not report_uuid:
print "get_report_results(): _get_report_uuid() failed. report_title: %s" % (
report_title)
return None
report_results_url = ji.get_url(
self.req_api_get_report_results % report_uuid,
self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(report_results_url, self.jsessionid)
return recvd_data['data']['list']
except Exception, e:
print traceback.format_exc()
return None
def verify_syslog_facility(self,
enable='false',
facility="LOCAL0",
facility_type=''):
"""
Verify Syslog Facility
:param str facility: LOCAL0|LOCAL1|...|LOCAL7 - Default: LOCAL0
:return: True: if facility is selected
:rtype: boolean
"""
url = ji.get_url(self.req_api_syslog, self.scg_mgmt_ip, self.scg_port)
response_data = ji.get_json_data(url, self.jsessionid)
if response_data['data']['enable'] != enable:
return None
if facility_type == "appfacility":
return response_data["data"]["applog_syslog_facility"] == facility
elif facility_type == "auditfacility":
return response_data["data"]["audit_syslog_facility"] == facility
else:
return response_data["data"]["event_syslog_facility"] == facility
def get_domain_uuid(self, domain_label='Administration Domain'):
is_entry_found = False
uuid = None
try:
url = ji.get_url(self.req_api_domains, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
if len(recvd_data['data']['list']) >= 1:
for data in recvd_data['data']['list']:
if data['label'] == domain_label:
uuid = data['key']
is_entry_found = True
break
else:
print "get_domain_uuid(): No data.list recvd"
return uuid
if not is_entry_found:
print "get_domain_uuid(): domain_label: %s not found" % domain_label
return uuid
except Exception:
print traceback.format_exc()
return uuid
return uuid
def get_ap_firmwares_in_apzone(self, domain_label='Administration Domain', apzone_name='APZone-1'):
apzone_uuid = None
ap_fw_list = []
try:
apzone_uuid = self.get_apzone_uuid(domain_label=domain_label, apzone_name=apzone_name)
if not apzone_uuid:
print "get_apzone_uuid(): domain_label: %s apzone_name: %s failed" %(
domain_label, apzone_name)
return ap_fw_list
current_ap_fwversion = self.get_ap_fwversion_in_apzone(domain_label=domain_label,
apzone_name=apzone_name)
if not current_ap_fwversion:
print "get_ap_fwversion_in_apzone(): apzone_name: %s failed" % apzone_name
return ap_fw_list
url = ji.get_url(self.req_api_fetch_ap_firmwares_in_apzone % (apzone_uuid, current_ap_fwversion),
self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
ap_fw_list = recvd_data['data']['list']
return ap_fw_list
except Exception:
print traceback.format_exc()
return ap_fw_list
return ap_fw_list
def _get_cluster_d_staus(self):
cluster_stat_api = "/wsg/api/scg/planes/data?"
cluster_stat_url = ji.get_url(cluster_stat_api, self.scg_mgmt_ip,
self.scg_port)
print cluster_stat_url
cluster_stat_data = ji.get_json_data(cluster_stat_url, self.jsessionid)
return cluster_stat_data
def verify_apzone_syslog_facility(self,
zone_name="Syslog-Test",
facility="-1",
domain_label='Administration Domain'):
"""
Verify AP Zone Syslog Facility
:param str zone_name: AP Zone name
:param str facility: -1|16|17|18|19|20|21|22|23 (default : -1)
:param str domain_label: APZone Domain name
:return: True: if facility is selected
:rtype: boolean
"""
try:
req_zone_url = ji.get_url(
self.SJC.req_api_update_zoneprofile % self.SJC.get_apzone_uuid(
apzone_name=zone_name, domain_label=domain_label),
self.scg_mgmt_ip, self.scg_port)
zone_profile_data = ji.get_json_data(req_zone_url, self.jsessionid)
zone_profile = zone_profile_data["data"]
if zone_profile["commonConfig"]["syslogFacility"] == int(facility):
return True
return False
except Exception, e:
print traceback.format_exc()
return False
def get_key_and_data_for_device_policy(
self,
name='DevicePolicyName',
apzone_name='TEST',
domain_label='Administration Domain'):
key, data = None, None
is_found = False
get_url = ji.get_url(
self.api_add_rule_get % self.get_apzone_uuid(
apzone_name=apzone_name, domain_label=domain_label),
self.scg_mgmt_ip, self.scg_port)
rcvd_data = ji.get_json_data(get_url, self.jsessionid)
for i in range(0, len(rcvd_data['data']['list'])):
if rcvd_data['data']['list'][i]['name'] == name:
key, data = rcvd_data['data']['list'][i]['key'], rcvd_data[
'data']['list'][i]
is_found = True
break
if not is_found:
print "get_key(): Failed"
return key, data
return key, data
def get_cblade_id(self, cblade_name):
url = ji.get_url(self.GET_BLADE_ID,self.scg_mgmt_ip,self.scg_port)
_data = ji.get_json_data(url,self.jsessionid)
for blade in _data["data"]["list"]:
if blade["label"] == cblade_name + "-C":
_key = blade["bladeUUID"]
return _key
def get_license_stats(self):
lic_url = ji.get_url(self.req_api_license, self.scg_mgmt_ip, self.scg_port)
lic_data = ji.get_json_data(lic_url, self.jsessionid)
ue_lic_data = {}
for i in range(0, len(lic_data["data"]["licenseUsageList"])):
if lic_data["data"]["licenseUsageList"][i]["type"] == "UE":
ue_lic_data.update(lic_data["data"]["licenseUsageList"][i])
return ue_lic_data["usedCount"], ue_lic_data["availableCount"], ue_lic_data["usageCountPerc"], ue_lic_data["availablCountPerc"]
def get_ftp(self,ftp_name):
url = ji.get_url(self.GET_FTP_API,self.scg_mgmt_ip,self.scg_port)
_data = ji.get_json_data(url,self.jsessionid)
for ftp in _data["data"]["list"]:
if ftp["ftpName"] == ftp_name:
ftp_key = ftp["key"]
return ftp_key
def set_access_point_syslog_setting(self,
ap_mac="",
syslogIp="",
syslogPort="514",
syslogFacility="-1",
syslogRLevel="3"):
"""
Set Ap syslog setting
:param str ap_mac: AP Mac
:param str syslogIp: Syslog server ip address
:param str syslogPort: Syslog server port
:param str syslogFacility: -1|16|17|18|19|20|21|22|23 (default : -1)
:param str syslogRLevel: 0|1|..|7 (default : 3)
"""
result = False
ap_profile = {}
try:
req_ap_url = ji.get_url(self.req_api_update_ap % ap_mac,
self.scg_mgmt_ip, self.scg_port)
ap_profile_data = ji.get_json_data(req_ap_url, self.jsessionid)
ap_profile["mac"] = ap_profile_data["data"]["mac"]
ap_profile["description"] = ap_profile_data["data"]["description"]
ap_profile["fwVersion"] = ap_profile_data["data"]["fwVersion"]
ap_profile["model"] = ap_profile_data["data"]["model"]
ap_profile["mobilityZoneUUID"] = ap_profile_data["data"][
"mobilityZoneUUID"]
ap_profile["clientAdmissionConfig"] = ap_profile_data["data"][
"clientAdmissionConfig"]
ap_profile["config"] = ap_profile_data["data"]["config"]
if syslogIp:
ap_profile["config"]["syslogIp"] = syslogIp
ap_profile["config"]["syslogPort"] = int(syslogPort)
ap_profile["config"]["syslogFacility"] = int(syslogFacility)
ap_profile["config"]["syslogRLevel"] = int(syslogRLevel)
else:
for conf in ("syslogIp", "syslogPort", "syslogFacility",
"syslogRLevel"):
if ap_profile["config"].has_key(conf):
del ap_profile["config"][conf]
json_data = json.dumps(ap_profile)
print json_data
result = ji.put_json_data(req_ap_url, self.jsessionid, json_data)
except Exception, e:
print traceback.format_exc()
return False
def get_backup_list(self):
result = False
data = []
try:
url = ji.get_url(self.req_wait_back_up, self.scg_mgmt_ip,
self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
except Exception, e:
print traceback.format_exc()
return False
def create_snmpv3_agent(self, user='******',
auth_protocol='',
auth_passphrase='',
privacy_protocol='',
privacy_passphrase='',
read_privilege=True, write_privilege=True, trap_privilege=False,
trap_target_ip=None, trap_target_port='162'):
result = False
snmp_agent_data = {}
try:
if self.get_snmpv3_agent(user=user):
print "create_snmpv3_agent(): user: %s already exists" % user
return False
url = ji.get_url(self.req_api_snmp_agent, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
snmp_agent_data = self.SJT.get_snmpv3_agent_template_data()
snmp_agent_data['readPrivilege'] = read_privilege
snmp_agent_data['writePrivilege'] = write_privilege
snmp_agent_data['trapPrivilege'] = trap_privilege
snmp_agent_data['userName'] = user
snmp_agent_data['authProtocol'] = auth_protocol
snmp_agent_data['authPassword'] = auth_passphrase
snmp_agent_data['privProtocol'] = privacy_protocol
snmp_agent_data['privPassword'] = privacy_passphrase
snmp_agent_data['communities'] = copy.deepcopy(recvd_data['data']['communities'])
snmp_agent_data['users'] = copy.deepcopy(recvd_data['data']['users'])
user_dict = {
'userName' : user,
'authProtocol' : auth_protocol,
'authPassword' : auth_passphrase,
'privProtocol' : privacy_protocol,
'privPassword' : privacy_passphrase,
'readPrivilege' : read_privilege,
'writePrivilege' : write_privilege,
'trapPrivilege' : trap_privilege,
'traps': [] if trap_target_ip is None else [{'targetAddress' : trap_target_ip, 'targetPort' : trap_target_port}]
}
snmp_agent_data['users'].append(user_dict)
data_json = json.dumps(snmp_agent_data)
result = ji.put_json_data(url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def get_nodeprofile(self, naf_p_name):
url=ji.get_url(self.NAF_PROFILE,self.scg_mgmt_ip,self.scg_port)
naf_profile_data = ji.get_json_data(url,self.jsessionid)
for naf_p in naf_profile_data["data"]["list"]:
if naf_p_name == naf_p["name"]:
nafp_key = naf_p["key"]
print nafp_key
return nafp_key
def get_ap_config(self, ap_mac='01:02:03:04:05:06'):
recvd_data = {}
try:
url = ji.get_url(self.req_api_ap_config % ap_mac, self.scg_mgmt_ip, self.scg_port)
_resp = ji.get_json_data(url, self.jsessionid)
recvd_data = _resp['data']
print recvd_data
except Exception, e:
print traceback.format_exc()
return recvd_data
def update_snmpv3_agent(self, current_user='******',
new_user='******',
auth_protocol=None,
auth_passphrase=None,
privacy_protocol=None,
privacy_passphrase=None,
read_privilege=None, write_privilege=None, trap_privilege=None,
trap_target_ip=None, trap_target_port='162'):
result = False
is_entry_found = False
snmp_agent_data = {}
update_index = -1
try:
url = ji.get_url(self.req_api_snmp_agent, self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(url, self.jsessionid)
new_data = copy.deepcopy(recvd_data)
for i in range(len(new_data['data']['users'])):
if new_data['data']['users'][i]['userName'] == current_user:
update_index = i
is_entry_found = True
break
if not is_entry_found:
print 'update_snmpv3_agent(): user: %s does not exist' % current_user
return False
else:
user_dict = {
'userName' : new_user,
'authProtocol' : auth_protocol if auth_protocol is not None else recvd_data['data']['users'][update_index]['authProtocol'],
'authPassword' : auth_passphrase if auth_passphrase is not None else recvd_data['data']['users'][update_index]['authPassword'],
'privProtocol' : privacy_protocol if privacy_protocol is not None else recvd_data['data']['users'][update_index]['privProtocol'],
'privPassword' : privacy_passphrase if privacy_passphrase is not None else recvd_data['data']['users'][update_index]['privPassword'],
'readPrivilege' : read_privilege if read_privilege is not None else recvd_data['data']['users'][update_index]['readPrivilege'],
'writePrivilege' : write_privilege if write_privilege is not None else recvd_data['data']['users'][update_index]['writePrivilege'],
'trapPrivilege' : trap_privilege if trap_privilege is not None else recvd_data['data']['users'][update_index]['trapPrivilege'],
'traps': [] [{'targetAddress' : trap_target_ip, 'targetPort' : trap_target_port}] if trap_target_ip is not None \
else copy.deepcopy(recvd_data['data']['users'][update_index]['traps'])
}
new_data['data']['users'][update_index] = user_dict
snmp_agent_data = new_data['data']
data_json = json.dumps(snmp_agent_data)
result = ji.put_json_data(url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def get_initial_ggsn_stats(self,ggsn_ip):
#self._build_params(stats_param=stats_param)
url=ji.get_url(self.GTP_C_API,self.scg_mgmt_ip,self.scg_port)
stats_data = ji.get_json_data(url,self.jsessionid)
for _sdata in stats_data["data"]["list"]:
if ggsn_ip == _sdata["ggsnIp"]:
no_of_act_pdp = _sdata["numActPdp"]
print no_of_act_pdp
def get_aps_dataplane_details(self, ap_mac=None):
if ap_mac:
aps_data_plane_url = ji.get_url(
self.req_api_chk_aps_dataplane_details % (ap_mac),
self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.get_json_data(aps_data_plane_url, self.jsessionid)
if recvd_data['success'] == True and recvd_data['error'] == None:
if recvd_data['data']['list']:
for item in recvd_data['data']['list']:
if (item['dpMac']):
return item['dpMac']
return None
def get_initial_radius_stats(self,radius_ip,scg_c_name):
url=ji.get_url(self.RAD_PROXY,self.scg_mgmt_ip,self.scg_port)
stats_data = ji.get_json_data(url,self.jsessionid)
for _sdata in stats_data["data"]["list"]:
if radius_ip == _sdata["aaaIp"]:
if scg_c_name == _sdata["cBladeName"]:
no_of_acct_req_sent = _sdata["numAccRqSntAaa"]
return no_of_acct_req_sent
