requests.codes

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 7

2 Source : lxca_rest.py
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

    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

    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

    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

    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

    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

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