def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URL specific to this Module
self.license_url = "manage/license"
self.activate_license_url = "manage/license/activate"
self.system_info_url = "manage/systeminfo"
self.staged_software_url = "manage/software/stagedversion"
self.deployed_software_url = "manage/software/deployed"
self.latest_software_url = "manage/software/latest"
self.update_content_url = "manage/updatecontent"
self.update_software_url = "manage/software/update"
self.update_hotfix_url = "manage/software/update/hotfix"
self.file_based_update_content_url = "manage/filebasedupdatecontent"
self.users_url = "manage/users"
# URL separator
self.sep_url = "/"
def __init__(self, protocol=None, ip=None, username=None, password=None):
# Default Parameters, manual location redirection
if protocol is None:
protocol = "https"
else:
pass
# Account
self.username = username
self.password = password
# Singleton Logger
self.logger = CustomLogger().get_logger()
# Timeout
self.timeout = 60
# Header
self.headers = {
"content-type": "application/json;charset=utf-8",
}
# Base URL + API Version
self.proto_ip_url = "{protocol}://{ip}/".format(protocol=protocol,
ip=ip)
self.api_version = "bps/api/v1/"
# Login/Logout - Session URL
self.session_url = "auth/session"
# This is a base URL
self.base_url = self.proto_ip_url + self.api_version
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# Test Info
self.test_id = None
self.test_iteration = None
self.model_name = None
# URLs specific to Breaking Point
self.ports_url = "bps/ports"
self.reserve_ports_url = "bps/ports/operations/reserve"
self.unreserve_ports_url = "bps/ports/operations/unreserve"
self.chassis_config_url = "bps/ports/chassisconfig"
self.change_card_config_url = "bps/ports/operations/changecardconfig"
self.reboot_card_url = "bps/ports/operations/rebootcard"
self.running_tests_url = "bps/tests"
self.start_test_url = "bps/tests/operations/start"
self.stop_test_url = "bps/tests/operations/stop"
self.get_rts_url = "bps/tests/operations/getrts"
self.result = "bps/tests/operations/getrts"
# Breaking Point constants
self.TEST_COMPLETE = 100.0 # 100% complete
self.BETWEEN_CHECKS = 1 * 60 # period for checking the stats
self.RAMP_UP = 20.0 # Ramp up
self.RAMP_DOWN = 80.0 # Ramp down
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# Aspects of system under test
self.acl_mgmt = ACL_Mgmt(rest_session)
self.audit_log_mgmt = AuditLog(rest_session)
self.jobs_mgmt = JobsMgmt(rest_session)
self.sps_mgmt = SPS_Mgmt(rest_session)
self.sys_mgmt = SysMgmt(rest_session)
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# URL specific to this Module
self.license_url = "manage/license/"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to IP Whitelist
self.whitelist_url = "accesscontrol/whitelistedips"
self.export_listed_ip_url = "accesscontrol/export/whitelist"
class Replaycenter:
def __init__(self, interface=None):
# singleton logger
self.logger = CustomLogger().get_logger()
# error codes
self.codes = DotMap()
self.codes.ok = 0
self.codes.error = -1
self.codes.missing_iface = -2
self.codes.missing_pcap = -3
if interface is not None:
self.interface = interface
else:
pass
def replay(self, bundle, interface="eth1", inter_pkt_delay=0):
replay_status = None
# Check if interface is provided
if self.interface is None:
self.logger.error("Replay interface must be provided.")
return self.codes.missing_iface
else:
pass
# Check if pcaps are provided
if "pcaps" not in bundle:
self.logger.warning("Pcaps not found, skipping.")
return self.codes.missing_pcap
else:
pass
# Replay pcap after done with checks
pcaps = bundle["pcaps"]
for pcap in pcaps:
self.logger.info("Replay Pcap: {}".format(pcap))
if os.path.isfile(pcap):
try:
pkts = rdpcap(pcap)
for pkt in pkts:
sendp(pkt,
verbose=False,
iface=interface,
inter=inter_pkt_delay)
except Exception as e:
self.logger.error(e)
replay_status = self.codes.error
# Done replaying pcaps without error
replay_status = self.codes.ok
return replay_status
def __init__(self, interface=None):
# singleton logger
self.logger = CustomLogger().get_logger()
# error codes
self.codes = DotMap()
self.codes.ok = 0
self.codes.error = -1
self.codes.missing_iface = -2
self.codes.missing_pcap = -3
if interface is not None:
self.interface = interface
else:
pass
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to Jobs API
self.jobs_url = "jobs/"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to Resource group and Network set
self.resource_group_create_url = "infras/resourcegroup"
self.network_set_create_url = "infras/networkset"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URL specific to this Module
self.nodes_info_url = "sxquery/_nodes"
self.multi_search_url = "sxquery/_msearch"
# Spare separator
self.sep_url = "/"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs - ACL
self.access_control_policy_url = "policy/accesscontrolpolicy"
# URLs - Threat Prevention Policy (TPP)
self.content_attribute_url = "policy/threatpreventionpolicy/contentattr"
self.protection_type_url = "policy/threatpreventionpolicy/protectiontype"
self.tpp_url = "policy/threatpreventionpolicy"
self.tpp_by_id_url = "policy/threatpreventionpolicy/{policy_id}"
self.threats_by_policy_id_url = "policy/{policy_id}/threats"
self.threat_responses_by_policy_id_url = "policy/{policy_id}/threatresponses"
self.apps_by_policy_id_url = "policy/{policy_id}/apps"
self.clone_tpp_responses_url = "policy/{from_policy_id}/{to_policy_id}/clonethreatresponses"
self.bulk_update_response_url = "policy/threatresponses"
# URLs - Threat Encyclopedia
self.threat_encyclopedia_url = "policy/threatencyclopedia"
self.threat_severity_url = "policy/severity"
# URLs - URL Filtering Policy
self.url_filtering_policy_url = "policy/urlfilteringpolicy"
# URL separator
self.sep_url = "/"
def __init__(self, rest_session):
self.test_aws_flow_connection = 'appconfig/testawss3connection'
self.post_aws_flow_log = 'appconfig/flowlogsstorageconfig'
self.get_all_cloud_listing = 'infras'
self.app_instance = 'applications/instances'
self.sequence_apps = 'applications/sequence'
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
self.acl_caller = AccessControl(rest_session)
self.new_acl_count = "applications/statistics"
self.forward_test = "applications/forwardtest"
self.get_forward_time = "applications/forwardtest/starttime"
self.implement_all_CS = "applications/services/implement"
self.purge_data = "appconfig/purgedata"
self.implement_all = "applications/instances/implement"
self.summary_apps = "applications/summarydetails"
self.delete_apps = "applications/instances"
self.filter_config = 'appconfig/filterconfig'
self.get_networks = 'infras/networkset'
self.deny_policy = 'applications/lasthitaclrule'
self.last_hit_rule = 'applications/lasthitaclrule'
self.get_violations_api = 'policy/accesscontrolpolicy/rulehits/'
self.create_acl_rule = 'policy/accesscontrolpolicy/rule'
self.proposed_acl = 'applications/aclrules/propose'
self.acl_policy = 'policy/accesscontrolpolicy'
self.resource_group = 'applications/resourcegroups'
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to IP Blacklist
self.blacklist_url = "accesscontrol/ipblacklist"
self.disable_blacklist_url = "accesscontrol/ipblacklist/disable"
self.import_by_file_url = "accesscontrol/importlistedip"
self.import_by_feed_url = "accesscontrol/urlfeed/blacklistedips"
self.export_listed_ip_url = "accesscontrol/export/blacklist"
self.response_action_url = "accesscontrol/ipblacklist/action"
self.global_settings_url = "accesscontrol/ipblacklist/globalsettings"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to Resource group and Network set
self.chassis_list_url = "chassislist"
self.chassis_redeploy_id = "chassis/"
self.network_set_insertionstaging_elements = "chassis/insertionstagingelements"
self.network_set_chassis_bulkinsertion = "chassisbulkinsertion"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URL specific to this Module
self.infras_url = "infras"
self.resource_group_url = "infras/resourcegroup"
self.resource_groups_url = "infras/resourcegroups"
self.ip_pool_url = "ippool"
# URL separator
self.sep_url = "/"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URL specific to this Module
self.audit_log_url = "logs/audit"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs - Malware
self.malware_url = "policy/malwarepolicy"
self.malware_engines_config_url = "manage/malwareenginesconfig"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs - Security Policy Set
self.sps_url = "policy/securitypolicyset"
self.sps_by_tenant_id_url = "policy/securitypolicyset/tenant/{tenant_id}"
self.sps_by_id_url = "policy/securitypolicyset/{sps_id}"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs - Resource Groups
self.resource_group_url = "infras/resourcegroups"
# URL separator
self.sep_url = "/"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to ACL's
self.accesscontrol_policy_url = "policy/accesscontrolpolicy"
self.accesscontrol_policy_ruleadd = "policy/accesscontrolpolicy"
self.accesscontrol_policy_nondefaultacl = "policy/accesscontrolpolicy"
self.accesscontrol_policy_nondefaultacl_del = "policy/accesscontrolpolicy/"
self.accesscontrol_policy_byruleid = "policy/accesscontrolpolicy/rules/"
self.accesscontrol_policy_bychassisid = "policy/accesscontrolpolicy/chassis/"
self.accesscontrol_policy_byinfraid = "policy/accesscontrolpolicy/infra/"
self.accesscontrol_policy_byaclid = "policy/accesscontrolpolicy/"
self.accesscontrol_policy_bytenantid = "policy/accesscontrolpolicy/tenant/"
self.accesscontrol_policy_ruleadd_policyid = "policy/accesscontrolpolicy/rule"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URL specific to this Module
self.dataplane_url = "chassis"
# URL separator
self.sep_url = "/"
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs - Access Control
self.acl_url = "policy/accesscontrolpolicy"
self.acl_by_id_url = "policy/accesscontrolpolicy/{acl_id}"
self.acl_by_infra_url = "policy/accesscontrolpolicy/infra/{infra_id}"
self.acl_by_tenant_url = "policy/accesscontrolpolicy/tenant/{tenant_id}"
self.acl_by_dataplane_url = "policy/accesscontrolpolicy/chassis/{dp_id}"
class StandaloneTool(object):
def __init__(self):
# Logger
self.logger = CustomLogger().get_logger()
def show_system_info(self, ip=None, username=None, password=None):
if all([ip, username, password]):
self.logger.info("Get system info.")
# REST Session
sx_session = SxSession(ip=ip, username=username, password=password)
# Login
sx_session.login()
# System Management
sys_mgmt = SysMgmt(sx_session)
sys_info = sys_mgmt.get_system_info()
self.logger.info("System Info: {}".format(sys_info))
# Logout
sx_session.logout()
else:
self.logger.error("Missing parameters.")
class JobsApis(object):
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to Jobs API
self.jobs_url = "jobs/"
def get_jobs(self):
# Jobs
jobs = []
# Craft the URL
url = self.rest_session.base_url + self.jobs_url
# Headers
headers = self.rest_session.headers
# Call REST - GET
response = self.rest_call.get_query(url=url,
verify=False,
headers=headers)
# Convert response to expected data
jobs = list(response.json())
return jobs
def get_job_by_id(self, job_id):
# Job
job = None
# Craft the URL
url = self.rest_session.base_url + self.jobs_url + str(job_id)
# Headers
headers = self.rest_session.headers
# Call REST - GET
response = self.rest_call.get_query(url=url,
verify=False,
headers=headers)
# Convert response to expected data
job = dict(response.json())
return job
def wait_on_job_by_id(self, job_id):
job_completed = False
try:
# Craft the URL
url = self.rest_session.base_url + self.jobs_url + str(
job_id) + "/wait"
# Headers
headers = self.rest_session.headers
# Call REST - GET
response = self.rest_call.get_query(url=url,
verify=False,
headers=headers)
if response.status_code == requests.codes.ok:
job_completed = True
self.logger.info("Job completed successfully")
else:
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return job_completed
def get_tasks_by_job_id(self, job_id):
# Tasks
tasks = []
# Craft the URL
url = self.rest_session.base_url + self.jobs_url + str(
job_id) + "/tasks"
# Headers
headers = self.rest_session.headers
# Call REST - GET
response = self.rest_call.get_query(url=url,
verify=False,
headers=headers)
tasks = list(response.json())
return tasks
def abort_job_by_id(self, job_id):
is_job_aborted = False
try:
# Craft the URL
url = self.rest_session.base_url + self.jobs_url + str(
job_id) + "/abort"
# Headers
headers = self.rest_session.headers
# Call REST - POST
response = self.rest_call.post_query(url=url,
verify=False,
headers=headers)
if response.status_code == requests.codes.ok:
is_job_aborted = True
self.logger.info("Job aborted successfully")
else:
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return is_job_aborted
class ElasticSearch(object):
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URL specific to this Module
self.nodes_info_url = "sxquery/_nodes"
self.multi_search_url = "sxquery/_msearch"
# Spare separator
self.sep_url = "/"
def get_nodes_info(self):
# Nodes Info
nodes_info = None
try:
# Craft the URL
url = self.rest_session.base_url + self.nodes_info_url
# Headers
headers = self.rest_session.headers
# Call REST - GET
response = self.rest_call.get_query(
url = url,
verify = False,
headers = headers
)
# Convert response to expected data
nodes_info = response.json()
except Exception as e:
self.logger.error(e)
return nodes_info
def multi_search_query(self, data):
# Query result
query_result = None
try:
# Craft the URL
url = self.rest_session.base_url + self.multi_search_url
# Headers
headers = self.rest_session.headers
# Call REST - POST
response = self.rest_call.post_query(
url = url,
verify = False,
headers = headers,
data = data
)
# Convert response to expected data
query_result = response.json()
except Exception as e:
self.logger.error(e)
return query_result
def get_ms_timstamp(self):
return int(round(time.time()) * 1000)
ip_list = ["192.168.131.5","192.168.131.51"]
parser.add_argument("-a","--action", default="info", help="Action", required=False)
args = vars(parser.parse_args())
# Take parameters
# ip = args["ipaddress"]
# username = os.environ.get("SHIELDX_USER")
# password = os.environ.get("SHIELDX_PASS")
ip = "172.16.100.52"
username = "******"
password = "******"
action = args["action"]
# Initialize logger
logger = CustomLogger().get_logger()
if username is None or password is None:
logger.warning("Please set username and password as environment variables.")
sys.exit()
# Establish REST connection
sx_session = SxSession(ip=ip, username=username, password=password)
sx_session.login()
try:
virtual_patch_rg = VirtualPatchRG(sx_session, logger, ip_list)
except KeyboardInterrupt as e:
logger.info("Task done. Goodbye.")
except Exception as e:
class GroupandInsert(object):
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# Common REST Calls
self.rest_call = RestCall(rest_session)
# URLs specific to Resource group and Network set
self.resource_group_create_url = "infras/resourcegroup"
self.network_set_create_url = "infras/networkset"
def rgany_vmname_noinsertion(self, rname, regexpr, descrip):
rg_created = False
rgid = None
payload = [{
"infraIDs": [0],
"dynamic": True,
"id": 0,
"name": "RG-WL-2",
"regex": "name='tony-frog-WL-4';",
"resourceType": "VM",
"description": "RG-2",
"purpose": "INSERTION_AND_POLICY"
}]
for i in payload:
if i["infraIDs"] == [0]:
i["name"] = rname
i["regex"] = regexpr
i["description"] = descrip
data = json.dumps(payload)
data = str(data)[1:-1]
try:
# Craft the URL
url = self.rest_session.base_url + self.resource_group_create_url
# Headers
headers = self.rest_session.headers
# Call REST - POST
response = self.rest_call.post_query(url=url,
headers=headers,
verify=False,
data=data)
if response.status_code == requests.codes.ok:
rgid = list(response.json())
rgid = rgid[0]
rg_created = True
self.logger.info("New resource group added")
else:
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return rgid
def nset_create_noinsertion(self, rname, regexpr, descrip):
ns_created = False
nsid = None
payload = [{
"cloudId": 1,
"id": 0,
"name": "NSET-1-PG63-2",
"regex": "ic='1';.*name='tony-PG63-2';",
"description": "NSET-1-PG63-2",
"isExclusion": False
}]
for i in payload:
if i["cloudId"] == 1:
i["name"] = rname
i["regex"] = regexpr
i["description"] = descrip
data = json.dumps(payload)
data = str(data)[1:-1]
try:
# Craft the URL
url = self.rest_session.base_url + self.network_set_create_url
# Headers
headers = self.rest_session.headers
# Call REST - POST
response = self.rest_call.post_query(url=url,
headers=headers,
verify=False,
data=data)
if response.status_code == requests.codes.ok:
nsid = list(response.json())
nsid = nsid[0]
ns_created = True
self.logger.info("New network set added")
else:
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return nsid
class SystemUnderTest(object):
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# Aspects of system under test
self.acl_mgmt = ACL_Mgmt(rest_session)
self.audit_log_mgmt = AuditLog(rest_session)
self.jobs_mgmt = JobsMgmt(rest_session)
self.sps_mgmt = SPS_Mgmt(rest_session)
self.sys_mgmt = SysMgmt(rest_session)
def assign_sps(self, acl_container, policy_name):
is_updated = False
if policy_name is not None:
# SPS - map name to ID
sps_id = None
# Get SPS by name
sps = self.sps_mgmt.get_sps_by_name(policy_name)
if sps is not None:
sps_id = sps["id"]
else:
pass
else:
# SPS is Null
policy_name = "null"
sps_id = "null"
# Resolve ACL container
acl_policy = self.acl_mgmt.get_acl_by_name(acl_container)
if acl_policy is not None:
self.logger.info(
"Update ACL with SPS Name: {}".format(policy_name))
self.logger.info("Update ACL with SPS ID: {}".format(sps_id))
# Modify the ACL Rule in the Default ACL Policy
acl_policy["spsId"] = sps_id
acl_policy["aclRules"][0]["spsId"] = sps_id
# Update the ACL
self.logger.info("Update ACL: {}".format(acl_policy))
is_updated = self.acl_mgmt.update_acl(acl_policy)
else:
# ACL Container not found
pass
return is_updated
def get_sps(self, acl_container, acl_rule_order_num=0):
policy_name = None
# Resolve ACL container
acl_policy = self.acl_mgmt.get_acl_by_name(acl_container)
# Get ACL Rules
acl_rules = acl_policy.get("aclRules", [])
self.logger.info("ACL Rules: {}".format(acl_rules))
# Get SPS of specified ACL Rule
sps_id = acl_rules[acl_rule_order_num]["spsId"]
sps = self.sps_mgmt.get_sps_by_id(sps_id)
self.logger.info("SPS: {}".format(sps))
if sps is not None:
# Get SPS Name
policy_name = sps.get("name", None)
else:
pass
return policy_name
def get_system_info(self):
system_info = {}
# Get the software and content versions
versions = self.sys_mgmt.get_system_info()
system_info["software_version"] = versions["version"]
system_info["content_version"] = versions["contentVersion"]
# Get the license info
license_info = self.sys_mgmt.get_license()
system_info["capacity"] = license_info["expected_capacity"]
return system_info
def get_audit_log_by_action(self, start_time, end_time, action):
# Craft query
query = json.dumps({
"eventType": "AUDIT_LOG",
"gte": start_time,
"lte": end_time,
"queryType": "TABLE",
"size": 100
})
# Get Audit Log
audit_log_entries = self.audit_log_mgmt.get_audit_log(query=query)
# Filter logs by action
filtered_logs = [
entry for entry in audit_log_entries
if action in entry["log"]["action"]
]
return filtered_logs
def get_last_completed_job(self):
# Check last completed job
jobs = self.jobs_mgmt.get_jobs()
completed_jobs = [job for job in jobs if job["state"] == "COMPLETED"]
# Get Job ID
job_id = completed_jobs[0]["id"]
# Fetch and return job based on job ID
return self.jobs_mgmt.get_job_by_id(job_id)
def update_content_by_file(self, filename):
# Update content
is_content_update_initiated = self.sys_mgmt.file_based_update_content(
filename)
# Return status
return is_content_update_initiated
class SxDemo(object):
def __init__(self, rest_session):
# singleton logger
self.logger = CustomLogger().get_logger()
# fetched data
self.data = None
# REST Session
self.rest_session = rest_session
# URL specific to this Module
self.license_url = "manage/license/"
def get_capacity1(self):
# Dummy should not be needed for this call!
license = "dummy"
# Expected Capacity
capacity = None
try:
url = self.rest_session.base_url + self.license_url + license
self.logger.info("URL: {}".format(url))
self.logger.info("REST Session Headers: {}".format(self.rest_session.headers))
self.logger.info("Payload: {}".format(license))
with closing(
requests.get(
url,
headers = self.rest_session.headers,
timeout = self.rest_session.timeout,
verify=False
)
) as response:
self.logger.info("Response Code: {}".format(response.status_code))
if response.status_code == requests.codes.ok:
# Fetch capacity from license call.
for license_key, license_value in response.json().items():
if license_key == "expected_capacity":
capacity = license_value
break
else:
pass
else:
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return capacity
def get_capacity2(self):
# Dummy should not be needed for this call!
license = "dummy"
# Expected Capacity
capacity = None
try:
url = self.rest_session.base_url + self.license_url + license
self.logger.info("URL: {}".format(url))
self.logger.info("REST Session Headers: {}".format(self.rest_session.headers))
self.logger.info("Payload: {}".format(license))
with closing(
requests.get(
url,
headers = self.rest_session.headers,
timeout = self.rest_session.timeout,
verify = False
)
) as response:
self.logger.info("Response Code: {}".format(response.status_code))
if response.status_code == requests.codes.ok:
# Fetch capacity from license call.
license_dict = dict(response.json())
if "expected_capacity" in license_dict:
capacity = license_dict["expected_capacity"]
else:
pass
else:
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return capacity
def get_capacity3(self):
# Dummy should not be needed for this call!
license = "dummy"
# Expected Capacity
capacity = None
try:
url = self.rest_session.base_url + self.license_url + license
self.logger.info("URL: {}".format(url))
self.logger.info("REST Session Headers: {}".format(self.rest_session.headers))
self.logger.info("Payload: {}".format(license))
with closing(
requests.get(
url,
headers = self.rest_session.headers,
timeout = self.rest_session.timeout,
verify = False
)
) as response:
self.logger.info("Response Code: {}".format(response.status_code))
if response.status_code == requests.codes.ok:
license_dict = json.loads(response.text)
if "expected_capacity" in license_dict:
capacity = license_dict["expected_capacity"]
else:
pass
else:
# debugging
self.logger.error(response.status_code)
except Exception as e:
self.logger.error(e)
return capacity
