ipkernel.py
817 lines
| 30.8 KiB
| text/x-python
|
PythonLexer
|
r2598 | #!/usr/bin/env python | ||
"""A simple interactive kernel that talks to a frontend over 0MQ. | ||||
Things to do: | ||||
* Implement `set_parent` logic. Right before doing exec, the Kernel should | ||||
call set_parent on all the PUB objects with the message about to be executed. | ||||
* Implement random port and security key logic. | ||||
* Implement control messages. | ||||
* Implement event loop and poll version. | ||||
""" | ||||
|
r2712 | #----------------------------------------------------------------------------- | ||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
|
r2856 | from __future__ import print_function | ||
|
r2712 | |||
|
r6789 | # Standard library imports | ||
|
r2598 | import __builtin__ | ||
import sys | ||||
import time | ||||
import traceback | ||||
|
r3294 | import logging | ||
|
r6788 | import uuid | ||
from datetime import datetime | ||||
|
r5601 | from signal import ( | ||
|
r11130 | signal, default_int_handler, SIGINT | ||
|
r5601 | ) | ||
|
r6789 | |||
# System library imports | ||||
|
r2598 | import zmq | ||
|
r6790 | from zmq.eventloop import ioloop | ||
from zmq.eventloop.zmqstream import ZMQStream | ||||
|
r2598 | |||
|
r6789 | # Local imports | ||
|
r2759 | from IPython.config.configurable import Configurable | ||
|
r4952 | from IPython.core.error import StdinNotImplementedError | ||
|
r9094 | from IPython.core import release | ||
|
r4772 | from IPython.utils import py3compat | ||
|
r2948 | from IPython.utils.jsonutil import json_clean | ||
|
r3970 | from IPython.utils.traitlets import ( | ||
|
r11130 | Any, Instance, Float, Dict, List, Set, Integer, Unicode, | ||
|
r8474 | Type | ||
|
r3970 | ) | ||
|
r3979 | |||
|
r6788 | from serialize import serialize_object, unpack_apply_message | ||
|
r9357 | from session import Session | ||
|
r2778 | from zmqshell import ZMQInteractiveShell | ||
|
r2598 | |||
|
r3314 | |||
|
r2712 | #----------------------------------------------------------------------------- | ||
|
r2754 | # Main kernel class | ||
|
r2712 | #----------------------------------------------------------------------------- | ||
|
r2641 | |||
|
r9094 | protocol_version = list(release.kernel_protocol_version_info) | ||
ipython_version = list(release.version_info) | ||||
|
r8861 | language_version = list(sys.version_info[:3]) | ||
|
r8830 | |||
|
r2759 | class Kernel(Configurable): | ||
|
r2778 | #--------------------------------------------------------------------------- | ||
# Kernel interface | ||||
#--------------------------------------------------------------------------- | ||||
|
r5153 | # attribute to override with a GUI | ||
eventloop = Any(None) | ||||
|
r6790 | def _eventloop_changed(self, name, old, new): | ||
"""schedule call to eventloop from IOLoop""" | ||||
loop = ioloop.IOLoop.instance() | ||||
loop.add_timeout(time.time()+0.1, self.enter_eventloop) | ||||
|
r5153 | |||
|
r2760 | shell = Instance('IPython.core.interactiveshell.InteractiveShellABC') | ||
|
r8474 | shell_class = Type(ZMQInteractiveShell) | ||
|
r2778 | session = Instance(Session) | ||
|
r5261 | profile_dir = Instance('IPython.core.profiledir.ProfileDir') | ||
|
r6790 | shell_streams = List() | ||
control_stream = Instance(ZMQStream) | ||||
|
r6804 | iopub_socket = Instance(zmq.Socket) | ||
|
r6790 | stdin_socket = Instance(zmq.Socket) | ||
|
r3970 | log = Instance(logging.Logger) | ||
|
r6571 | |||
|
r6826 | user_module = Any() | ||
|
r6571 | def _user_module_changed(self, name, old, new): | ||
if self.shell is not None: | ||||
self.shell.user_module = new | ||||
|
r12476 | user_ns = Instance(dict, args=None, allow_none=True) | ||
|
r6571 | def _user_ns_changed(self, name, old, new): | ||
if self.shell is not None: | ||||
self.shell.user_ns = new | ||||
self.shell.init_user_ns() | ||||
|
r2759 | |||
|
r6789 | # identities: | ||
int_id = Integer(-1) | ||||
ident = Unicode() | ||||
def _ident_default(self): | ||||
return unicode(uuid.uuid4()) | ||||
|
r2940 | # Private interface | ||
|
r6785 | |||
|
r2940 | # Time to sleep after flushing the stdout/err buffers in each execute | ||
# cycle. While this introduces a hard limit on the minimal latency of the | ||||
# execute cycle, it helps prevent output synchronization problems for | ||||
# clients. | ||||
# Units are in seconds. The minimum zmq latency on local host is probably | ||||
# ~150 microseconds, set this to 500us for now. We may need to increase it | ||||
# a little if it's not enough after more interactive testing. | ||||
_execute_sleep = Float(0.0005, config=True) | ||||
# Frequency of the kernel's event loop. | ||||
# Units are in seconds, kernel subclasses for GUI toolkits may need to | ||||
# adapt to milliseconds. | ||||
_poll_interval = Float(0.05, config=True) | ||||
|
r2972 | |||
# If the shutdown was requested over the network, we leave here the | ||||
# necessary reply message so it can be sent by our registered atexit | ||||
# handler. This ensures that the reply is only sent to clients truly at | ||||
# the end of our shutdown process (which happens after the underlying | ||||
# IPython shell's own shutdown). | ||||
_shutdown_message = None | ||||
|
r3019 | |||
# This is a dict of port number that the kernel is listening on. It is set | ||||
# by record_ports and used by connect_request. | ||||
|
r3970 | _recorded_ports = Dict() | ||
|
r8940 | |||
# A reference to the Python builtin 'raw_input' function. | ||||
# (i.e., __builtin__.raw_input for Python 2.7, builtins.input for Python 3) | ||||
_sys_raw_input = Any() | ||||
|
r12320 | _sys_eval_input = Any() | ||
|
r8940 | |||
|
r6785 | # set of aborted msg_ids | ||
aborted = Set() | ||||
|
r3970 | |||
|
r3294 | |||
|
r2759 | def __init__(self, **kwargs): | ||
super(Kernel, self).__init__(**kwargs) | ||||
|
r2786 | |||
# Initialize the InteractiveShell subclass | ||||
|
r11064 | self.shell = self.shell_class.instance(parent=self, | ||
|
r5261 | profile_dir = self.profile_dir, | ||
|
r6043 | user_module = self.user_module, | ||
user_ns = self.user_ns, | ||||
|
r5261 | ) | ||
|
r2786 | self.shell.displayhook.session = self.session | ||
|
r6804 | self.shell.displayhook.pub_socket = self.iopub_socket | ||
|
r6814 | self.shell.displayhook.topic = self._topic('pyout') | ||
|
r3277 | self.shell.display_pub.session = self.session | ||
|
r6804 | self.shell.display_pub.pub_socket = self.iopub_socket | ||
|
r8102 | self.shell.data_pub.session = self.session | ||
self.shell.data_pub.pub_socket = self.iopub_socket | ||||
|
r2778 | |||
|
r2838 | # TMP - hack while developing | ||
self.shell._reply_content = None | ||||
|
r2598 | # Build dict of handlers for message types | ||
|
r4872 | msg_types = [ 'execute_request', 'complete_request', | ||
|
r3817 | 'object_info_request', 'history_request', | ||
|
r8879 | 'kernel_info_request', | ||
|
r6782 | 'connect_request', 'shutdown_request', | ||
'apply_request', | ||||
] | ||||
|
r6790 | self.shell_handlers = {} | ||
|
r2612 | for msg_type in msg_types: | ||
|
r6790 | self.shell_handlers[msg_type] = getattr(self, msg_type) | ||
|
r6783 | |||
|
r13188 | widget_msg_types = [ 'widget_update', 'widget_destroy' ] | ||
widget_manager = self.shell.widget_manager | ||||
for msg_type in widget_msg_types: | ||||
self.shell_handlers[msg_type] = getattr(widget_manager, msg_type) | ||||
|
r6799 | control_msg_types = msg_types + [ 'clear_request', 'abort_request' ] | ||
|
r6782 | self.control_handlers = {} | ||
for msg_type in control_msg_types: | ||||
self.control_handlers[msg_type] = getattr(self, msg_type) | ||||
|
r13188 | |||
|
r6790 | def dispatch_control(self, msg): | ||
"""dispatch control requests""" | ||||
idents,msg = self.session.feed_identities(msg, copy=False) | ||||
try: | ||||
msg = self.session.unserialize(msg, content=True, copy=False) | ||||
except: | ||||
self.log.error("Invalid Control Message", exc_info=True) | ||||
return | ||||
|
r4237 | |||
|
r6790 | self.log.debug("Control received: %s", msg) | ||
|
r4237 | |||
|
r6790 | header = msg['header'] | ||
msg_id = header['msg_id'] | ||||
msg_type = header['msg_type'] | ||||
|
r4872 | |||
|
r6790 | handler = self.control_handlers.get(msg_type, None) | ||
if handler is None: | ||||
self.log.error("UNKNOWN CONTROL MESSAGE TYPE: %r", msg_type) | ||||
else: | ||||
|
r6792 | try: | ||
handler(self.control_stream, idents, msg) | ||||
except Exception: | ||||
self.log.error("Exception in control handler:", exc_info=True) | ||||
|
r6790 | |||
def dispatch_shell(self, stream, msg): | ||||
"""dispatch shell requests""" | ||||
# flush control requests first | ||||
if self.control_stream: | ||||
self.control_stream.flush() | ||||
idents,msg = self.session.feed_identities(msg, copy=False) | ||||
try: | ||||
msg = self.session.unserialize(msg, content=True, copy=False) | ||||
except: | ||||
self.log.error("Invalid Message", exc_info=True) | ||||
return | ||||
header = msg['header'] | ||||
msg_id = header['msg_id'] | ||||
msg_type = msg['header']['msg_type'] | ||||
|
r2926 | # Print some info about this message and leave a '--->' marker, so it's | ||
# easier to trace visually the message chain when debugging. Each | ||||
# handler prints its message at the end. | ||||
|
r6783 | self.log.debug('\n*** MESSAGE TYPE:%s***', msg_type) | ||
self.log.debug(' Content: %s\n --->\n ', msg['content']) | ||||
|
r2926 | |||
|
r6785 | if msg_id in self.aborted: | ||
self.aborted.remove(msg_id) | ||||
# is it safe to assume a msg_id will not be resubmitted? | ||||
reply_type = msg_type.split('_')[0] + '_reply' | ||||
status = {'status' : 'aborted'} | ||||
|
r7957 | md = {'engine' : self.ident} | ||
md.update(status) | ||||
reply_msg = self.session.send(stream, reply_type, metadata=md, | ||||
|
r6785 | content=status, parent=msg, ident=idents) | ||
return | ||||
|
r6790 | handler = self.shell_handlers.get(msg_type, None) | ||
|
r2868 | if handler is None: | ||
|
r6790 | self.log.error("UNKNOWN MESSAGE TYPE: %r", msg_type) | ||
|
r2868 | else: | ||
|
r6790 | # ensure default_int_handler during handler call | ||
sig = signal(SIGINT, default_int_handler) | ||||
try: | ||||
handler(stream, idents, msg) | ||||
|
r6792 | except Exception: | ||
self.log.error("Exception in message handler:", exc_info=True) | ||||
|
r6790 | finally: | ||
signal(SIGINT, sig) | ||||
def enter_eventloop(self): | ||||
"""enter eventloop""" | ||||
|
r6882 | self.log.info("entering eventloop") | ||
|
r6790 | # restore default_int_handler | ||
signal(SIGINT, default_int_handler) | ||||
|
r6827 | while self.eventloop is not None: | ||
try: | ||||
self.eventloop(self) | ||||
except KeyboardInterrupt: | ||||
# Ctrl-C shouldn't crash the kernel | ||||
self.log.error("KeyboardInterrupt caught in kernel") | ||||
continue | ||||
else: | ||||
# eventloop exited cleanly, this means we should stop (right?) | ||||
self.eventloop = None | ||||
break | ||||
|
r6882 | self.log.info("exiting eventloop") | ||
|
r4872 | |||
|
r6790 | def start(self): | ||
"""register dispatchers for streams""" | ||||
|
r6826 | self.shell.exit_now = False | ||
|
r6790 | if self.control_stream: | ||
self.control_stream.on_recv(self.dispatch_control, copy=False) | ||||
|
r2950 | |||
|
r6790 | def make_dispatcher(stream): | ||
def dispatcher(msg): | ||||
return self.dispatch_shell(stream, msg) | ||||
return dispatcher | ||||
|
r2778 | |||
|
r6790 | for s in self.shell_streams: | ||
s.on_recv(make_dispatcher(s), copy=False) | ||||
|
r10338 | |||
# publish idle status | ||||
self._publish_status('starting') | ||||
|
r6790 | |||
def do_one_iteration(self): | ||||
"""step eventloop just once""" | ||||
if self.control_stream: | ||||
self.control_stream.flush() | ||||
for stream in self.shell_streams: | ||||
# handle at most one request per iteration | ||||
stream.flush(zmq.POLLIN, 1) | ||||
stream.flush(zmq.POLLOUT) | ||||
|
r5153 | |||
|
r3019 | |||
|
r3970 | def record_ports(self, ports): | ||
|
r3019 | """Record the ports that this kernel is using. | ||
The creator of the Kernel instance must call this methods if they | ||||
want the :meth:`connect_request` method to return the port numbers. | ||||
""" | ||||
|
r3970 | self._recorded_ports = ports | ||
|
r3019 | |||
|
r2778 | #--------------------------------------------------------------------------- | ||
# Kernel request handlers | ||||
#--------------------------------------------------------------------------- | ||||
|
r6807 | |||
|
r7957 | def _make_metadata(self, other=None): | ||
"""init metadata dict, for execute/apply_reply""" | ||||
new_md = { | ||||
|
r6807 | 'dependencies_met' : True, | ||
'engine' : self.ident, | ||||
'started': datetime.now(), | ||||
} | ||||
|
r7957 | if other: | ||
new_md.update(other) | ||||
return new_md | ||||
|
r6807 | |||
|
r6542 | def _publish_pyin(self, code, parent, execution_count): | ||
|
r2926 | """Publish the code request on the pyin stream.""" | ||
|
r6804 | self.session.send(self.iopub_socket, u'pyin', | ||
|
r6794 | {u'code':code, u'execution_count': execution_count}, | ||
|
r6795 | parent=parent, ident=self._topic('pyin') | ||
|
r6794 | ) | ||
|
r7491 | |||
def _publish_status(self, status, parent=None): | ||||
"""send status (busy/idle) on IOPub""" | ||||
|
r6804 | self.session.send(self.iopub_socket, | ||
|
r5471 | u'status', | ||
|
r7491 | {u'execution_state': status}, | ||
|
r6794 | parent=parent, | ||
|
r6795 | ident=self._topic('status'), | ||
|
r6794 | ) | ||
|
r5471 | |||
|
r7491 | |||
def execute_request(self, stream, ident, parent): | ||||
"""handle an execute_request""" | ||||
self._publish_status(u'busy', parent) | ||||
|
r2598 | try: | ||
|
r2926 | content = parent[u'content'] | ||
code = content[u'code'] | ||||
|
r4872 | silent = content[u'silent'] | ||
|
r7981 | store_history = content.get(u'store_history', not silent) | ||
|
r2598 | except: | ||
|
r3970 | self.log.error("Got bad msg: ") | ||
|
r6783 | self.log.error("%s", parent) | ||
|
r2598 | return | ||
|
r6807 | |||
|
r7957 | md = self._make_metadata(parent['metadata']) | ||
|
r2722 | |||
|
r2926 | shell = self.shell # we'll need this a lot here | ||
|
r4872 | # Replace raw_input. Note that is not sufficient to replace | ||
|
r2926 | # raw_input in the user namespace. | ||
|
r4952 | if content.get('allow_stdin', False): | ||
raw_input = lambda prompt='': self._raw_input(prompt, ident, parent) | ||||
|
r12320 | input = lambda prompt='': eval(raw_input(prompt)) | ||
|
r4952 | else: | ||
|
r12320 | raw_input = input = lambda prompt='' : self._no_raw_input() | ||
|
r4952 | |||
|
r4772 | if py3compat.PY3: | ||
|
r8940 | self._sys_raw_input = __builtin__.input | ||
|
r4772 | __builtin__.input = raw_input | ||
else: | ||||
|
r8940 | self._sys_raw_input = __builtin__.raw_input | ||
|
r12320 | self._sys_eval_input = __builtin__.input | ||
|
r4772 | __builtin__.raw_input = raw_input | ||
|
r12320 | __builtin__.input = input | ||
|
r2926 | |||
# Set the parent message of the display hook and out streams. | ||||
shell.displayhook.set_parent(parent) | ||||
|
r3277 | shell.display_pub.set_parent(parent) | ||
|
r8102 | shell.data_pub.set_parent(parent) | ||
|
r9556 | try: | ||
sys.stdout.set_parent(parent) | ||||
except AttributeError: | ||||
pass | ||||
try: | ||||
sys.stderr.set_parent(parent) | ||||
except AttributeError: | ||||
pass | ||||
|
r2926 | |||
# Re-broadcast our input for the benefit of listening clients, and | ||||
# start computing output | ||||
if not silent: | ||||
|
r6542 | self._publish_pyin(code, parent, shell.execution_count) | ||
|
r2926 | |||
reply_content = {} | ||||
|
r2598 | try: | ||
|
r6803 | # FIXME: the shell calls the exception handler itself. | ||
|
r7981 | shell.run_cell(code, store_history=store_history, silent=silent) | ||
|
r2598 | except: | ||
|
r2926 | status = u'error' | ||
|
r2838 | # FIXME: this code right now isn't being used yet by default, | ||
|
r3752 | # because the run_cell() call above directly fires off exception | ||
|
r2838 | # reporting. This code, therefore, is only active in the scenario | ||
# where runlines itself has an unhandled exception. We need to | ||||
# uniformize this, for all exception construction to come from a | ||||
# single location in the codbase. | ||||
|
r2598 | etype, evalue, tb = sys.exc_info() | ||
|
r2838 | tb_list = traceback.format_exception(etype, evalue, tb) | ||
|
r2926 | reply_content.update(shell._showtraceback(etype, evalue, tb_list)) | ||
|
r2598 | else: | ||
|
r2926 | status = u'ok' | ||
|
r8482 | finally: | ||
# Restore raw_input. | ||||
if py3compat.PY3: | ||||
|
r8940 | __builtin__.input = self._sys_raw_input | ||
|
r8482 | else: | ||
|
r8940 | __builtin__.raw_input = self._sys_raw_input | ||
|
r12320 | __builtin__.input = self._sys_eval_input | ||
|
r2926 | |||
reply_content[u'status'] = status | ||||
|
r4872 | |||
|
r3077 | # Return the execution counter so clients can display prompts | ||
|
r6803 | reply_content['execution_count'] = shell.execution_count - 1 | ||
|
r2926 | |||
# FIXME - fish exception info out of shell, possibly left there by | ||||
# runlines. We'll need to clean up this logic later. | ||||
if shell._reply_content is not None: | ||||
reply_content.update(shell._reply_content) | ||||
|
r7038 | e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute') | ||
reply_content['engine_info'] = e_info | ||||
|
r3853 | # reset after use | ||
shell._reply_content = None | ||||
|
r8579 | |||
if 'traceback' in reply_content: | ||||
self.log.info("Exception in execute request:\n%s", '\n'.join(reply_content['traceback'])) | ||||
|
r2926 | |||
# At this point, we can tell whether the main code execution succeeded | ||||
# or not. If it did, we proceed to evaluate user_variables/expressions | ||||
if reply_content['status'] == 'ok': | ||||
reply_content[u'user_variables'] = \ | ||||
|
r6792 | shell.user_variables(content.get(u'user_variables', [])) | ||
|
r2926 | reply_content[u'user_expressions'] = \ | ||
|
r6792 | shell.user_expressions(content.get(u'user_expressions', {})) | ||
|
r2926 | else: | ||
# If there was an error, don't even try to compute variables or | ||||
# expressions | ||||
reply_content[u'user_variables'] = {} | ||||
reply_content[u'user_expressions'] = {} | ||||
|
r2987 | |||
# Payloads should be retrieved regardless of outcome, so we can both | ||||
# recover partial output (that could have been generated early in a | ||||
# block, before an error) and clear the payload system always. | ||||
reply_content[u'payload'] = shell.payload_manager.read_payload() | ||||
# Be agressive about clearing the payload because we don't want | ||||
# it to sit in memory until the next execute_request comes in. | ||||
shell.payload_manager.clear_payload() | ||||
|
r2938 | # Flush output before sending the reply. | ||
sys.stdout.flush() | ||||
sys.stderr.flush() | ||||
# FIXME: on rare occasions, the flush doesn't seem to make it to the | ||||
# clients... This seems to mitigate the problem, but we definitely need | ||||
# to better understand what's going on. | ||||
|
r2940 | if self._execute_sleep: | ||
time.sleep(self._execute_sleep) | ||||
|
r4872 | |||
|
r3333 | # Send the reply. | ||
|
r4782 | reply_content = json_clean(reply_content) | ||
|
r6807 | |||
|
r7957 | md['status'] = reply_content['status'] | ||
|
r6807 | if reply_content['status'] == 'error' and \ | ||
reply_content['ename'] == 'UnmetDependency': | ||||
|
r7957 | md['dependencies_met'] = False | ||
|
r6807 | |||
|
r6790 | reply_msg = self.session.send(stream, u'execute_reply', | ||
|
r7957 | reply_content, parent, metadata=md, | ||
|
r6807 | ident=ident) | ||
|
r6783 | self.log.debug("%s", reply_msg) | ||
|
r3333 | |||
|
r6803 | if not silent and reply_msg['content']['status'] == u'error': | ||
self._abort_queues() | ||||
|
r2778 | |||
|
r7491 | self._publish_status(u'idle', parent) | ||
|
r3035 | |||
|
r6790 | def complete_request(self, stream, ident, parent): | ||
|
r2856 | txt, matches = self._complete(parent) | ||
matches = {'matches' : matches, | ||||
'matched_text' : txt, | ||||
|
r2778 | 'status' : 'ok'} | ||
|
r4782 | matches = json_clean(matches) | ||
|
r6790 | completion_msg = self.session.send(stream, 'complete_reply', | ||
|
r2778 | matches, parent, ident) | ||
|
r6783 | self.log.debug("%s", completion_msg) | ||
|
r2778 | |||
|
r6790 | def object_info_request(self, stream, ident, parent): | ||
|
r6556 | content = parent['content'] | ||
object_info = self.shell.object_inspect(content['oname'], | ||||
detail_level = content.get('detail_level', 0) | ||||
) | ||||
|
r3051 | # Before we send this object over, we scrub it for JSON usage | ||
oinfo = json_clean(object_info) | ||||
|
r6790 | msg = self.session.send(stream, 'object_info_reply', | ||
|
r2948 | oinfo, parent, ident) | ||
|
r6783 | self.log.debug("%s", msg) | ||
|
r2795 | |||
|
r6790 | def history_request(self, stream, ident, parent): | ||
|
r3404 | # We need to pull these out, as passing **kwargs doesn't work with | ||
# unicode keys before Python 2.6.5. | ||||
|
r3817 | hist_access_type = parent['content']['hist_access_type'] | ||
|
r2844 | raw = parent['content']['raw'] | ||
|
r3404 | output = parent['content']['output'] | ||
|
r3817 | if hist_access_type == 'tail': | ||
n = parent['content']['n'] | ||||
hist = self.shell.history_manager.get_tail(n, raw=raw, output=output, | ||||
include_latest=True) | ||||
|
r4872 | |||
|
r3817 | elif hist_access_type == 'range': | ||
session = parent['content']['session'] | ||||
start = parent['content']['start'] | ||||
stop = parent['content']['stop'] | ||||
hist = self.shell.history_manager.get_range(session, start, stop, | ||||
raw=raw, output=output) | ||||
|
r4872 | |||
|
r3817 | elif hist_access_type == 'search': | ||
|
r8404 | n = parent['content'].get('n') | ||
|
r9415 | unique = parent['content'].get('unique', False) | ||
|
r3817 | pattern = parent['content']['pattern'] | ||
|
r9413 | hist = self.shell.history_manager.search( | ||
pattern, raw=raw, output=output, n=n, unique=unique) | ||||
|
r4872 | |||
|
r3817 | else: | ||
hist = [] | ||||
|
r6057 | hist = list(hist) | ||
content = {'history' : hist} | ||||
|
r4782 | content = json_clean(content) | ||
|
r6790 | msg = self.session.send(stream, 'history_reply', | ||
|
r2795 | content, parent, ident) | ||
|
r6057 | self.log.debug("Sending history reply with %i entries", len(hist)) | ||
|
r3019 | |||
|
r6790 | def connect_request(self, stream, ident, parent): | ||
|
r3019 | if self._recorded_ports is not None: | ||
content = self._recorded_ports.copy() | ||||
else: | ||||
content = {} | ||||
|
r6790 | msg = self.session.send(stream, 'connect_reply', | ||
|
r3019 | content, parent, ident) | ||
|
r6783 | self.log.debug("%s", msg) | ||
|
r3019 | |||
|
r8879 | def kernel_info_request(self, stream, ident, parent): | ||
|
r8830 | vinfo = { | ||
|
r8861 | 'protocol_version': protocol_version, | ||
'ipython_version': ipython_version, | ||||
'language_version': language_version, | ||||
'language': 'python', | ||||
|
r8830 | } | ||
|
r8879 | msg = self.session.send(stream, 'kernel_info_reply', | ||
|
r8830 | vinfo, parent, ident) | ||
self.log.debug("%s", msg) | ||||
|
r6790 | def shutdown_request(self, stream, ident, parent): | ||
|
r2972 | self.shell.exit_now = True | ||
|
r6799 | content = dict(status='ok') | ||
content.update(parent['content']) | ||||
self.session.send(stream, u'shutdown_reply', content, parent, ident=ident) | ||||
# same content, but different msg_id for broadcasting on IOPub | ||||
|
r5471 | self._shutdown_message = self.session.msg(u'shutdown_reply', | ||
|
r6799 | content, parent | ||
|
r6790 | ) | ||
self._at_shutdown() | ||||
# call sys.exit after a short delay | ||||
|
r6826 | loop = ioloop.IOLoop.instance() | ||
loop.add_timeout(time.time()+0.1, loop.stop) | ||||
|
r3019 | |||
|
r2778 | #--------------------------------------------------------------------------- | ||
|
r6782 | # Engine methods | ||
#--------------------------------------------------------------------------- | ||||
|
r6790 | def apply_request(self, stream, ident, parent): | ||
|
r6782 | try: | ||
content = parent[u'content'] | ||||
bufs = parent[u'buffers'] | ||||
msg_id = parent['header']['msg_id'] | ||||
except: | ||||
|
r6783 | self.log.error("Got bad msg: %s", parent, exc_info=True) | ||
|
r6782 | return | ||
|
r6834 | |||
|
r7491 | self._publish_status(u'busy', parent) | ||
|
r9556 | |||
|
r6834 | # Set the parent message of the display hook and out streams. | ||
|
r7469 | shell = self.shell | ||
shell.displayhook.set_parent(parent) | ||||
shell.display_pub.set_parent(parent) | ||||
|
r8102 | shell.data_pub.set_parent(parent) | ||
|
r9556 | try: | ||
sys.stdout.set_parent(parent) | ||||
except AttributeError: | ||||
pass | ||||
try: | ||||
sys.stderr.set_parent(parent) | ||||
except AttributeError: | ||||
pass | ||||
|
r6834 | |||
|
r6782 | # pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent) | ||
|
r6804 | # self.iopub_socket.send(pyin_msg) | ||
# self.session.send(self.iopub_socket, u'pyin', {u'code':code},parent=parent) | ||||
|
r7957 | md = self._make_metadata(parent['metadata']) | ||
|
r6782 | try: | ||
|
r7469 | working = shell.user_ns | ||
|
r6796 | |||
|
r6782 | prefix = "_"+str(msg_id).replace("-","")+"_" | ||
f,args,kwargs = unpack_apply_message(bufs, working, copy=False) | ||||
fname = getattr(f, '__name__', 'f') | ||||
fname = prefix+"f" | ||||
argname = prefix+"args" | ||||
kwargname = prefix+"kwargs" | ||||
resultname = prefix+"result" | ||||
ns = { fname : f, argname : args, kwargname : kwargs , resultname : None } | ||||
# print ns | ||||
working.update(ns) | ||||
|
r6796 | code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname) | ||
|
r6782 | try: | ||
|
r7469 | exec code in shell.user_global_ns, shell.user_ns | ||
|
r6782 | result = working.get(resultname) | ||
finally: | ||||
for key in ns.iterkeys(): | ||||
working.pop(key) | ||||
|
r8033 | result_buf = serialize_object(result, | ||
buffer_threshold=self.session.buffer_threshold, | ||||
item_threshold=self.session.item_threshold, | ||||
) | ||||
|
r7967 | |||
|
r6782 | except: | ||
|
r7469 | # invoke IPython traceback formatting | ||
shell.showtraceback() | ||||
# FIXME - fish exception info out of shell, possibly left there by | ||||
# run_code. We'll need to clean up this logic later. | ||||
reply_content = {} | ||||
if shell._reply_content is not None: | ||||
reply_content.update(shell._reply_content) | ||||
e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply') | ||||
reply_content['engine_info'] = e_info | ||||
# reset after use | ||||
shell._reply_content = None | ||||
self.session.send(self.iopub_socket, u'pyerr', reply_content, parent=parent, | ||||
|
r6795 | ident=self._topic('pyerr')) | ||
|
r8579 | self.log.info("Exception in apply request:\n%s", '\n'.join(reply_content['traceback'])) | ||
|
r6782 | result_buf = [] | ||
|
r7469 | if reply_content['ename'] == 'UnmetDependency': | ||
|
r7957 | md['dependencies_met'] = False | ||
|
r6782 | else: | ||
reply_content = {'status' : 'ok'} | ||||
# put 'ok'/'error' status in header, for scheduler introspection: | ||||
|
r7957 | md['status'] = reply_content['status'] | ||
|
r6782 | |||
# flush i/o | ||||
sys.stdout.flush() | ||||
sys.stderr.flush() | ||||
|
r6783 | |||
|
r6790 | reply_msg = self.session.send(stream, u'apply_reply', reply_content, | ||
|
r7957 | parent=parent, ident=ident,buffers=result_buf, metadata=md) | ||
|
r6782 | |||
|
r7491 | self._publish_status(u'idle', parent) | ||
|
r6782 | #--------------------------------------------------------------------------- | ||
# Control messages | ||||
#--------------------------------------------------------------------------- | ||||
|
r6790 | def abort_request(self, stream, ident, parent): | ||
|
r6782 | """abort a specifig msg by id""" | ||
msg_ids = parent['content'].get('msg_ids', None) | ||||
if isinstance(msg_ids, basestring): | ||||
msg_ids = [msg_ids] | ||||
if not msg_ids: | ||||
self.abort_queues() | ||||
for mid in msg_ids: | ||||
self.aborted.add(str(mid)) | ||||
content = dict(status='ok') | ||||
|
r6790 | reply_msg = self.session.send(stream, 'abort_reply', content=content, | ||
|
r6782 | parent=parent, ident=ident) | ||
|
r6783 | self.log.debug("%s", reply_msg) | ||
|
r6782 | |||
|
r6790 | def clear_request(self, stream, idents, parent): | ||
|
r6782 | """Clear our namespace.""" | ||
|
r6796 | self.shell.reset(False) | ||
|
r6790 | msg = self.session.send(stream, 'clear_reply', ident=idents, parent=parent, | ||
|
r6782 | content = dict(status='ok')) | ||
#--------------------------------------------------------------------------- | ||||
|
r2778 | # Protected interface | ||
#--------------------------------------------------------------------------- | ||||
|
r2598 | |||
|
r6796 | def _wrap_exception(self, method=None): | ||
# import here, because _wrap_exception is only used in parallel, | ||||
# and parallel has higher min pyzmq version | ||||
from IPython.parallel.error import wrap_exception | ||||
e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method=method) | ||||
content = wrap_exception(e_info) | ||||
return content | ||||
|
r6795 | def _topic(self, topic): | ||
"""prefixed topic for IOPub messages""" | ||||
if self.int_id >= 0: | ||||
base = "engine.%i" % self.int_id | ||||
else: | ||||
base = "kernel.%s" % self.ident | ||||
return py3compat.cast_bytes("%s.%s" % (base, topic)) | ||||
|
r6785 | def _abort_queues(self): | ||
|
r6790 | for stream in self.shell_streams: | ||
if stream: | ||||
self._abort_queue(stream) | ||||
|
r6785 | |||
|
r6790 | def _abort_queue(self, stream): | ||
|
r6799 | poller = zmq.Poller() | ||
poller.register(stream.socket, zmq.POLLIN) | ||||
|
r2778 | while True: | ||
|
r6790 | idents,msg = self.session.recv(stream, zmq.NOBLOCK, content=True) | ||
|
r3269 | if msg is None: | ||
|
r6785 | return | ||
|
r3322 | |||
|
r6785 | self.log.info("Aborting:") | ||
self.log.info("%s", msg) | ||||
|
r4230 | msg_type = msg['header']['msg_type'] | ||
|
r2778 | reply_type = msg_type.split('_')[0] + '_reply' | ||
|
r6807 | |||
status = {'status' : 'aborted'} | ||||
|
r7957 | md = {'engine' : self.ident} | ||
md.update(status) | ||||
|
r7978 | reply_msg = self.session.send(stream, reply_type, metadata=md, | ||
|
r6807 | content=status, parent=msg, ident=idents) | ||
|
r6783 | self.log.debug("%s", reply_msg) | ||
|
r2778 | # We need to wait a bit for requests to come in. This can probably | ||
# be set shorter for true asynchronous clients. | ||||
|
r6799 | poller.poll(50) | ||
|
r6785 | |||
|
r2778 | |||
|
r4952 | def _no_raw_input(self): | ||
|
r5471 | """Raise StdinNotImplentedError if active frontend doesn't support | ||
stdin.""" | ||||
raise StdinNotImplementedError("raw_input was called, but this " | ||||
"frontend does not support stdin.") | ||||
|
r4952 | |||
|
r2778 | def _raw_input(self, prompt, ident, parent): | ||
|
r2730 | # Flush output before making the request. | ||
sys.stderr.flush() | ||||
sys.stdout.flush() | ||||
|
r10367 | # flush the stdin socket, to purge stale replies | ||
while True: | ||||
try: | ||||
self.stdin_socket.recv_multipart(zmq.NOBLOCK) | ||||
except zmq.ZMQError as e: | ||||
if e.errno == zmq.EAGAIN: | ||||
break | ||||
else: | ||||
raise | ||||
|
r2730 | # Send the input request. | ||
|
r4782 | content = json_clean(dict(prompt=prompt)) | ||
|
r5471 | self.session.send(self.stdin_socket, u'input_request', content, parent, | ||
ident=ident) | ||||
|
r2730 | |||
# Await a response. | ||||
|
r4521 | while True: | ||
try: | ||||
ident, reply = self.session.recv(self.stdin_socket, 0) | ||||
except Exception: | ||||
self.log.warn("Invalid Message:", exc_info=True) | ||||
|
r11706 | except KeyboardInterrupt: | ||
# re-raise KeyboardInterrupt, to truncate traceback | ||||
raise KeyboardInterrupt | ||||
|
r4521 | else: | ||
break | ||||
|
r2730 | try: | ||
|
r11154 | value = py3compat.unicode_to_str(reply['content']['value']) | ||
|
r2730 | except: | ||
|
r3970 | self.log.error("Got bad raw_input reply: ") | ||
|
r6783 | self.log.error("%s", parent) | ||
|
r2730 | value = '' | ||
|
r5622 | if value == '\x04': | ||
# EOF | ||||
raise EOFError | ||||
|
r2730 | return value | ||
|
r4872 | |||
|
r2778 | def _complete(self, msg): | ||
|
r2839 | c = msg['content'] | ||
try: | ||||
cpos = int(c['cursor_pos']) | ||||
except: | ||||
# If we don't get something that we can convert to an integer, at | ||||
|
r2856 | # least attempt the completion guessing the cursor is at the end of | ||
# the text, if there's any, and otherwise of the line | ||||
|
r2839 | cpos = len(c['text']) | ||
|
r2856 | if cpos==0: | ||
cpos = len(c['line']) | ||||
|
r2839 | return self.shell.complete(c['text'], c['line'], cpos) | ||
|
r2598 | |||
|
r2972 | def _at_shutdown(self): | ||
"""Actions taken at shutdown by the kernel, called by python's atexit. | ||||
""" | ||||
# io.rprint("Kernel at_shutdown") # dbg | ||||
if self._shutdown_message is not None: | ||||
|
r6804 | self.session.send(self.iopub_socket, self._shutdown_message, ident=self._topic('shutdown')) | ||
|
r6783 | self.log.debug("%s", self._shutdown_message) | ||
|
r6804 | [ s.flush(zmq.POLLOUT) for s in self.shell_streams ] | ||
|
r2972 | |||