kernel_gateway去内核执行编程代码

最近因为工作需要，在研究调用kernel_gateway提供的api去运行python代码，先上代码：
导入包代码

import os
from tornado.escape import json_decode, json_encode, url_escape
from tornado.websocket import websocket_connect
from tornado.ioloop import IOLoop
from tornado.httpclient import AsyncHTTPClient, HTTPRequest
from tornado.options import options, parse_command_line, define
from uuid import uuid4
from demo6 import open_file

设置参数的代码：
code: 需要运行的python代码，我这是读取文件的代码 ，可以写成define(“code”, default=‘print(hello word)’)
lang: 语言，内核用该参数传递的语言执行代码
times: 内核执行的次数

define("code", default=open_file('demo1.py').decode())
define("lang", default="python3")
define("times", default=1)

1.运行该代码的时候本地要启动kernel_gateway的应用，可以git该代码然后运行__main__.py文件就可以启动该应用
2.先调用kernel_gateway的**{}/api/kernels’.format(base_url)**的地址进行内核的创建，该请求返回内核的kernel_id
3. 建立websocket连接，并请求url=’{}/api/kernels/{}/channels’.format(base_ws_url, kernel_id)地址去执行你要运行的python代码code
4. on_code 封装了websocket的发送和接收的报文，得到的结果就是code代码执行后的结果，这里是打印，没有返回，如果执行错误，也会返回错误信息，并关闭websocket通道
5. close_kernel方法封装了通过kernel_id去删除对应的内核

async def main():
    parse_command_line()
    base_url = os.getenv('BASE_GATEWAY_HTTP_URL', 'http://localhost:8888')
    base_ws_url = os.getenv('BASE_GATEWAY_WS_URL', 'ws://localhost:8888')

    print(base_url)
    print(base_ws_url)
    client = AsyncHTTPClient()
    response = await client.fetch(
        '{}/api/kernels'.format(base_url), method='POST', auth_username='fakeuser', auth_password='fakepass',
        body=json_encode({'name': options.lang})
    )
    kernel = json_decode(response.body)
    kernel_id = kernel.get('id', None)
    print('创建了内核：{0}'.format(kernel_id))

    ws_req = HTTPRequest(url='{}/api/kernels/{}/channels'.format(base_ws_url, kernel_id),
                         auth_username='fakeuser',
                         auth_password='fakepass'
                         )
    ws = await websocket_connect(ws_req)
    print('建立连接')
    await on_code(ws, options.code)  # 通过websocket得到运行的代码结果，并关闭websocket通道
    await close_kernel(kernel_id, base_url, client) # 删除内核

async def close_kernel(kernel_id, base_url, client):
    print('关闭内核{}'.format(kernel_id))
    await client.fetch('{}/api/kernels/{}'.format(base_url, kernel_id), method='DELETE', auth_username='fakeuser', auth_password='fakepass', )

async def on_code(ws, code):
    msg_id = uuid4().hex
    print(msg_id)
    ws.write_message(json_encode({
        'header': {'username': '', 'version': '5.0', 'session': '', 'msg_id': msg_id, 'msg_type': 'execute_request'
        },
        'parent_header': {},
        'channel': 'shell',
        'content': {'code': code, 'silent': False, 'store_history': False, 'user_expressions': {}, 'allow_stdin': False
        },
        'metadata': {},
        'buffers': {}
    }))
        while 1:
        msg = await ws.read_message()
        msg = json_decode(msg)
        msg_type = msg['msg_type']
        print('Received message type:', msg_type)
        if msg_type == 'error':
            for x in range(len(msg['content']['traceback'])):
                print(msg['content']['traceback'][x])
            break
        parent_msg_id = msg['parent_header']['msg_id']
        if msg_type == 'stream' and parent_msg_id == msg_id:
            print('  Content:', msg['content']['text'])
            break
    ws.close()

if __name__ == '__main__':
    IOLoop.current().run_sync(main)