def enable_node_afinity(self,nafp_name="",zone_name="",no_of_zone=10):
url=ji.get_url(self.NODE_AF_API,self.scg_mgmt_ip,self.scg_port)
naf_key = self.get_nodeprofile(naf_p_name=nafp_name)
data = {"enable":True,
"numOfRetries":3,
"zoneIdToNAPIdMap":{}
}
new_zone = {}
for i in range(1,int(no_of_zone) + 1):
zone_key = self.get_apzone_uuid(apzone_name=zone_name + "_" + str(i))
tmp_zone = {zone_key:naf_key}
new_zone.update(tmp_zone)
print new_zone
data["zoneIdToNAPIdMap"] = copy.deepcopy(new_zone)
data_json = json.dumps(data)
print data_json
try:
result = ji.put_json_data(url,self.jsessionid, data_json)
except Exception:
print traceback.format_exc()
return False, None
def login_scgc(self, scg_mgmt_ip='127.0.0.2', scg_port='8443',
username='******', password='******', **kwargs):
"""
Login to SCG-C GUI with given username and password
"""
req_api_login = "******"
req_api_login_validation = '/wsg/api/scg/session/validation?'
data = { "userName":"", "password":"",}
data['userName'] = username
data['password'] = password
url = ji.get_url(req_api_login, scg_mgmt_ip, scg_port)
data_json = json.dumps(data)
jsessionid = ''
try:
jsessionid = ji.get_jsessionid(dict(req_uri=req_api_login_validation,
scg_mgmt_ip=scg_mgmt_ip,
scg_port=scg_port,
proto='https'))
result, jsessionid = ji.put_json_data(url, jsessionid, data_json, login=True)
except Exception:
print traceback.format_exc()
return False, None
self.jsessionid = jsessionid
self.scg_mgmt_ip = scg_mgmt_ip
self.scg_port = scg_port
return result, jsessionid
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 generate_report(self, report_title='myreport'):
"""
API used to Generate Report
URI GET: '/wsg/api/scg/reports/<report_uuid>/run'
:param str report_title: Report Title
:return: True if Report Generated else False
:rtype: boolean
"""
try:
report_uuid = self._get_report_uuid(report_title=report_title)
if not report_uuid:
print "generate_report(): _get_report_uuid() failed. report_title: %s" % (
report_title)
return False
url = ji.get_url(self.req_api_report_generate % report_uuid,
self.scg_mgmt_ip, self.scg_port)
data_json = None
result = ji.put_json_data(url, self.jsessionid, data_json)
return result
except Exception, e:
print traceback.format_exc()
return False
def sz100_clear_alarm(self,
alarm_list,
clear_comment="cleared by automation",
partial=False):
result = False
data = []
data_final = {}
alarm_key = None
alarm_count = len(alarm_list)
if partial:
clear_count = alarm_count / 2
for i in range(0, clear_count):
alarm_key = self.get_alarm_key(alarm_list[i])
data.append(alarm_key)
else:
for i in range((alarm_count / 2), alarm_count):
alarm_key = self.get_alarm_key(alarm_list[i])
data.append(alarm_key)
print '###', data
data_final.update({"alarmUUIDS": data, "clearComment": clear_comment})
try:
url = ji.get_url(self.sz_req_alarm_auto_clear, self.scg_mgmt_ip,
self.scg_port)
res = json.dumps(data_final)
result = ji.put_json_data(url, self.jsessionid, res)
except Exception, e:
print traceback.format_exc()
return False
def detele_rule_to_device_policy(self,
device_policy_name="DevicePolicyName",
apzone_name="TEST",
domain_label="Administration Domain",
rule_description='DP_rule'):
result = False
get_data = {}
update_rule = {}
key = None
try:
key, get_data = self.get_key_and_data_for_device_policy(
name=device_policy_name,
apzone_name=apzone_name,
domain_label=domain_label)
update_rule = copy.deepcopy(get_data)
for i in range(0, len(update_rule['rule'])):
if update_rule['rule'][i]['description'] == rule_description:
del update_rule['rule'][i]
break
data_json = json.dumps(update_rule)
put_url = ji.get_url(self.api_add_rule_put % key, self.scg_mgmt_ip,
self.scg_port)
result = ji.put_json_data(put_url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def acknowledge_alarm_35(self, alarm_list, partial=False):
result = False
data_dict = {}
data = []
alarm_key = None
alarm_count = len(alarm_list)
if partial:
clear_count = alarm_count / 2
for i in range(0, clear_count):
alarm_key = self.get_alarm_key(alarm_list[i], 'id')
data.append(alarm_key)
else:
for i in range((alarm_count / 2), alarm_count):
alarm_key = self.get_alarm_key(alarm_list[i], 'id')
data.append(alarm_key)
print '###', data
try:
url = ji.get_url(self.req_alarm_auto_ack_35, self.scg_mgmt_ip,
self.scg_port)
data_dict.update({'idList': data})
res = json.dumps(data_dict)
result = ji.put_json_data(url, self.jsessionid, res)
except Exception, e:
print traceback.format_exc()
return False
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 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 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 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 update_ap_config(self, ap_mac='01:02:03:04:05:06',
domain_label='Administration Domain',
location='bangalore', wait_ap_status='completed'
):
try:
curr_ap_cfg = self.get_ap_config(ap_mac=ap_mac)
if not curr_ap_cfg:
print "update_ap_config(): get_ap_config() failed. ap_mac: %s " % ap_mac
return False
ap_info = self.get_ap_info(domain_label=domain_label, ap_mac=ap_mac)
if not ap_info:
print "update_ap_config(): _get_ap_info() failed. ap_mac: %s " % ap_mac
return False
ap_data = self.SJT.get_ap_config_template_data()
ap_data['fwVersion'] = curr_ap_cfg['fwVersion']
ap_data['model'] = curr_ap_cfg['model']
ap_data['mobilityZoneUUID'] = curr_ap_cfg['mobilityZoneUUID']
ap_data['mac'] = ap_mac
ap_data['description'] = curr_ap_cfg['description']
ap_data['config'] = curr_ap_cfg['config'].copy()
## Remove spurious keys that are not to be copied over...
ap_data['config'].pop("apLogin", None)
ap_data['config'].pop("apPass", None)
ap_data['config'].pop("isDualRadio", None)
ap_data['config'].pop("wifi1ChannelWidth", None)
ap_data['config'].pop("wifi0ChannelWidth", None)
ap_data['config'].pop("syslogIpv6", None)
ap_data['config']['deviceName'] = ap_info['deviceName']
ap_data['config']['deviceLocation'] = location
#ap_data['config']['deviceIpSetting'] = ap_info['specificationConfiguration']['deviceIpSetting']
url = ji.get_url(self.req_api_ap_config % ap_mac,
self.scg_mgmt_ip, self.scg_port)
data_json = json.dumps(ap_data)
result = ji.put_json_data(url, self.jsessionid, data_json)
if ap_info["zoneName"] != "Staging Zone":
if not self.wait_ap_status(ap_mac=ap_mac.upper(), status=wait_ap_status):
print "wait_ap_status() AP status is not up-to-date"
return False
return result
except Exception, e:
print traceback.format_exc()
return False
def move_ap_to_apzone(self, domain_label='Administration Domain', apzone_name="APZone-1", ap_mac=None,
wait_preconfig_status="NotApplicable", wait_preconfig_retries='30', wait_preconfig_sleeptime='16',
wait_postmove_retries='15', wait_postmove_sleeptime='30'):
ap_info = None
recvd_status = None
apzone_uuid = None
if ap_mac is None:
print "move_ap_to_apzone(): ap_mac is None"
return ap_info
try:
if wait_preconfig_status != "NotApplicable":
_is_status_ok = False
for i in range(int(wait_preconfig_retries)):
recvd_status = self.get_ap_configuration_status(domain_label=domain_label, ap_mac=ap_mac)
if recvd_status != wait_preconfig_status:
print "Waiting to get the updated AP Configuration Status. Sleeping for %s, recvd_status - %s" % (wait_preconfig_sleeptime, recvd_status)
time.sleep(int(wait_preconfig_sleeptime))
else:
_is_status_ok = True
break
if not _is_status_ok:
print 'move_ap_to_apzone: Error - AP configuration Status is incorrect'
return None
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_info
data = ''
url = ji.get_url(self.req_api_ap_move % (ap_mac, apzone_uuid), self.scg_mgmt_ip, self.scg_port)
recvd_data = ji.put_json_data(url, self.jsessionid, data)
if recvd_data:
is_ap_moved = False
for i in range(int(wait_postmove_retries)):
ap_info = self.get_ap_info(domain_label=domain_label, ap_mac=ap_mac)
if ap_info["zoneName"] != apzone_name:
print "Waiting for the AP configuration status to get completed after move. Sleeping for %s" % wait_postmove_sleeptime
time.sleep(int(wait_postmove_sleeptime))
else:
is_ap_moved = True
break
if not is_ap_moved:
return None
except Exception:
print traceback.format_exc()
return ap_info
return ap_info
def disable_node_afinity(self):
url=ji.get_url(self.NODE_AF_API,self.scg_mgmt_ip,self.scg_port)
data = {"enable":False,"numOfRetries":3,"zoneIdToNAPIdMap":{}}
data_json = json.dumps(data)
try:
result = ji.put_json_data(url,self.jsessionid, data_json)
except Exception:
print traceback.format_exc()
return False, None
def update_rule_to_device_policy(self,
device_policy_name="DevicePolicyName",
apzone_name="TEST",
domain_label="Administration Domain",
rule_description='DP_rule',
new_rule_description=None,
action=None,
device_type=None,
uplink=None,
downlink=None,
vlan=None):
result = False
get_data = {}
update_rule = {}
key = None
try:
key, get_data = self.get_key_and_data_for_device_policy(
name=device_policy_name,
apzone_name=apzone_name,
domain_label=domain_label)
update_rule = copy.deepcopy(get_data)
rcvd_rule_data = {}
element = None
for i in range(0, len(get_data['rule'])):
if get_data['rule'][i]['description'] == rule_description:
rcvd_rule_data = get_data['rule'][i]
element = i
break
update_rule['rule'][element]["description"] = rcvd_rule_data[
"description"] if not new_rule_description else new_rule_description
update_rule['rule'][element][
"action"] = rcvd_rule_data["action"] if not action else action
update_rule['rule'][element]["deviceType"] = rcvd_rule_data[
"deviceType"] if not device_type else int(device_type)
update_rule['rule'][element][
"uplink"] = rcvd_rule_data["uplink"] if not uplink else uplink
update_rule['rule'][element]["downlink"] = rcvd_rule_data[
"downlink"] if not downlink else downlink
update_rule['rule'][element][
"vlan"] = rcvd_rule_data["vlan"] if not vlan else int(vlan)
data_json = json.dumps(update_rule)
put_url = ji.get_url(self.api_add_rule_put % key, self.scg_mgmt_ip,
self.scg_port)
result = ji.put_json_data(put_url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def current_ap_dblade_reboot(self):
ap_tunnel = self._get_ap_gre_tunnel(ap_ip=self.ap_ip,
ap_pwd=self.ap_pwd,
ap_user=self.ap_user)
current_d = ap_tunnel["current_d"]
cluster_d_info = {}
cluster_d_info = self._get_cluster_d_staus()
for i in range(0, len(cluster_d_info[u"data"][u"list"])):
if cluster_d_info[u"data"][u"list"][i][u"ip"] == current_d:
self._set_ap_k_interval(ap_ip=self.ap_ip,
ap_user=self.ap_user,
ap_pwd=self.ap_pwd,
kinterval='2')
self._set_ap_k_limit(ap_ip=self.ap_ip,
ap_user=self.ap_user,
ap_pwd=self.ap_pwd,
klimit='1')
reboot_api = "/wsg/api/scg/planes/data/" + cluster_d_info[
u"data"][u"list"][i][u"key"] + "/reboot"
url = ji.get_url(reboot_api, self.scg_mgmt_ip, self.scg_port)
data = None
res_put = ji.put_json_data(url,
self.jsessionid,
data,
login=False)
if not res_put:
print "current_ap_dblade_reboot(): Failed Data PUT method"
self._set_ap_gre_tunnel_disable(ap_ip=self.ap_ip,
ap_user=self.ap_user,
ap_pwd=self.ap_pwd)
self._set_ap_gre_tunnel_enable(ap_ip=self.ap_ip,
ap_user=self.ap_user,
ap_pwd=self.ap_pwd)
ap_tunnel = self._get_ap_gre_tunnel(ap_ip=self.ap_ip,
ap_user=self.ap_user,
ap_pwd=self.ap_pwd)
count = 0
while ap_tunnel['current_d'] == current_d:
count = count + 1
ap_tunnel = self._get_ap_gre_tunnel(ap_ip=self.ap_ip,
ap_user=self.ap_user,
ap_pwd=self.ap_pwd)
time.sleep(1)
if count > 40:
break
def update_snmpv2_agent(self, current_community='public',
new_community='public_new',
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']['communities'])):
if new_data['data']['communities'][i]['communityName'] == current_community:
update_index = i
is_entry_found = True
break
if not is_entry_found:
print 'update_snmpv2_agent(): community: %s does not exist' % current_community
return False
else:
community_dict = { 'communityName' : new_community,
'readPrivilege' : read_privilege if read_privilege is not None else recvd_data['data']['communities'][update_index]['readPrivilege'],
'writePrivilege' : write_privilege if write_privilege is not None else recvd_data['data']['communities'][update_index]['writePrivilege'],
'trapPrivilege' : trap_privilege if trap_privilege is not None else recvd_data['data']['communities'][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']['communities'][update_index]['traps']),
}
new_data['data']['communities'][update_index] = community_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 set_apzone_syslog_setting(self,
zone_name="Syslog-Test",
domain_label='Administration Domain',
syslogIp="",
syslogPort="514",
syslogFacility="-1",
syslogRLevel="3"):
"""
Set Ap zone syslog setting
:param str zone_name: AP zone name
:param str domain_label: APZone Domain name
: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
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"]
zone_profile["commonConfig"]["syslogIp"] = syslogIp
zone_profile["commonConfig"]["syslogPort"] = syslogPort
zone_profile["commonConfig"]["syslogFacility"] = int(
syslogFacility)
zone_profile["commonConfig"]["syslogRLevel"] = int(syslogRLevel)
json_data = json.dumps(zone_profile)
result = ji.put_json_data(req_zone_url, self.jsessionid, json_data)
except Exception, e:
print traceback.format_exc()
return False
def enable_global_snmp_trap(self):
result = False
snmp_agent_data = {}
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)
snmp_agent_data = copy.deepcopy(recvd_data['data'])
snmp_agent_data['enabled'] = True
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 update_global_lma_mag(self,
lma_key="pmipv6GlobalSetting",
lma_keepalive_interval=None,
lma_keepalive_retry=None,
binding_refreshtime=None):
"""
Update MAG Global Value with given parameter
"""
pmip_profile = data_pmip = {}
try:
url = ji.get_url(self.req_api_pmip, self.scg_mgmt_ip,
self.scg_port)
recv_data_pmip = ji.get_json_data(url, self.jsessionid)
data_pmip = recv_data_pmip["data"]
pmip_profile.update(self.SJT.get_global_lma_mag_template_data())
pmip_profile["key"] = pmip_profile[
"key"] if not data_pmip["key"] else data_pmip["key"]
pmip_profile[
"key"] = pmip_profile["key"] if not lma_key else lma_key
pmip_profile["lmaKeepAliveInterval"]=pmip_profile["lmaKeepAliveInterval"] if not data_pmip["lmaKeepAliveInterval"] else \
data_pmip["lmaKeepAliveInterval"]
pmip_profile["lmaKeepAliveInterval"] = pmip_profile[
"lmaKeepAliveInterval"] if not lma_keepalive_interval else lma_keepalive_interval
pmip_profile["lmaKeepAliveRetry"] = pmip_profile[
"lmaKeepAliveRetry"] if not data_pmip[
"lmaKeepAliveRetry"] else data_pmip["lmaKeepAliveRetry"]
pmip_profile["lmaKeepAliveRetry"] = pmip_profile[
"lmaKeepAliveRetry"] if not lma_keepalive_retry else lma_keepalive_retry
pmip_profile["bindingRefreshTime"]=pmip_profile["bindingRefreshTime"] if not data_pmip["bindingRefreshTime"] else \
data_pmip["bindingRefreshTime"]
pmip_profile["bindingRefreshTime"] = pmip_profile[
"bindingRefreshTime"] if not binding_refreshtime else binding_refreshtime
data_json = json.dumps(pmip_profile)
result = ji.put_json_data(url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def create_snmpv2_agent(self, community='public',
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_snmpv2_agent(community=community):
print "create_snmpv2_agent(): community: %s already exists" % community
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_snmpv2_agent_template_data()
snmp_agent_data['communityName'] = community
snmp_agent_data['readPrivilege'] = read_privilege
snmp_agent_data['writePrivilege'] = write_privilege
snmp_agent_data['trapPrivilege'] = trap_privilege
snmp_agent_data['communities'] = copy.deepcopy(recvd_data['data']['communities'])
snmp_agent_data['users'] = copy.deepcopy(recvd_data['data']['users'])
community_dict = { 'communityName' : community,
'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['communities'].append(community_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 add_rule_to_device_policy(self,
device_policy_name='DevicePolicyName',
rule_description='DP_rule',
action='ALLOW',
device_type='1',
uplink='500000',
downlink='2000000',
vlan=None,
apzone_name='TEST',
domain_label='Administration Domain'):
result = False
get_data = {}
add_rule = {}
key = None
try:
key, get_data = self.get_key_and_data_for_device_policy(
name=device_policy_name,
apzone_name=apzone_name,
domain_label=domain_label)
add_rule.update(get_data)
add_rule['rule'].append({
"description": rule_description,
"action": action,
"deviceType": int(device_type),
"uplink": uplink,
"downlink": downlink
})
if vlan:
add_rule['rule'].append({"vlan": int(vlan)})
data_json = json.dumps(add_rule)
put_url = ji.get_url(self.api_add_rule_put % key, self.scg_mgmt_ip,
self.scg_port)
result = ji.put_json_data(put_url, self.jsessionid, data_json)
except Exception, e:
print traceback.format_exc()
return False
def set_app_log_level(self,
scg_host_name='hostname',
app_config_name='appConfigName',
log_root_level='logRootLevel'):
"""
Set app log level
:param str scg_host_name: SCG HOST NAME
:param str app_config_name: API | CaptivePortal | Cassandra | ... | Configurer | ... |Web
:param str log_root_level: ERROR | WARN | INFO | DEBUG
:return: True: if app log level updated
:rtype: boolean
"""
cblade_label = scg_host_name + '-C'
try:
app_status = self.SJAAS.get_app_status(cblade_label)
for item in app_status:
if str(item['appConfigName']) == app_config_name:
item['logRootLevel'] = log_root_level
break
data_json = json.dumps(item)
url = ji.get_url(self.req_api_app_log_level, self.scg_mgmt_ip,
self.scg_port)
status = ji.put_json_data(url, self.jsessionid, data_json)
return status
except Exception, e:
print traceback.format_exc()
return False
def set_syslog_setting(self,
enable=True,
syslog_host="127.0.0.1",
syslog_port=514,
event_filter="1",
event_syslog_severity="",
syslog_facility="LOCAL0",
admin_active_log_facility='',
app_log_facility='',
**priority):
"""
Set Syslog Settings
:param boolean enable: True|False (Default : True)
:param str syslog_host: Syslog server ip address
:param int syslog_port: Syslog server port number (Default : 514)
:param str event_filter: 0|1|2
:param str event_syslog_severity: Critical|Major|Minor|Warning|Informational|Debug
:param str syslog_facility: LOCAL0|LOCAL1|...|LOCAL7
:param str admin_active_log_facility: LOCAL0|LOCAL1|...|LOCAL7
:param str app_log_facility: LOCAL0|LOCAL1|...|LOCAL7
:param Dictionary priority: severity and priority as key value pair
:return: True: if Syslog server created
:rtype: boolean
"""
try:
data = {}
enable = str(enable).lower()
if enable:
data = self.sjst.get_syslog_template_data()
data["enable"] = enable
data["host"] = syslog_host
data["port"] = syslog_port
data["forwardUEEventsType"] = event_filter
if event_filter == "2":
if event_syslog_severity:
data["event_syslog_severity"] = event_syslog_severity
else:
return False
data["event_syslog_facility"] = syslog_facility
data[
"audit_syslog_facility"] = syslog_facility if admin_active_log_facility == '' else admin_active_log_facility
data[
"applog_syslog_facility"] = syslog_facility if app_log_facility == '' else app_log_facility
if priority:
for item in priority.keys():
data["severityPriorityMapping"][item] = priority[item]
pri_str = ",".join(
"\"{0}\":\"{1}\"".format(key, val) for key, val in sorted(
data["severityPriorityMapping"].items()))
data["severityPriorityMapping"] = "{" + pri_str + "}"
else:
data["enable"] = enable
data_json = json.dumps(data)
syslog_facility_check = 0
status = False
while syslog_facility_check < 5:
url = ji.get_url(self.req_api_syslog, self.scg_mgmt_ip,
self.scg_port)
status = ji.put_json_data(url, self.jsessionid, data_json)
if status:
time.sleep(5)
print "Checking syslog facility %s/5" % (
syslog_facility_check)
facility_status = self.verify_syslog_facility(
enable=enable, facility=syslog_facility)
if facility_status:
break
syslog_facility_check += 1
return status
except Exception, e:
print traceback.format_exc()
return False
def update_pmipv6_service_profile(self,
pmipv6_profile_name="LMA Profile",
new_pmipv6_profile_name=None,
description=None,
lma_primary_ip=None,
lma_secondary_ip=None,
mnid_type=None,
mac48_type=None,
lma_apn=None,
mac48_hex_delimiter="No"):
"""
Update the PMIP profile with given parameters
URI: PUT /wsg/api/scg/serviceProfiles/forwarding/<>
:param str pmipv6_name: PMIPv6 Profile Name
:param str lma_primary_ip: Primary IP Address of LMA
:param str lma_secondary_ip: Secondary IP Address of LMA
:param str mnid_type: NAI_From_Authentication | MAC48_At_APN
:param mac48_type: Decimal | Hexadecimal
:param lma_apn: APN name
:return: True if PMIPv6 Updated else False
:rtype: boolean
"""
key, data = None, None
lma_update = {}
result = False
try:
url = ji.get_url(self.req_api_lma_validation, self.scg_mgmt_ip,
self.scg_port)
key, rcv_data = self._get_key_for_pmipv6_service(
url=url, name=pmipv6_profile_name)
lma_update["key"] = rcv_data["key"]
lma_update["tenantId"] = rcv_data["tenantId"]
lma_update["profileType"] = rcv_data["profileType"]
lma_update["name"] = rcv_data[
"name"] if not new_pmipv6_profile_name else new_pmipv6_profile_name
lma_update["description"] = rcv_data[
"description"] if not description else description
lma_update["lmaPrimaryIp"] = rcv_data[
"lmaPrimaryIp"] if not lma_primary_ip else lma_primary_ip
lma_update["lmaSecondaryIp"] = rcv_data[
"lmaSecondaryIp"] if not lma_secondary_ip else lma_secondary_ip
lma_update["apn"] = rcv_data["apn"] if not lma_apn else lma_apn
lma_update["mnIdType"] = rcv_data[
"mnIdType"] if not mnid_type else mnid_type
if lma_update["mnIdType"] == "MAC48_At_APN":
lma_update["mac48Type"] = rcv_data[
"mac48Type"] if not mac48_type else mac48_type
if lma_update["mac48Type"] == "Hexadecimal":
lma_update["delimiter"] = rcv_data[
"delimiter"] if not mac48_hex_delimiter else mac48_hex_delimiter
else:
lma_update["mac48Type"] = None
json_data = json.dumps(lma_update)
url_lma_update = ji.get_url(self.req_api_lma_updt_del % key,
self.scg_mgmt_ip, self.scg_port)
result = ji.put_json_data(url_lma_update, self.jsessionid,
json_data)
except Exception, e:
print traceback.format_exc()
return False
