def post(self):
if 'Origin' in self.request.headers:
self.set_header(
'Access-Control-Allow-Origin', self.request.headers['Origin'])
self.set_header('Access-Control-Allow-Credentials', 'true')
if (config.get('requires_tos')
and self.get_argument('accepted_tos', 'false') != 'true'):
self.set_status(403)
self.finish(
'When evaluating code, you must acknowledge your acceptance '
'of the terms of service at /static/tos.html by passing the '
'parameter accepted_tos=true\n')
return
code = ''.join(self.get_arguments('code', strip=False))
if len(code) > 65000:
self.set_status(413)
self.finish('Max code size is 65000 characters')
return
remote_ip = self.request.remote_ip
referer = self.request.headers.get('Referer', '')
self.kernel_id = yield tornado.gen.Task(
self.application.km.new_session_async,
referer=referer,
remote_ip=remote_ip,
timeout=0)
sm = StatsMessage(
kernel_id=self.kernel_id,
remote_ip=remote_ip,
referer=referer,
code=code,
execute_type='service')
if remote_ip == '127.0.0.1' and self.kernel_id:
stats_logger.debug(sm)
else:
stats_logger.info(sm)
if not self.kernel_id:
logger.error('could not obtain a valid kernel_id')
self.set_status(503)
self.finish()
return
self.zmq_handler = ZMQServiceHandler()
self.zmq_handler.open(self.application, self.kernel_id)
loop = tornado.ioloop.IOLoop.instance()
def kernel_callback(msg):
if msg['msg_type'] == 'execute_reply':
loop.remove_timeout(self.timeout_handle)
logger.debug('service request finished for %s', self.kernel_id)
streams = self.zmq_handler.streams
streams['success'] = msg['content']['status'] == 'ok'
streams['execute_reply'] = msg['content']
loop.add_callback(self.finish_request)
self.zmq_handler.msg_from_kernel_callbacks.append(kernel_callback)
def timeout_callback():
logger.debug('service request timed out for %s', self.kernel_id)
loop.add_callback(self.finish_request)
self.timeout_handle = loop.call_later(30, timeout_callback)
exec_message = {
'channel': 'shell',
'parent_header': {},
'header': {
'msg_id': str(uuid.uuid4()),
'username': '',
'session': self.kernel_id,
'msg_type': 'execute_request',
},
'content': {
'code': code,
'silent': False,
'user_expressions':
jsonapi.loads(self.get_argument('user_expressions', '{}')),
'allow_stdin': False,
},
'metadata': {},
}
self.zmq_handler.on_message(jsonapi.dumps(exec_message))
def post(self):
if config.get_config("requires_tos") and \
self.get_argument("accepted_tos", "false") != "true":
self.write("""When evaluating code, you must acknowledge your acceptance
of the terms of service at /static/tos.html by passing the parameter
accepted_tos=true\n""")
self.set_status(403)
self.finish()
return
default_timeout = 30 # seconds
code = "".join(self.get_arguments('code', strip=False))
if len(code)>65000:
self.set_status(413)
self.write("Max code size is 65000 characters")
self.finish()
return
if code:
km = self.application.km
remote_ip = self.request.remote_ip
referer = self.request.headers.get('Referer','')
self.kernel_id = yield tornado.gen.Task(
km.new_session_async,
referer=referer,
remote_ip=remote_ip,
timeout=0)
if not self.kernel_id:
logger.error("could not obtain a valid kernel_id")
self.set_status(503)
self.finish()
return
if not (remote_ip == "::1"
and referer == ""
and self.cron.match(code) is not None):
sm = StatsMessage(kernel_id=self.kernel_id,
remote_ip=remote_ip,
referer=referer,
code=code,
execute_type='service')
if remote_ip == "127.0.0.1" and self.kernel_id:
stats_logger.debug(sm)
else:
stats_logger.info(sm)
self.zmq_handler = ZMQServiceHandler()
self.zmq_handler.open(self.application, self.kernel_id)
loop = tornado.ioloop.IOLoop.instance()
self.success = False
def done(msg):
if msg["msg_type"] == "execute_reply":
self.success = msg["content"]["status"] == "ok"
self.execute_reply = msg['content']
loop.remove_timeout(self.timeout_request)
loop.add_callback(self.finish_request)
self.zmq_handler.msg_from_kernel_callbacks.append(done)
self.timeout_request = loop.add_timeout(
time.time() + default_timeout, self.timeout_request)
exec_message = {
"channel": "shell",
"parent_header": {},
"header": {
"msg_id": str(uuid.uuid4()),
"username": "",
"session": self.kernel_id,
"msg_type": "execute_request",
},
"content": {
"code": code,
"silent": False,
"user_expressions": jsonapi.loads(
self.get_argument('user_expressions', default="{}")),
"allow_stdin": False,
},
"metadata": {},
}
self.zmq_handler.on_message(jsonapi.dumps(exec_message))
def post(self):
if 'Origin' in self.request.headers:
self.set_header(
'Access-Control-Allow-Origin', self.request.headers['Origin'])
self.set_header('Access-Control-Allow-Credentials', 'true')
if (config.get('requires_tos')
and self.get_argument('accepted_tos', 'false') != 'true'):
self.set_status(403)
self.finish(
'When evaluating code, you must acknowledge your acceptance '
'of the terms of service at /static/tos.html by passing the '
'parameter accepted_tos=true\n')
return
code = ''.join(self.get_arguments('code', strip=False))
if len(code) > 65000:
self.set_status(413)
self.finish('Max code size is 65000 characters')
return
remote_ip = self.request.remote_ip
referer = self.request.headers.get('Referer', '')
self.kernel = yield tornado.gen.Task(
self.application.kernel_dealer.get_kernel,
rlimits=config.get("provider_settings")["preforked_rlimits"],
lifespan=config.get("max_lifespan"),
timeout=0)
sm = StatsMessage(
kernel_id=self.kernel.id,
remote_ip=remote_ip,
referer=referer,
code=code,
execute_type='service')
if remote_ip == '127.0.0.1':
stats_logger.debug(sm)
else:
stats_logger.info(sm)
self.zmq_handler = ZMQServiceHandler()
streams = self.zmq_handler.streams
self.zmq_handler.connect(self.kernel)
loop = tornado.ioloop.IOLoop.instance()
def kernel_callback(msg):
if msg['msg_type'] == 'execute_reply':
loop.remove_timeout(self.timeout_handle)
streams['success'] = msg['content']['status'] == 'ok'
streams['execute_reply'] = msg['content']
if self.kernel.status == "idle" and 'success' in streams:
logger.debug('service request finished for %s', self.kernel.id)
loop.add_callback(self.finish_request)
self.zmq_handler.msg_from_kernel_callbacks.append(kernel_callback)
def timeout_callback():
logger.debug('service request timed out for %s', self.kernel.id)
self.kernel.stop()
self.zmq_handler.streams['success'] = False
loop.add_callback(self.finish_request)
self.timeout_handle = loop.call_later(30, timeout_callback)
exec_message = {
'channel': 'shell',
'parent_header': {},
'header': {
'msg_id': str(uuid.uuid4()),
'username': '',
'session': self.kernel.id,
'msg_type': 'execute_request',
},
'content': {
'code': code,
'silent': False,
'user_expressions':
jsonapi.loads(self.get_argument('user_expressions', '{}')),
'allow_stdin': False,
},
'metadata': {},
}
self.zmq_handler.send(exec_message)
async def post(self):
if 'Origin' in self.request.headers:
self.set_header('Access-Control-Allow-Origin',
self.request.headers['Origin'])
self.set_header('Access-Control-Allow-Credentials', 'true')
if (config.get('requires_tos')
and self.get_argument('accepted_tos', 'false') != 'true'):
self.set_status(403)
self.finish(
'When evaluating code, you must acknowledge your acceptance '
'of the terms of service at /static/tos.html by passing the '
'parameter accepted_tos=true\n')
return
code = ''.join(self.get_arguments('code', strip=False))
if len(code) > 65000:
self.set_status(413)
self.finish('Max code size is 65000 characters')
return
remote_ip = self.request.remote_ip
referer = self.request.headers.get('Referer', '')
self.kernel = await self.application.kernel_dealer.get_kernel(
rlimits=config.get("provider_settings")["preforked_rlimits"],
lifespan=config.get("max_lifespan"),
timeout=0)
sm = StatsMessage(kernel_id=self.kernel.id,
remote_ip=remote_ip,
referer=referer,
code=code,
execute_type='service')
if remote_ip == '127.0.0.1':
stats_logger.debug(sm)
else:
stats_logger.info(sm)
self.zmq_handler = ZMQServiceHandler()
streams = self.zmq_handler.streams
self.zmq_handler.connect(self.kernel)
loop = tornado.ioloop.IOLoop.current()
def kernel_callback(msg):
if msg['msg_type'] == 'execute_reply':
loop.remove_timeout(self.timeout_handle)
streams['success'] = msg['content']['status'] == 'ok'
streams['execute_reply'] = msg['content']
if self.kernel.status == "idle" and 'success' in streams:
logger.debug('service request finished for %s', self.kernel.id)
loop.add_callback(self.finish_request)
self.zmq_handler.msg_from_kernel_callbacks.append(kernel_callback)
def timeout_callback():
logger.debug('service request timed out for %s', self.kernel.id)
self.kernel.stop()
self.zmq_handler.streams['success'] = False
loop.add_callback(self.finish_request)
self.timeout_handle = loop.call_later(30, timeout_callback)
exec_message = {
'channel': 'shell',
'parent_header': {},
'header': {
'msg_id': str(uuid.uuid4()),
'username': '',
'session': self.kernel.id,
'msg_type': 'execute_request',
},
'content': {
'code':
code,
'silent':
False,
'user_expressions':
jsonapi.loads(self.get_argument('user_expressions', '{}')),
'allow_stdin':
False,
},
'metadata': {},
}
self.zmq_handler.send(exec_message)
self._auto_finish = False
def post(self):
if config.get_config("requires_tos") and self.get_cookie("accepted_tos") != "true" and \
self.get_argument("accepted_tos", "false") != "true":
self.write("""When evaluating code, you must acknowledge your acceptance
of the terms of service at /static/tos.html by passing the parameter or cookie
accepted_tos=true\n""")
self.set_status(403)
self.finish()
return
default_timeout = 30 # seconds
code = "".join(self.get_arguments('code', strip=False))
if len(code)>65000:
self.set_status(413)
self.write("Max code size is 65000 characters")
self.finish()
return
if code:
km = self.application.km
remote_ip = self.request.remote_ip
referer = self.request.headers.get('Referer','')
self.kernel_id = yield gen.Task(km.new_session_async,
referer = referer,
remote_ip = remote_ip,
timeout=0)
if not (remote_ip=="::1" and referer==""
and cron.match(code) is not None):
sm = StatsMessage(kernel_id=self.kernel_id,
remote_ip=remote_ip,
referer=referer,
code=code,
execute_type='service')
if remote_ip == "127.0.0.1" and self.kernel_id:
stats_logger.debug(sm)
else:
stats_logger.info(sm)
self.shell_handler = ShellServiceHandler(self.application)
self.iopub_handler = IOPubServiceHandler(self.application)
self.iopub_handler.open(self.kernel_id)
self.shell_handler.open(self.kernel_id)
loop = ioloop.IOLoop.instance()
self.success = False
def done(msg):
if msg["msg_type"] == "execute_reply":
self.success = msg["content"]["status"] == "ok"
self.user_variables = msg["content"].get("user_variables", [])
self.execute_reply = msg['content']
loop.remove_timeout(self.timeout_request)
loop.add_callback(self.finish_request)
self.shell_handler.msg_from_kernel_callbacks.append(done)
self.timeout_request = loop.add_timeout(time.time()+default_timeout, self.timeout_request)
exec_message = {"parent_header": {},
"header": {"msg_id": str(uuid.uuid4()),
"username": "",
"session": self.kernel_id,
"msg_type": "execute_request",
},
"content": {"code": code,
"silent": False,
"user_variables": self.get_arguments('user_variables'),
"user_expressions": {},
"allow_stdin": False,
},
"metadata": {}
}
self.shell_handler.on_message(jsonapi.dumps(exec_message))
