Here are the examples of the python api requests.codes taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
7 Examples
2
Source : lxca_rest.py
with Apache License 2.0
from lenovo
with Apache License 2.0
from lenovo
def set_nodes(self, url, session, uuid, modify):
url = url + '/nodes'
job = None
if uuid:
url = url + '/' + uuid + '?synchronous=false'
try:
payload = dict()
payload = modify
resp = session.put(url, data=json.dumps(payload), verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
if "location" in resp.headers._store:
job = resp.headers._store["location"][-1].split("/")[-1]
except HTTPError as re:
logger.error("REST API Exception: Exception = %s", re)
raise re
return job
def get_switches(self,url, session, uuid):
2
Source : lxca_rest.py
with Apache License 2.0
from lenovo
with Apache License 2.0
from lenovo
def do_discovery(self,url, session, ip_addr,jobid):
try:
if ip_addr:
url = url + '/discoverRequest'
payload = [{"ipAddresses":ip_addr.split(",")}]
resp = session.post(url,data = json.dumps(payload),verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
if "location" in resp.headers._store:
job = resp.headers._store["location"][-1].split("/")[-1]
return job
else:
return None
elif jobid:
url = url + '/discoverRequest/jobs/' + str(jobid)
resp = session.get(url,verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
else:
url = url + '/discovery'
resp = session.get(url, verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
except HTTPError as re:
logger.error("Exception occured: %s",re)
raise re
return resp.json()
def do_manage(self,url, session, ip_addr,user,pw,rpw,force,jobid, storedcredential_id):
2
Source : lxca_rest.py
with Apache License 2.0
from lenovo
with Apache License 2.0
from lenovo
def do_manage(self,url, session, ip_addr,user,pw,rpw,force,jobid, storedcredential_id):
try:
orig_url = url
#All input arguments ip_add, user, pw, rpw and mp are mandatory
# if ip_addr and user and pw and mp:
if ip_addr and \
(( user and pw) or (storedcredential_id)):
url = url + '/manageRequest'
payload = list()
param_dict = dict()
param_dict["ipAddresses"]=ip_addr.split(",")
param_dict["username"] = user
param_dict["password"] = pw
if rpw:param_dict["recoveryPassword"] = rpw
# do auto discovery
disc_job_id = self.do_discovery(url.rsplit('/',1)[0], session, ip_addr,None)
disc_progress = 0
if disc_job_id:
#TODO Check if dicovery succeed, if not throw Exception
while disc_progress < 100:
time.sleep(2) # delays for 5 seconds to allow discovery to complete
disc_job_resp = self.do_discovery(url.rsplit('/',1)[0], session, None,disc_job_id)
disc_resp_py_obj = disc_job_resp
disc_progress = disc_resp_py_obj['progress']
discovered_endpoint = False
for key in list(disc_resp_py_obj.keys()):
if isinstance(disc_resp_py_obj[key],list) and disc_resp_py_obj[key] != []:
discovered_endpoint = True
#Fetch Management Port value from Response
param_dict["managementPorts"] = disc_resp_py_obj[key][0]["managementPorts"]
#Fetch Type value from Response
param_dict["type"] = disc_resp_py_obj[key][0]["type"]
# Fetch machine type from Response
param_dict["machineType"] = disc_resp_py_obj[key][0]["machineType"]
if param_dict["type"] == "Rack-Tower Server" or param_dict["type"] == "Edge Server":
# Fetch ManagementProcessor value from Response
param_dict["managementProcessor"] = disc_resp_py_obj[key][0]["managementProcessor"]
param_dict['server-type'] = param_dict['type']
#Fetch UUID value from Response
param_dict["uuid"] = disc_resp_py_obj[key][0]["uuid"]
disc_ip_addr = disc_resp_py_obj[key][0]["ipAddresses"][0]
param_dict["ipAddresses"] = [disc_ip_addr]
if param_dict["type"] == "Rackswitch":
param_dict["os"] = disc_resp_py_obj[key][0]["os"]
if not discovered_endpoint:
logger.debug("Failed to discover given endpoint %s" %param_dict["ipAddresses"])
raise Exception("Failed to discover given endpoint %s" %param_dict["ipAddresses"])
if force:
if isinstance(force, bool):
param_dict["forceManage"] = force
else:
if force.lower() == "true":
param_dict["forceManage"] = True
else:
param_dict["forceManage"] = False
security_Descriptor = { }
if storedcredential_id:
security_Descriptor['managedAuthEnabled'] = False
security_Descriptor['managedAuthSupported'] = False
cred = self.get_storedcredentials(orig_url, session, storedcredential_id)
cred_resp = cred.json()
storedCredentials = {}
storedCredentials['id'] = storedcredential_id
storedCredentials['userName'] = cred_resp['response']['userName']
storedCredentials['description'] = cred_resp['response']['description']
security_Descriptor['storedCredentials'] = storedCredentials
else:
security_Descriptor['managedAuthEnabled'] = True
security_Descriptor['managedAuthSupported'] = False
param_dict['securityDescriptor'] = security_Descriptor
payload = [param_dict]
resp = session.post(url,data = json.dumps(payload),verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
manage_resp = {}
manage_resp['manageRequestJob'] = None
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
if "location" in resp.headers._store:
job = resp.headers._store["location"][-1].split("/")[-1]
manage_resp['manageRequestJob'] = job
manage_resp['manageRequestResponse'] = resp.json()
return manage_resp
elif jobid:
url = url + '/manageRequest/jobs/' + str(jobid)
resp = session.get(url,verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
return resp.json()
else:
logger.error("Invalid execution of manage REST API")
raise Exception("Invalid execution of manage REST API")
except HTTPError as re:
logger.error("Exception occured: %s",re)
raise re
return resp
def do_unmanage(self,url, session, endpoints,force,jobid):
2
Source : lxca_rest.py
with Apache License 2.0
from lenovo
with Apache License 2.0
from lenovo
def do_unmanage(self,url, session, endpoints,force,jobid):
endpoints_list = list()
param_dict = dict()
try:
if endpoints:
url = url + '/unmanageRequest'
for each_ep in endpoints.split(","):
ip_addr = None
each_ep_dict = dict()
ep_data = each_ep.split(";")
ip_addr = ep_data[0]
uuid = ep_data[1]
type = ep_data[2]
#Fetch type value from input
type_list = ["Chassis","Rackswitch","ThinkServer","Storage","Rack-Tower","Edge"]
if type not in type_list:
raise Exception("Invalid Type Specified")
if type == "ThinkServer": type = "Lenovo ThinkServer"
elif type == "Storage": type = "Lenovo Storage"
elif type == "Rack-Tower": type = "Rack-Tower Server"
elif type == "Edge": type = "Edge Server"
each_ep_dict = {"ipAddresses":ip_addr.split("#"),"type":type,"uuid":uuid}
endpoints_list.append(each_ep_dict)
param_dict["endpoints"] = endpoints_list
if force:
if isinstance(force, bool):
param_dict["forceUnmanage"] = force
else:
if force.lower() == "true":
param_dict["forceUnmanage"] = True
else:
param_dict["forceUnmanage"] = False
payload = param_dict
resp = session.post(url,data = json.dumps(payload),verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
unmanage_resp = {}
unmanage_resp['unmanageRequestJob'] = None
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
if "location" in resp.headers._store:
job = resp.headers._store["location"][-1].split("/")[-1]
unmanage_resp['unmanageRequestJob'] = job
unmanage_resp['unmanageRequestResponse'] = resp.json()
return unmanage_resp
elif jobid:
url = url + '/unmanageRequest/jobs/' + str(jobid)
resp = session.get(url,verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
return resp.json()
else:
logger.error("Invalid execution of unmanage REST API")
raise Exception("Invalid execution of unmanage REST API")
except HTTPError as re:
logger.error("Exception occured: %s",re)
raise re
return resp
def get_jobs(self,url, session,jobid,uuid,state,canceljobid,deletejobid):
2
Source : lxca_rest.py
with Apache License 2.0
from lenovo
with Apache License 2.0
from lenovo
def get_jobs(self,url, session,jobid,uuid,state,canceljobid,deletejobid):
url = url + '/jobs'
try:
if jobid:
url = url + '/' + jobid
if state:
if state == "Pending " or state == "Running" \
or state == "Complete" or state == "Cancelled" \
or state == "Running_With_Errors" or state == "Cancelled_With_Errors" \
or state == "Stopped_With_Error" or state == "Interrupted":
url = url + '?state=' + state
if uuid:
url = url + ',uuid=' + uuid
else:
raise Exception("Invalid argument 'state': %s" %state)
if state == None and uuid:
url = url + '?uuid=' + uuid
resp = session.get(url, verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
elif canceljobid:
url = url + '/' + canceljobid
payload = {"cancelRequest":"true"}
resp = session.put(url,data = json.dumps(payload),verify=False, timeout=REST_TIMEOUT)
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
return True
resp.raise_for_status()
elif deletejobid:
url = url + '/' + deletejobid
resp = session.delete(url,verify=False, timeout=REST_TIMEOUT)
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
return True
resp.raise_for_status()
else:
if state:
if state == "Pending" or state == "Running" \
or state == "Complete" or state == "Cancelled" \
or state == "Running_With_Errors" or state == "Cancelled_With_Errors" \
or state == "Stopped_With_Error" or state == "Interrupted":
url = url + '?state=' + state
if uuid:
url = url + ',uuid=' + uuid
else:
raise Exception("Invalid argument 'state': %s" %state)
if state == None and uuid:
url = url + '?uuid=' + uuid
resp = session.get(url, verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
except HTTPError as re:
logger.error("REST API Exception: Exception = %s", re)
raise re
return resp
def get_users(self,url, session, userid):
2
Source : lxca_rest.py
with Apache License 2.0
from lenovo
with Apache License 2.0
from lenovo
def get_ffdc(self,url, session, uuid):
url = url + '/ffdc/endpoint'
try:
if uuid:
url = url + '/' + uuid
resp = session.get(url,verify=False, timeout=REST_TIMEOUT)
resp.raise_for_status()
if resp.status_code == requests.codes['ok'] or resp.status_code == requests.codes['created'] or resp.status_code == requests.codes['accepted']:
job_info = resp.json()
if "jobURL" in job_info:
job = job_info["jobURL"].split("/")[-1]
return job
else:
return resp.json()
else:
logger.error("Invalid execution of ffdc REST API mandatory parameter uuid is missing")
raise Exception("Invalid execution of ffdc REST API mandatory parameter uuid is missing")
except HTTPError as re:
logger.error("Exception occured: %s",re)
raise re
def get_updatepolicy(self, url, session, info, jobid, uuid):
0
Source : authentication.py
with GNU General Public License v3.0
from duhby
with GNU General Public License v3.0
from duhby
def _raise_from_response(res):
"""
Raises an appropriate `YggdrasilError` based on the `status_code` and
`json` of a `requests.Request` object.
"""
if res.status_code == requests.codes['ok']:
return None
exception = YggdrasilError()
exception.status_code = res.status_code
try:
json_resp = res.json()
if not ("error" in json_resp and "errorMessage" in json_resp):
raise ValueError
except ValueError:
message = "[{status_code}] Malformed error message: '{response_text}'"
message = message.format(status_code=str(res.status_code),
response_text=res.text)
exception.args = (message,)
else:
message = "[{status_code}] {error}: '{error_message}'"
message = message.format(status_code=str(res.status_code),
error=json_resp["error"],
error_message=json_resp["errorMessage"])
exception.args = (message,)
exception.yggdrasil_error = json_resp["error"]
exception.yggdrasil_message = json_resp["errorMessage"]
exception.yggdrasil_cause = json_resp.get("cause")
raise exception