def setup(self, http=None, timeout=None, **kw): if not http: timeout = timeout if timeout is not None else self.default_timeout http = HttpClient(timeout=timeout, **kw) http.headers['accept'] = 'application/json, text/*; q=0.5' http.headers['content-type'] = 'application/json' self.local.http = http
def test_graph(self): c = HttpClient() handler = Echo(c._loop) ws = yield c.get(self.ws_uri, websocket_handler=handler) self.assertEqual(ws.event('post_request').fired(), 0) message = yield handler.get() self.assertTrue(message)
def http(self): if self._parent: return self._parent.http else: if self._http is None: self._http = HttpClient(loop=asyncio.new_event_loop()) return self._http
def test_override_headers(self): headers = {'Accept': 'application/json, text/plain; q=0.8', 'content-type': 'application/json'} client = HttpClient(headers=headers) self.assertEqual(client.headers['accept'], 'application/json, text/plain; q=0.8') self.assertEqual(client.headers['content-type'], 'application/json')
def __init__(self, url, version=None, data=None, full_response=False, http=None, timeout=None, sync=False, loop=None, encoding='ascii', **kw): self.sync = sync self._url = url self._version = version or self.__class__.default_version self._full_response = full_response self._data = data if data is not None else {} if not http: timeout = timeout if timeout is not None else self.default_timeout if sync and not loop: loop = new_event_loop() http = HttpClient(timeout=timeout, loop=loop, **kw) http.headers['accept'] = 'application/json, text/*; q=0.5' http.headers['content-type'] = 'application/json' self._http = http self._encoding = encoding
def setUpClass(cls): s = server(name=cls.name(), concurrency=cls.concurrency, bind='127.0.0.1:0') cls.app_cfg = yield from send('arbiter', 'run', s) cls.uri = 'http://{0}:{1}'.format(*cls.app_cfg.addresses[0]) cls.client = HttpClient()
async def test_oauth1(self): oauth = OAuth1('random', client_secret='xxxxxxx', resource_owner_key='xxxxxxx', resource_owner_secret='xxxxxxx') async with HttpClient() as http: await http.post('https://api.github.com/gists/public', pre_request=oauth)
def test_pong(self): c = HttpClient() handler = Echo() ws = yield c.get(self.ws_echo, websocket_handler=handler).on_headers # ws.ping('TESTING CLIENT PING') message = yield handler.get() self.assertEqual(message, 'PONG: TESTING CLIENT PING')
def __init__(self, http=None, **kwargs): if http is None: http = HttpClient() self.http = http if self.json: self.http.headers['content-type'] = 'application/json' self.http.headers['accept'] = 'application/json' self.setup(**kwargs)
def test_urlparams(self): http = HttpClient() params = {'page': 2, 'key': 'foo'} request = HttpRequest(http, 'http://bla.com?k=6', 'post', params=params) url = urlparse(request.url) data = parse_qsl(url.query) self.assertEqual(len(data), 3)
async def test_verify(self): c = HttpClient() await self.wait.assertRaises(SSLError, c.get, self.httpbin()) response = await c.get(self.httpbin(), verify=False) self.assertEqual(response.status_code, 200) response = await c.get(self.httpbin(), verify=crt) self.assertEqual(response.status_code, 200) self.assertEqual(response.request.verify, crt)
async def setUpClass(cls): s = FlaskGreen(name=cls.name(), concurrency=cls.concurrency, bind='127.0.0.1:0', echo_bind='127.0.0.1:0') cls.app_cfg = await send('arbiter', 'run', s) cls.uri = 'http://{0}:{1}'.format(*cls.app_cfg[0].addresses[0]) cls.client = HttpClient()
async def create(cls, cfg, loop=None, auth=None): http = HttpClient(loop=loop) try: git = await Git.create() gitapi = git.api(auth=auth, http=http) repo_path = await git.toplevel() except Exception: git = gitapi = repo_path = None return cls(cfg, http, git, gitapi, repo_path)
def http_sessions(self, model=None): """Return an HTTP session handler for a given concurrency model """ if model == concurrency.THREAD_IO: return HttpClient(loop=new_event_loop()) elif model == concurrency.ASYNC_IO: return self.http else: return GreenHttp(self.http)
def client(cls, loop=None, parser=None, pool_size=2, **kwargs): parser = cls.parser() if cls.with_proxy: kwargs['proxy_info'] = {'http': cls.proxy_uri, 'https': cls.proxy_uri, 'ws': cls.proxy_uri, 'wss': cls.proxy_uri} return HttpClient(loop=loop, parser=parser, pool_size=pool_size, **kwargs)
def test_ping(self): c = HttpClient() handler = Echo() ws = yield c.get(self.ws_echo, websocket_handler=handler).on_headers # # ASK THE SERVER TO SEND A PING FRAME ws.write('send ping TESTING PING') message = yield handler.get() self.assertEqual(message, 'PING: TESTING PING')
def __init__(self, auth=None, http=None): if not http: http = HttpClient() self.logger = logging.getLogger('agile.github') self.http = http try: self.auth = auth or get_auth() except utils.AgileError as exc: self.logger.warning(str(exc)) self.auth = None
def start(self, worker): self.http = HttpClient(loop=self._loop) self.accounts = {} api_key = self.get_param('twitter_api_key') api_secret = self.get_param('twitter_api_secret') twitter_accounts = self.get_param('twitter_accounts') for account in twitter_accounts: account = Account(self, api_key, api_secret, account) self.accounts[account.token] = account account.connect()
def minify(self, options, data): b = convert_bytes(len(data)) self.write('Minimise %s css file via http://cssminifier.com' % b) http = HttpClient(loop=new_event_loop()) response = http.post('http://cssminifier.com/raw', data={'input': data}) if response.status_code == 200: return native_str(response.get_content()) else: response.raise_for_status()
def test_close(self): c = HttpClient() handler = Echo(c._loop) ws = yield c.get(self.ws_echo, websocket_handler=handler) self.assertEqual(ws.event('post_request').fired(), 0) ws.write('send close 1001') message = yield handler.get() self.assertEqual(message, 'CLOSE') self.assertTrue(ws.close_reason) self.assertEqual(ws.close_reason[0], 1001) self.assertTrue(ws._connection.closed)
def http(self): '''Get the HTTP client ''' if self._http is None: api_url = self.app.config['API_URL'] headers = [('content-type', 'application/json')] # Remote API if is_absolute_uri(api_url): if self.app.green_pool: self._http = HttpClient(headers=headers) else: self._http = HttpClient(loop=new_event_loop()) # Local API else: self._http = LocalClient(self.app, headers) token = self.app.config['API_AUTHENTICATION_TOKEN'] if token: self._http.headers['Athentication'] = 'Bearer %s' % token return self._http
def _init(self, headers=None, doc_url=None, **kw): bits = self._name.split('+') if len(bits) == 2: self._scheme = bits[0] self._name = bits[1] else: self._scheme = 'http' host = self._host if isinstance(host, tuple): host = '%s:%s' % host self._address = '%s://%s' % (self._scheme, host) self._http = HttpClient(loop=self._loop, **kw)
def client(cls, loop=None, parser=None, pool_size=2, verify=False, **kwargs): parser = cls.parser() kwargs['proxies'] = cls.proxies() return HttpClient(loop=loop, parser=parser, pool_size=pool_size, verify=verify, **kwargs)
async def connection(cls, url, valid_status=200): client = HttpClient(verify=False) times = 0 sleepy = 0.1 while times < 5: times += sleepy try: resp = await client.get(url) except HttpConnectionError: await asyncio.sleep(sleepy) else: if not resp.status_code == valid_status: resp.raise_for_status() break
def coveralls(http=None, url=None, data_file=None, repo_token=None, git=None, service_name=None, service_job_id=None, strip_dirs=None, ignore_errors=False, stream=None): '''Send a coverage report to coveralls.io. :param http: optional http client :param url: optional url to send data to. It defaults to ``coveralls`` api url. :param data_file: optional data file to load coverage data from. By default, coverage uses ``.coverage``. :param repo_token: required when not submitting from travis. https://coveralls.io/docs/api ''' stream = stream or sys.stdout coverage = Coverage(data_file=data_file) coverage.load() if http is None: from pulsar.apps.http import HttpClient http = HttpClient(force_sync=True) if not service_job_id: service_job_id = os.environ.get('TRAVIS_JOB_ID', '') if service_job_id: service_name = 'travis-ci' if not git: git = gitrepo() data = { 'service_job_id': service_job_id, 'service_name': service_name or 'pulsar', 'git': git, 'source_files': coverage.coveralls(strip_dirs, ignore_errors), } if repo_token: data['repo_token'] = repo_token url = url or COVERALLS_URL stream.write('Submitting coverage report to %s\n' % url) response = http.post(url, files={'json_file': json.dumps(data)}) stream.write('Response code: %s\n' % response.status_code) info = response.json() if 'error' in info: stream.write('An error occured while sending coverage' ' report to coverall.io') stream.write('\n%s' % info['message'])
def test_close_sync(self): loop = new_event_loop() c = HttpClient(loop=loop) handler = Echo(loop) ws = c.get(self.ws_echo, websocket_handler=handler) self.assertEqual(ws.event('post_request').fired(), 0) self.assertEqual(ws._loop, loop) self.assertFalse(ws._loop.is_running()) ws.write('send close 1001') message = ws._loop.run_until_complete(handler.get()) self.assertEqual(message, 'CLOSE') self.assertTrue(ws.close_reason) self.assertEqual(ws.close_reason[0], 1001) self.assertTrue(ws._connection.closed)
def monitor_start(self, monitor): # this application has no workers self.cfg.set('workers', 0) api_key = self.get_param('twitter_api_key') client_secret = self.get_param('twitter_api_secret') access_token = self.get_param('twitter_access_token') access_secret = self.get_param('twitter_access_secret') self._http = HttpClient(encode_multipart=False) oauth2 = OAuth1(api_key, client_secret=client_secret, resource_owner_key=access_token, resource_owner_secret=access_secret) self._http.bind_event('pre_request', oauth2) self.buffer = [] self.connect()
def __init__(self, service_name, region_name=None, endpoint_url=None, loop=None, session=None, http_session=None, **kwargs): if not http_session: http_session = HttpClient(loop=loop, decompress=False) self._session = get_session() self._client = self._session.create_client(service_name, region_name=region_name, endpoint_url=endpoint_url, http_session=http_session, **kwargs)
def worker_start(self, worker, exc=None): '''When the worker starts :meth:`connect` to twitter spreaming endpoint ''' api_key = self.get_param('twitter_api_key') client_secret = self.get_param('twitter_api_secret') access_token = self.get_param('twitter_access_token') access_secret = self.get_param('twitter_access_secret') self._http = HttpClient(encode_multipart=False) oauth1 = OAuth1(api_key, client_secret=client_secret, resource_owner_key=access_token, resource_owner_secret=access_secret) self._http.bind_event('pre_request', oauth1) self.buffer = [] ensure_future(self.connect())
def testBadRequests(self): c = HttpClient() response = yield c.post(self.ws_uri) self.assertEqual(response.status_code, 405) # response = yield c.get(self.ws_uri, headers=[('Sec-Websocket-Key', 'x')]) self.assertEqual(response.status_code, 400) # response = yield c.get(self.ws_uri, headers=[('Sec-Websocket-Key', 'bla')]) self.assertEqual(response.status_code, 400) # response = yield c.get(self.ws_uri, headers=[('Sec-Websocket-version', 'xxx')]) self.assertEqual(response.status_code, 400)