12月 062018
 

网上看到的3篇连载关于tornado异步的文章,写的很好,虽然有些内容有些老了,但不影响文章的借鉴意义,强烈推荐:

转自: https://www.jianshu.com/p/ff9cb6dea27a/


Tornado异步笔记(二)— 异步客户端
前面了解Tornado的异步任务的常用做法,姑且归结为异步服务。通常在我们的服务内,还需要异步的请求第三方服务。针对HTTP请求,Python的库Requests是最好用的库,没有之一。官网宣称:HTTP for Human。然而,在tornado中直接使用requests将会是一场恶梦。requests的请求会block整个服务进程。
上帝关上门的时候,往往回打开一扇窗。Tornado提供了一个基于框架本身的异步HTTP客户端(当然也有同步的客户端)— AsyncHTTPClient。
AsyncHTTPClient 基本用法
AsyncHTTPClient是 tornado.httpclinet 提供的一个异步http客户端。使用也比较简单。与服务进程一样,AsyncHTTPClient也可以callback和yield两种使用方式。前者不会返回结果,后者则会返回response。
如果请求第三方服务是同步方式,同样会杀死性能。
class SyncHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):

        url = ‘https://api.github.com/’
        resp = requests.get(url)
        print resp.status_code

        self.finish(‘It works’)

使用ab测试大概如下:
Document Path:          /sync
Document Length:        5 bytes

Concurrency Level:      5
Time taken for tests:   10.255 seconds
Complete requests:      5
Failed requests:        0
Total transferred:      985 bytes
HTML transferred:       25 bytes
Requests per second:    0.49 [#/sec] (mean)
Time per request:       10255.051 [ms] (mean)
Time per request:       2051.010 [ms] (mean, across all concurrent requests)
Transfer rate:          0.09 [Kbytes/sec] received

性能相当慢了,换成AsyncHTTPClient再测:
class AsyncHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self, *args, **kwargs):

        url = ‘https://api.github.com/’
        http_client = tornado.httpclient.AsyncHTTPClient()
        http_client.fetch(url, self.on_response)
        self.finish(‘It works’)

    @tornado.gen.coroutine
    def on_response(self, response):
        print response.code
        

qps 提高了很多
Document Path:          /async
Document Length:        5 bytes

Concurrency Level:      5
Time taken for tests:   0.162 seconds
Complete requests:      5
Failed requests:        0
Total transferred:      985 bytes
HTML transferred:       25 bytes
Requests per second:    30.92 [#/sec] (mean)
Time per request:       161.714 [ms] (mean)
Time per request:       32.343 [ms] (mean, across all concurrent requests)
Transfer rate:          5.95 [Kbytes/sec] received

同样,为了获取response的结果,只需要yield函数。
class AsyncResponseHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, *args, **kwargs):

        url = ‘https://api.github.com/’
        http_client = tornado.httpclient.AsyncHTTPClient()
        response = yield tornado.gen.Task(http_client.fetch, url)
        print response.code
        print response.body

AsyncHTTPClient 转发
使用Tornado经常需要做一些转发服务,需要借助AsyncHTTPClient。既然是转发,就不可能只有get方法,post,put,delete等方法也会有。此时涉及到一些 headers和body,甚至还有https的waring。
下面请看一个post的例子, yield结果,通常,使用yield的时候,handler是需要 tornado.gen.coroutine。
headers = self.request.headers
body = json.dumps({‘name’: ‘rsj217’})
http_client = tornado.httpclient.AsyncHTTPClient()

resp = yield tornado.gen.Task(
    self.http_client.fetch, 
    url,
    method=”POST”, 
    headers=headers,
    body=body, 
    validate_cert=False)

AsyncHTTPClient 构造请求
如果业务处理并不是在handlers写的,而是在别的地方,当无法直接使用tornado.gen.coroutine的时候,可以构造请求,使用callback的方式。

body = urllib.urlencode(params)
req = tornado.httpclient.HTTPRequest(
  url=url, 
  method=’POST’, 
  body=body, 
  validate_cert=False)  

http_client.fetch(req, self.handler_response)

def handler_response(self, response):
    
    print response.code

用法也比较简单,AsyncHTTPClient中的fetch方法,第一个参数其实是一个HTTPRequest实例对象,因此对于一些和http请求有关的参数,例如method和body,可以使用HTTPRequest先构造一个请求,再扔给fetch方法。通常在转发服务的时候,如果开起了validate_cert,有可能会返回599timeout之类,这是一个warning,官方却认为是合理的。
AsyncHTTPClient 上传图片
AsyncHTTPClient 更高级的用法就是上传图片。例如服务有一个功能就是请求第三方服务的图片OCR服务。需要把用户上传的图片,再转发给第三方服务。
class ApiAccountUploadHandler(helper.BaseHandler):
    @tornado.gen.coroutine
    @helper.token_require
    def post(self, *args, **kwargs):
        upload_type = self.get_argument(‘type’, None)

        files_body = self.request.files[‘file’]
        
        new_file = ‘upload/new_pic.jpg’
        new_file_name = ‘new_pic.jpg’

        # 写入文件
        with open(new_file, ‘w’) as w:
            w.write(file_[‘body’])

        logging.info(‘user {} upload {}’.format(user_id, new_file_name))

        # 异步请求 上传图片
        with open(new_file, ‘rb’) as f:
            files = [(‘image’, new_file_name, f.read())]

        fields = ((‘api_key’, KEY), (‘api_secret’, SECRET))

        content_type, body = encode_multipart_formdata(fields, files)

        headers = {“Content-Type”: content_type, ‘content-length’: str(len(body))}
        request = tornado.httpclient.HTTPRequest(config.OCR_HOST,
                                                 method=”POST”, headers=headers, body=body, validate_cert=False)

        response = yield tornado.httpclient.AsyncHTTPClient().fetch(request)

def encode_multipart_formdata(fields, files):
    “””
    fields is a sequence of (name, value) elements for regular form fields.
    files is a sequence of (name, filename, value) elements for data to be
    uploaded as files.
    Return (content_type, body) ready for httplib.HTTP instance
    “””
    boundary = ‘———-ThIs_Is_tHe_bouNdaRY_$’
    crlf = ‘\r\n’
    l = []
    for (key, value) in fields:
        l.append(‘–‘ + boundary)
        l.append(‘Content-Disposition: form-data; name=”%s”‘ % key)
        l.append(”)
        l.append(value)
    for (key, filename, value) in files:
        filename = filename.encode(“utf8”)
        l.append(‘–‘ + boundary)
        l.append(
                ‘Content-Disposition: form-data; name=”%s”; filename=”%s”‘ % (
                    key, filename
                )
        )
        l.append(‘Content-Type: %s’ % get_content_type(filename))
        l.append(”)
        l.append(value)
    l.append(‘–‘ + boundary + ‘–‘)
    l.append(”)
    body = crlf.join(l)
    content_type = ‘multipart/form-data; boundary=%s’ % boundary
    return content_type, body

def get_content_type(filename):
    import mimetypes

    return mimetypes.guess_type(filename)[0] or ‘application/octet-stream’

对比上述的用法,上传图片仅仅是多了一个图片的编码。将图片的二进制数据按照multipart 方式编码。编码的同时,还需要把传递的相关的字段处理好。相比之下,使用requests 的方式则非常简单:

files = {}
f = open(‘/Users/ghost/Desktop/id.jpg’)
files[‘image’] = f
data = dict(api_key=’KEY’, api_secret=’SECRET’)
resp = requests.post(url, data=data, files=files)
f.close()
print resp.status_Code

总结
通过AsyncHTTPClient的使用方式,可以轻松的实现handler对第三方服务的请求。结合前面关于tornado异步的使用方式。无非还是两个key。是否需要返回结果,来确定使用callback的方式还是yield的方式。当然,如果不同的函数都yield,yield也可以一直传递。这个特性,tornado的中的tornado.auth 里面对oauth的认证。
大致就是这样的用法。

Sorry, the comment form is closed at this time.