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)
