Python Session.json方法代码示例

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
def pkgcloud_api_call(url, method, **kwargs):
    """
    Generic method to make HTTP requests to packagecloud
    """
    resp = None
    attempt = 0
    req = Request(method.upper(), url, **kwargs)

    while True:
        try:
            attempt += 1
            resp = Session().send(
                Session().prepare_request(req), verify=True)
            resp.raise_for_status()
            break
        except (HTTPError, ConnectionError, Timeout) as ex:
            if attempt >= 10:
                utils.abort(ex.message)
            else:
                time.sleep(3)
                continue
        except RequestException as ex:
            utils.abort(ex.message)

    try:
        if "error" in resp.json():
            raise Exception('{}'.format(resp.json()['error']))
        return resp
    except ValueError as ex:
        utils.abort("Unexpected response from packagecloud API. "
                    "Expected json, got something else: {}".format(ex.message))
    except Exception as ex:
        utils.abort("Error making packagecloud API call: {}".format(ex.message))

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
    def run(self, module, target, expr_form, args, **kwargs):
        self.verify_ssl = self.config.get('verify_ssl', True)
        '''
        CLI Examples:

            st2 run salt.local module=test.ping matches='web*'
            st2 run salt.local module=test.ping expr_form=grain target='os:Ubuntu'
        '''
        if module not in ['test.ping','test.version']:
            self.generate_package('local',
                                  cmd=module,
                                  target=target,
                                  expr_form=expr_form,
                                  args=args,
                                  data=kwargs)
        else:
            self.generate_package('local',
                                  cmd=module,
                                  target=target,
                                  expr_form=expr_form,
                                  args=None,
                                  data=kwargs)
            
        request = self.generate_request()
        self.logger.info('[salt] Request generated')
        request.prepare_body(json.dumps(self.data), None)
        self.logger.info('[salt] Preparing to send')
        resp = Session().send(request, verify=self.verify_ssl)
        return resp.json()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
    def run(self, module, **kwargs):
        _cmd = module
        """
        CLI Examples:

            st2 run salt.runner_jobs.active
            st2 run salt.runner_jobs.list_jobs
        """
        self.generate_package("runner", cmd=_cmd)
        if kwargs["kwargs"] is not None:
            self.data.update(kwargs["kwargs"])
        request = self.generate_request()
        request.prepare_body(json.dumps(self.data), None)
        resp = Session().send(request, verify=True)
        return resp.json()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
    def run(self, **kwargs):
        '''
        CLI Examples:

            st2 run salt.runner matches='web*' module=test.ping
            st2 run salt.client module=pkg.install \
                    kwargs='{"pkgs":["git","httpd"]}'
        '''
        # TODO: This is broken, fix it. I temporary disabled it to avoid pylint
        # failure.
        # Also "args" and "kwargs" action parameters are unused?
        # self.generate_package(cmd=cmd)
        request = self.generate_request()
        request.prepare_body(json.dumps(self.data), None)
        resp = Session().send(request, verify=True)
        return resp.json()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
    def run(self, module, target, **kwargs):
        '''
        CLI Examples:

            st2 run salt.runner matches='web*' module=test.ping
            st2 run salt.client module=pkg.install \
                    kwargs='{"pkgs":["git","httpd"]}'
        '''
        # TODO: This is broken, fix it. I temporary disabled it to avoid pylint
        # failure.
        # Also "args" and "kwargs" action parameters are unused?
        # self.generate_package(cmd=cmd)
        _cmd = module
        self.generate_package('local', cmd=_cmd)
        if kwargs['kwargs'] is not None:
            self.data.update(arg['arg'])
        if target is not None:
        	target = target.replace('http://','')
        	self.data['tgt'] = target

        request = self.generate_request()
        request.prepare_body(json.dumps(self.data), None)
        resp = Session().send(request, verify=True)
        return resp.json()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
 def get_njobs_in_queue(self, username=None):
     if username is None:
         username = getpass.getuser()
     from requests import Session  # hide import in case optional library not installed
     r = Session().get("https://newt.nersc.gov/newt/queue/{}/?user={}".format(self.resource, username))
     return len(r.json())

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import json [as 别名]
def reindex(host, handler, core, swap_core, core_admin='admin/cores', output_stream=sys.stderr):
    try:
        base_url = url(host, core, handler)
        index_req = Request('GET', base_url, params={'wt': 'json', 'command': 'full-import', 'clean':'true'}).prepare()
        test_req = Request('GET', base_url, params={'wt': 'json'}).prepare()
        optimize_req = Request('GET', base_url, params={'wt': 'json', 'optimize': 'true'}).prepare()
        
        numdocs_estimate = 1
        if swap_core:
            swap_req = Request('GET', url(host, core_admin), params={
                    'wt': 'json', 
                    'action': 'swap', 
                    'core': core, 
                    'other': swap_core}
            ).prepare()
            try:
                # use "other" core if we're going to swap
                numdocs_estimate = get(url(host, swap_core, 'select'), 
                        params={'wt': 'json', 'rows': '0', 'q': '*:*'}).json()['response']['numFound']
            except:
                pass
        else:
            try:
                # use index core otherwise
                numdocs_estimate = get(url(host, core, 'select'), 
                        params={'wt': 'json', 'rows': '0', 'q': '*:*'}).json()['response']['numFound']
            except:
                pass
            
        # start index process
        logging.info("Starting search index")
        try:
            resp = Session().send(index_req)
        except Exception as e:
            logging.exception(e)
            logging.debug(resp.url)
        if resp.status_code != 200:
            raise Exception("%s\n\nIndexing Failed!, response code: (%d) with body:\n%s" % (resp.url, resp.status_code, resp.text))

        # poll every minute until Indexing Complete or error
        test_session = Session()
        while True:
            sleep(60)
            resp = test_session.send(test_req)
            logging.debug("Testing DIH for completion...")
            if resp.status_code != 200:
                logging.warning("Solr DIH failed!, response code: (%d) with body:\n%s" % (resp.status_code, resp.text))
                continue
            
            data = resp.json()
            
            if data['status'] == 'busy':
                done = int(data['statusMessages']['Total Documents Processed'])
                if done > 0 and done < numdocs_estimate:
                    progbar_update(float(done) / numdocs_estimate, output_stream) 
                elif done > 0:
                    print >> output_stream, "%d docs completed" % done
                continue

            if data['statusMessages'][''].startswith('Indexing completed'):
                logging.debug("...DIH complete")
                break

            if data['status'] not in ('idle', 'busy'):
                logging.debug("Indexing Failed!")
                raise Exception("Indexing Failed!, response code: (%d) with body:\n%s" % (resp.status_code, resp.text))

        # optimize index
        logging.debug("Optimising Index")
        resp = Session().send(optimize_req)
        if resp.status_code != 200:
            raise Exception("Optimize Failed!, response code: (%d) with body:\n%s" % (resp.status_code, resp.text))

        # swap secondary index with main index
        logging.debug("Swapping Cores")
        resp = Session().send(swap_req)
        if resp.status_code != 200:
            raise Exception("Core Swap Failed!, response code: (%d) with body:\n%s" % (resp.status_code, resp.text))

        logging.info("Search index complete")
    except KeyboardInterrupt:
        from pprint import pformat as pp
        print >> output_stream, "\n" + pp(get(base_url, params={'wt': 'json', 'command': 'abort'}).json())
    except Exception, ex:
        logging.exception(ex)