def get(self): """GitHub OAuth callback handler.""" body = { 'client_id': config.GITHUB_ID, 'client_secret': config.GITHUB_SECRET, 'code': self.get_argument('code'), 'redirect_uri': config.GITHUB_CALLBACK } request = tornado.httpclient.HTTPRequest('https://github.com/login/oauth/access_token', method='POST') request.body = urlencode(body) request.headers = { 'Content-Type': 'application/x-www-form-urlencoded' } httpclient = tornado.httpclient.AsyncHTTPClient() httpclient.fetch(request, self.on_callback_response)
def on_callback_response(self, response): """Handles access token request response.""" if response.error: self.send_error() try: response_data = parse_qs(response.body) except: self.send_error() request = tornado.httpclient.HTTPRequest('https://api.github.com/user?access_token=' + response_data['access_token'][0], method='GET') httpclient = tornado.httpclient.AsyncHTTPClient() httpclient.fetch(request, self.on_profile_response)
def http_stream_client(): streamclient = tornado.httpclient.AsyncHTTPClient() def stream_cbk(chunk): logger.debug("CHUNK: %s", chunk) chunk = chunk.decode("utf-8").strip() self.assertTrue(chunk.startswith("data:")) notif = json.loads(chunk[5:]) self.assertIn("notification", notif) if "ietf-netconf-notifications:netconf-config-change" in notif["notification"]: stream_cbk.done = True stream_cbk.done = False req = tornado.httpclient.HTTPRequest( url = url, auth_username = "******", auth_password = "******", streaming_callback = stream_cbk ) streamclient.fetch(req) logger.info("Stream connected") # Websocket connected, now send config and then read the # config change notification httpclient = tornado.httpclient.AsyncHTTPClient() yield tornado.gen.sleep(0.5) # This is required for serializing put_result = yield httpclient.fetch(put_request) # Wait till a config change event is received while not stream_cbk.done: yield tornado.gen.sleep(0.5)
def login(self, callback): k = object() httpclient.fetch('%s/login' % options.haze, headers = {'Content-Type':'application/json'}, method = 'POST', body = json.dumps( dict( name = self.name, password = self.password ) ), callback = (yield gen.Callback(k))) response = yield gen.Wait(k) logging.info('login resp %s' % response) if response.code == 200 and 'Set-Cookie' in response.headers: self.data = json.loads(response.body) self.authcookie = Cookie.BaseCookie(response.headers['Set-Cookie'])['_auth'].value callback(True) else: callback(False)
def create(self, name, password, callback=None): args = { #'email':'*****@*****.**' % str(uuid.uuid4()), 'email':name, 'password':password } randomkey = object() kwargs = { 'body': json.dumps( args ), 'headers': {'Content-Type':'application/json'}, 'callback': (yield gen.Callback(randomkey)), 'method': 'POST'} httpclient.fetch("%s/user" % options.haze, **kwargs) response = yield gen.Wait(randomkey) if response.code == 200: callback( User(name, password) ) else: logging.error('error creating user %s' % response) callback( None )
def http_stream_client(): streamclient = tornado.httpclient.AsyncHTTPClient() def stream_cbk(chunk): logger.debug("CHUNK: %s", chunk) chunk = chunk.decode("utf-8").strip() self.assertTrue(chunk.startswith("data:")) notif = json.loads(chunk[5:]) self.assertIn("notification", notif) if "ietf-netconf-notifications:netconf-config-change" in notif[ "notification"]: stream_cbk.done = True stream_cbk.done = False req = tornado.httpclient.HTTPRequest(url=url, auth_username="******", auth_password="******", streaming_callback=stream_cbk) streamclient.fetch(req) logger.info("Stream connected") # Websocket connected, now send config and then read the # config change notification httpclient = tornado.httpclient.AsyncHTTPClient() yield tornado.gen.sleep(0.5) # This is required for serializing put_result = yield httpclient.fetch(put_request) # Wait till a config change event is received while not stream_cbk.done: yield tornado.gen.sleep(0.5)
def httprequest(cls, req_id, url, method, headers, body): _logger.info("begin http request") req_check_code = cls._request_check(req_id, url, method, headers) if req_check_code != WSHTTP_PROXY_CODE_OK: return cls._createresponse(req_id, req_check_code, None) proxy_url = cls._get_proxy_address(url) if not proxy_url: return cls._createresponse(req_id, WSHTTP_PROXY_CODE_UNSUPPORT, None) httpclient = tornado.httpclient.AsyncHTTPClient() try: req_body = None if body: req_body = json.dumps(body) if method.upper() == "POST" and not req_body: req_body = "" _logger.info("begin http request %s" % proxy_url) response = yield httpclient.fetch(proxy_url, None, method = method.upper(), headers = headers, body = req_body, follow_redirects = True, raise_error = False) _logger.info("get response success %s" % req_id) return cls._createresponse(req_id, WSHTTP_PROXY_CODE_OK, response) except Exception as e: _logger.error("http request failed {0}".format(e)) return cls._createresponse(req_id, WSHTTP_PROXY_CODE_SERVEREXCEPTION, None)
def getuser(token, provison = False): user = None userid = None #decode token decode_token = base64.b64decode(token[6:]) strs_list = str(decode_token, encoding = "utf-8").split(':') if not strs_list: return (None, 498) token_key = strs_list[0] userid = mickey.redis.read_from_redis(REDIS_AUTH_PREFIX + token_key) if not userid: httpclient = tornado.httpclient.AsyncHTTPClient() url = "http://localhost:8083/cxf/security/persons/00000000000" ath_headers = { "Authorization" : token } res_body = {} try: response = yield httpclient.fetch(url, None, method = "GET", headers = ath_headers, body = None, follow_redirects = True) if response.code != 200: _logger.error("get userinfo %d received session = %s" % (response.code, token)) return (userid, response.code) res_body = json.loads(response.body.decode("utf-8")) except Exception as e: _logger.error("get user info failed {0}".format(e)) if e.response: return (userid, e.response.code) else: return (userid, 599) userid = str(res_body.get("userID", "")) if not userid: _logger.error("get userid failed session = %s" % token) return (userid, 500) _logger.info("get user id success token = %s id = %s" % (token, userid)) #cach token mickey.redis.write_to_redis(REDIS_AUTH_PREFIX + token_key, userid, 3600) #do the local provision #yield mickey.users.local_provision(userid, token) if provison: _logger.info("begin to provision %s with token %s" % (userid, token)) yield mickey.users.local_provision(userid, token) return (userid, 200)
def flush(self,t): if not self._host: #logging.info('not flushing events -- no master host') return #logging.info('flushing events!') d = {} for key, stat in self._stats.items(): if stat.ready_for_consume(t) and stat.active: d[stat.name] = (stat.meta(), stat.consume(t, upstream_flush=True)) # stat gets consumed!!! self._last_flush = t content_type, body = encode_multipart_formdata( [(k,json.dumps(v)) for k,v in d.items()] ) headers = {'Source':self._source } if content_type: headers['Content-Type'] = content_type req = tornado.httpclient.HTTPRequest('%s/stats' % self._host, method = 'POST', log_request = False, headers = headers, body = body) #logging.info('flushing to %s/stats, %s' % (self._host, body)) httpclient.fetch(req, self.flushed)
def flush(self, t): if not self._host: #logging.info('not flushing events -- no master host') return #logging.info('flushing events!') d = {} for key, stat in self._stats.items(): if stat.ready_for_consume(t) and stat.active: d[stat.name] = (stat.meta(), stat.consume(t, upstream_flush=True) ) # stat gets consumed!!! self._last_flush = t content_type, body = encode_multipart_formdata([(k, json.dumps(v)) for k, v in d.items()]) headers = {'Source': self._source} if content_type: headers['Content-Type'] = content_type req = tornado.httpclient.HTTPRequest('%s/stats' % self._host, method='POST', log_request=False, headers=headers, body=body) #logging.info('flushing to %s/stats, %s' % (self._host, body)) httpclient.fetch(req, self.flushed)
def displayuser(userid): _logger.debug("display user %s" % userid) if not userid: return request_body = {"id":userid} str_body = json.dumps(request_body) try: httpclient = tornado.httpclient.AsyncHTTPClient() response = yield httpclient.fetch(_IM_DISPLAYUSER_URL, None, method = "POST", headers = None, body = str_body, follow_redirects = True) res_body = json.loads(response.body.decode("utf-8")) return res_body except Exception as e: _logger.error("get user info failed {0}".format(e)) return None
def executeQuery(self, query): request_url = self.asterixBaseURL + "/" + "query" query = "use dataverse " + self.dataverseName + "; " + query + ";" params = {'query': query} request_url = request_url + "?" + urllib.parse.urlencode(params) #response = requests.get(request_url, params = {"query": query, 'output': 'json'}) httpclient = tornado.httpclient.HTTPClient() try: request = tornado.httpclient.HTTPRequest(request_url, method='GET', headers={'Accept': 'application/json'}) response = httpclient.fetch(request) return response.code, str(response.body, encoding='utf-8') except tornado.httpclient.HTTPError as e: print ('Error', str(e)) except Exception as e: print ('Error', str(e))
def executeAQL(self, query): request_url = self.asterixBaseURL + "/" + "aql" query = "use dataverse " + self.dataverseName + "; " + query + ";" params = {'aql': query} request_url = request_url + "?" + urllib.parse.urlencode(params) httpclient = tornado.httpclient.AsyncHTTPClient() try: request = tornado.httpclient.HTTPRequest(request_url, method='GET') response = yield httpclient.fetch(request) return response.code, str(response.body, encoding='utf-8') except tornado.httpclient.HTTPError as e: log.error('Error ' + str(e)) except Exception as e: log.error('Erorr ', str(e)) return 500, 'Query failed:' + query
def executeDDL(self, ddlStatement): request_url = self.asterixBaseURL + "/" + "ddl" statement = "use dataverse " + self.dataverseName + "; " + ddlStatement + ";" log.info('Executing... ' + statement) params = {'ddl': ddlStatement} request_url = request_url + "?" + urllib.parse.urlencode(params) httpclient = tornado.httpclient.AsyncHTTPClient() try: request = tornado.httpclient.HTTPRequest(request_url, method='GET', headers={'Accept': 'application/json'}) response = yield httpclient.fetch(request) return response.code, str(response.body, encoding='utf-8') except tornado.httpclient.HTTPError as e: log.error('Error ' + str(e)) except Exception as e: log.error('Error ' + str(e)) return 500, 'Query failed:' + ddlStatement
def executeSQLPP(self, dataverseName, query): request_url = self.asterixBaseURL + '/' + 'query/service' if dataverseName: query = 'use ' + dataverseName + '; ' + query query += ';' log.debug(query) #request_url = request_url + "?" + urllib.parse.urlencode(params) # response = requests.get(request_url, params = {"aql": query, 'output': 'json'}) httpclient = tornado.httpclient.AsyncHTTPClient() try: request = tornado.httpclient.HTTPRequest(request_url, method='POST', body=query) response = yield httpclient.fetch(request) log.debug(response.body) result = json.loads(str(response.body, encoding='utf-8')) if result['status'] == 'success': if 'results' in result: return 200, json.dumps(result['results']) else: return 200, '' else: return 500, json.dumps(response['errors']) except tornado.httpclient.HTTPError as e: log.error('Error ' + str(e)) log.debug(e.response) if e.response and len(e.response.body) > 0: log.debug(e.response.body) errorResponse = json.loads(str(e.response.body, 'utf-8')) log.debug(errorResponse['errors']) errorMessage = errorResponse['errors'][ 'msg'] if 'msg' in errorResponse[ 'errors'] else 'Unknown error' else: errorMessage = str(e) return 500, 'Query failed ' + str(errorMessage)
def websocket_client(): websock = yield tornado.websocket.websocket_connect(ws_req) logger.info("Websocket connected") # Websocket connected, now send config and then read the # config change notification httpclient = tornado.httpclient.AsyncHTTPClient() yield tornado.gen.sleep(0.5) # This is required for serializing put_result = yield httpclient.fetch(put_request) while True: stream_msg = yield websock.read_message() logger.debug("Websocket message: %s", stream_msg) event = json.loads(stream_msg) self.assertIn("notification", event) # Wait until a config-change notification is received if "ietf-netconf-notifications:netconf-config-change" in event["notification"]: break websock.close()
def websocket_client(): websock = yield tornado.websocket.websocket_connect(ws_req) logger.info("Websocket connected") # Websocket connected, now send config and then read the # config change notification httpclient = tornado.httpclient.AsyncHTTPClient() yield tornado.gen.sleep(0.5) # This is required for serializing put_result = yield httpclient.fetch(put_request) while True: stream_msg = yield websock.read_message() logger.debug("Websocket message: %s", stream_msg) event = json.loads(stream_msg) self.assertIn("notification", event) # Wait until a config-change notification is received if "ietf-netconf-notifications:netconf-config-change" in event[ "notification"]: break websock.close()
def getcontact(contactid, token = None, forcedb = False): redis_contact_key = REDIS_CONTACT_PREFIX + contactid contact_info = None unpack_contact_info = {} if not contactid: return unpack_contact_info #read contact from redis first if forcedb: mickey.redis.remove_from_redis(redis_contact_key) else: contact_info = mickey.redis.read_from_redis(redis_contact_key) if contact_info: try: unpack_contact_info = json.loads(contact_info) return unpack_contact_info except Exception as e: _logger.error("unpack contact failed {0}".format(e)) #read contact from http httpclient = tornado.httpclient.AsyncHTTPClient() url = "http://localhost:8083/cxf/security/contacts/%s" % contactid try: response = yield httpclient.fetch(url, None, method = "GET", headers = None, body = None) if response.code != 200: _logger.error("get contactinfo failed userid = %s" % contactid) return unpack_contact_info unpack_contact_info = json.loads(response.body.decode("utf-8")) except Exception as e: _logger.error("get userinfo failed {0}".format(e)) #cache the contact information if unpack_contact_info: dump_contact = json.dumps(unpack_contact_info) mickey.redis.write_to_redis(redis_contact_key, dump_contact) return unpack_contact_info
def _sync_fetch(url, method="GET", headers=None, data=None): httpclient = tornado.httpclient.HTTPClient() if method == "GET": try: response = httpclient.fetch(url, headers=headers) return response.body except tornado.httpclient.HTTPError as e: print e.response else: try: client = tornado.httpclient.HTTPClient() print url, method, headers, data response = client.fetch(url, method="POST", headers=headers, body=data) print "111" print response print "222" return response except tornado.httpclient.HTTPError as e: print e.response.body
def getResponse(self, authrize=None, timeout=30): #======================================================================= # 获取response结果 #======================================================================= """ connection = http.client.HTTPConnection(self.__domain, self.__port, timeout) sys_parameters = { P_FORMAT: 'json', P_APPKEY: self.__app_key, P_SIGN_METHOD: "md5", P_VERSION: '2.0', P_TIMESTAMP: str(int(time.time() * 1000)), P_PARTNER_ID: SYSTEM_GENERATE_VERSION, P_API: self.getapiname(), } if authrize is not None: sys_parameters[P_SESSION] = authrize application_parameter = self.getApplicationParameters() sign_parameter = sys_parameters.copy() sign_parameter.update(application_parameter) sys_parameters[P_SIGN] = sign(self.__secret, sign_parameter) connection.connect() header = self.get_request_header(); if(self.getMultipartParas()): form = MultiPartForm() for key, value in list(application_parameter.items()): form.add_field(key, value) for key in self.getMultipartParas(): fileitem = getattr(self,key) if(fileitem and isinstance(fileitem,FileItem)): form.add_file(key,fileitem.filename,fileitem.content) body = str(form) header['Content-type'] = form.get_content_type() else: body = urllib.parse.urlencode(application_parameter) url = N_REST + "?" + urllib.parse.urlencode(sys_parameters) connection.request(self.__httpmethod, url, body=body, headers=header) response = connection.getresponse(); if response.status is not 200: raise RequestException('invalid http status ' + str(response.status) + ',detail body:' + response.read()) result = response.read() """ httpclient = tornado.httpclient.AsyncHTTPClient() sys_parameters = { P_FORMAT: 'json', P_APPKEY: self.__app_key, P_SIGN_METHOD: "md5", P_VERSION: '2.0', P_TIMESTAMP: str(int(time.time() * 1000)), P_PARTNER_ID: SYSTEM_GENERATE_VERSION, P_API: self.getapiname(), } if authrize is not None: sys_parameters[P_SESSION] = authrize application_parameter = self.getApplicationParameters() sign_parameter = sys_parameters.copy() sign_parameter.update(application_parameter) sys_parameters[P_SIGN] = sign(self.__secret, sign_parameter) header = self.get_request_header(); if(self.getMultipartParas()): form = MultiPartForm() for key, value in list(application_parameter.items()): form.add_field(key, value) for key in self.getMultipartParas(): fileitem = getattr(self,key) if(fileitem and isinstance(fileitem,FileItem)): form.add_file(key,fileitem.filename,fileitem.content) body = str(form) header['Content-type'] = form.get_content_type() else: body = urllib.parse.urlencode(application_parameter) url = "http://" + self.__domain + ":" + str(self.__port) + N_REST + "?" + urllib.parse.urlencode(sys_parameters) jsonobj = None response = None try: response = yield httpclient.fetch(url, None, method = self.__httpmethod, headers = header, body = body, follow_redirects = True) if response.code != 200: _logger.error("get userinfo %d received session = %s" % (response.code, token)) return userid jsonobj = json.loads(response.body.decode("utf-8")) except Exception as e: print(e) #jsonobj = json.loads(result) ###change the decode by hansf #str_result = str(result, encoding = "utf-8") #jsonobj = json.loads(str_result) ###change the decode by hansf if "error_response" in jsonobj: error = TopException() if P_CODE in jsonobj["error_response"] : error.errorcode = jsonobj["error_response"][P_CODE] if P_MSG in jsonobj["error_response"] : error.message = jsonobj["error_response"][P_MSG] if P_SUB_CODE in jsonobj["error_response"] : error.subcode = jsonobj["error_response"][P_SUB_CODE] if P_SUB_MSG in jsonobj["error_response"] : error.submsg = jsonobj["error_response"][P_SUB_MSG] error.application_host = response.headers.get_list("Application-Host") error.service_host = response.headers.get_list("Location-Host") raise error return jsonobj
#!/usr/bin/env python3 import subprocess import sys import tornado.httpclient PASTE_URL = 'https://yld.me/paste' httpclient = tornado.httpclient.HTTPClient() request = tornado.httpclient.HTTPRequest(url=PASTE_URL, method='POST', body=sys.stdin.read()) response = httpclient.fetch(request) shorturl = response.body.decode('utf-8').strip() try: subprocess.Popen(['xclip'], stdin=subprocess.PIPE).communicate(shorturl) except OSError: pass print(shorturl)
def get(self, port): self.write(httpclient.fetch('http://localhost:%s/'%port).body)