kernelapp.py
455 lines
| 17.6 KiB
| text/x-python
|
PythonLexer
|
r3970 | """An Application for launching a kernel | ||
Authors | ||||
------- | ||||
* MinRK | ||||
""" | ||||
#----------------------------------------------------------------------------- | ||||
# Copyright (C) 2011 The IPython Development Team | ||||
# | ||||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING.txt, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
|
r9357 | from __future__ import print_function | ||
|
r6790 | # Standard library imports | ||
|
r6889 | import atexit | ||
|
r4986 | import json | ||
|
r3970 | import os | ||
import sys | ||||
|
r6790 | import signal | ||
|
r3970 | |||
|
r6790 | # System library imports | ||
|
r3970 | import zmq | ||
|
r6790 | from zmq.eventloop import ioloop | ||
|
r9357 | from zmq.eventloop.zmqstream import ZMQStream | ||
|
r3970 | |||
|
r6790 | # IPython imports | ||
|
r3970 | from IPython.core.ultratb import FormattedTB | ||
|
r4023 | from IPython.core.application import ( | ||
|
r5214 | BaseIPythonApplication, base_flags, base_aliases, catch_config_error | ||
|
r3970 | ) | ||
|
r9357 | from IPython.core.profiledir import ProfileDir | ||
from IPython.core.shellapp import ( | ||||
InteractiveShellApp, shell_flags, shell_aliases | ||||
) | ||||
|
r3970 | from IPython.utils import io | ||
from IPython.utils.localinterfaces import LOCALHOST | ||||
|
r4958 | from IPython.utils.path import filefind | ||
|
r4967 | from IPython.utils.py3compat import str_to_bytes | ||
|
r7321 | from IPython.utils.traitlets import ( | ||
Any, Instance, Dict, Unicode, Integer, Bool, CaselessStrEnum, | ||||
DottedObjectName, | ||||
) | ||||
|
r3970 | from IPython.utils.importstring import import_item | ||
|
r9353 | from IPython.kernel import write_connection_file | ||
|
r9357 | |||
|
r3970 | # local imports | ||
|
r9357 | from heartbeat import Heartbeat | ||
from ipkernel import Kernel | ||||
from parentpoller import ParentPollerUnix, ParentPollerWindows | ||||
from session import ( | ||||
|
r4962 | Session, session_flags, session_aliases, default_secure, | ||
) | ||||
|
r9357 | from zmqshell import ZMQInteractiveShell | ||
|
r3970 | |||
#----------------------------------------------------------------------------- | ||||
# Flags and Aliases | ||||
#----------------------------------------------------------------------------- | ||||
kernel_aliases = dict(base_aliases) | ||||
kernel_aliases.update({ | ||||
|
r9357 | 'ip' : 'IPKernelApp.ip', | ||
'hb' : 'IPKernelApp.hb_port', | ||||
'shell' : 'IPKernelApp.shell_port', | ||||
'iopub' : 'IPKernelApp.iopub_port', | ||||
'stdin' : 'IPKernelApp.stdin_port', | ||||
|
r10296 | 'control' : 'IPKernelApp.control_port', | ||
|
r9357 | 'f' : 'IPKernelApp.connection_file', | ||
|
r11064 | 'parent': 'IPKernelApp.parent_handle', | ||
|
r9357 | 'transport': 'IPKernelApp.transport', | ||
|
r3970 | }) | ||
if sys.platform.startswith('win'): | ||||
|
r9516 | kernel_aliases['interrupt'] = 'IPKernelApp.interrupt' | ||
|
r3970 | |||
kernel_flags = dict(base_flags) | ||||
kernel_flags.update({ | ||||
'no-stdout' : ( | ||||
|
r9357 | {'IPKernelApp' : {'no_stdout' : True}}, | ||
|
r3970 | "redirect stdout to the null device"), | ||
'no-stderr' : ( | ||||
|
r9357 | {'IPKernelApp' : {'no_stderr' : True}}, | ||
|
r3970 | "redirect stderr to the null device"), | ||
|
r9357 | 'pylab' : ( | ||
{'IPKernelApp' : {'pylab' : 'auto'}}, | ||||
"""Pre-load matplotlib and numpy for interactive use with | ||||
the default matplotlib backend."""), | ||||
|
r3970 | }) | ||
|
r9357 | # inherit flags&aliases for any IPython shell apps | ||
kernel_aliases.update(shell_aliases) | ||||
kernel_flags.update(shell_flags) | ||||
|
r4962 | # inherit flags&aliases for Sessions | ||
kernel_aliases.update(session_aliases) | ||||
kernel_flags.update(session_flags) | ||||
|
r3970 | #----------------------------------------------------------------------------- | ||
|
r9357 | # Application class for starting an IPython Kernel | ||
|
r3970 | #----------------------------------------------------------------------------- | ||
|
r9357 | class IPKernelApp(BaseIPythonApplication, InteractiveShellApp): | ||
|
r6806 | name='ipkernel' | ||
|
r3970 | aliases = Dict(kernel_aliases) | ||
flags = Dict(kernel_flags) | ||||
|
r9357 | classes = [Kernel, ZMQInteractiveShell, ProfileDir, Session] | ||
|
r3970 | # the kernel class, as an importstring | ||
|
r10046 | kernel_class = DottedObjectName('IPython.kernel.zmq.ipkernel.Kernel', config=True, | ||
help="""The Kernel subclass to be used. | ||||
This should allow easy re-use of the IPKernelApp entry point | ||||
to configure and launch kernels other than IPython's own. | ||||
""") | ||||
|
r3970 | kernel = Any() | ||
poller = Any() # don't restrict this even though current pollers are all Threads | ||||
heartbeat = Instance(Heartbeat) | ||||
|
r9372 | session = Instance('IPython.kernel.zmq.session.Session') | ||
|
r3970 | ports = Dict() | ||
|
r4118 | |||
# inherit config file name from parent: | ||||
parent_appname = Unicode(config=True) | ||||
def _parent_appname_changed(self, name, old, new): | ||||
if self.config_file_specified: | ||||
# it was manually specified, ignore | ||||
return | ||||
self.config_file_name = new.replace('-','_') + u'_config.py' | ||||
# don't let this count as specifying the config file | ||||
|
r11278 | self.config_file_specified.remove(self.config_file_name) | ||
|
r4118 | |||
|
r3970 | # connection info: | ||
|
r7321 | transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True) | ||
|
r9175 | ip = Unicode(config=True, | ||
|
r3970 | help="Set the IP or interface on which the kernel will listen.") | ||
|
r9175 | def _ip_default(self): | ||
if self.transport == 'ipc': | ||||
if self.connection_file: | ||||
return os.path.splitext(self.abs_connection_file)[0] + '-ipc' | ||||
else: | ||||
return 'kernel-ipc' | ||||
else: | ||||
return LOCALHOST | ||||
|
r5344 | hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]") | ||
|
r7538 | shell_port = Integer(0, config=True, help="set the shell (ROUTER) port [default: random]") | ||
|
r5344 | iopub_port = Integer(0, config=True, help="set the iopub (PUB) port [default: random]") | ||
|
r10296 | stdin_port = Integer(0, config=True, help="set the stdin (ROUTER) port [default: random]") | ||
control_port = Integer(0, config=True, help="set the control (ROUTER) port [default: random]") | ||||
|
r4958 | connection_file = Unicode('', config=True, | ||
help="""JSON file in which to store connection info [default: kernel-<pid>.json] | ||||
This file will contain the IP, ports, and authentication key needed to connect | ||||
|
r9175 | clients to this kernel. By default, this file will be created in the security dir | ||
|
r4958 | of the current profile, but can be specified by absolute path. | ||
""") | ||||
|
r9175 | @property | ||
def abs_connection_file(self): | ||||
if os.path.basename(self.connection_file) == self.connection_file: | ||||
return os.path.join(self.profile_dir.security_dir, self.connection_file) | ||||
else: | ||||
return self.connection_file | ||||
|
r3970 | |||
# streams, etc. | ||||
no_stdout = Bool(False, config=True, help="redirect stdout to the null device") | ||||
no_stderr = Bool(False, config=True, help="redirect stderr to the null device") | ||||
|
r9372 | outstream_class = DottedObjectName('IPython.kernel.zmq.iostream.OutStream', | ||
|
r4055 | config=True, help="The importstring for the OutStream factory") | ||
|
r9372 | displayhook_class = DottedObjectName('IPython.kernel.zmq.displayhook.ZMQDisplayHook', | ||
|
r4055 | config=True, help="The importstring for the DisplayHook factory") | ||
|
r3970 | |||
# polling | ||||
|
r11064 | parent_handle = Integer(0, config=True, | ||
|
r3970 | help="""kill this process if its parent dies. On Windows, the argument | ||
specifies the HANDLE of the parent process, otherwise it is simply boolean. | ||||
""") | ||||
|
r5344 | interrupt = Integer(0, config=True, | ||
|
r3970 | help="""ONLY USED ON WINDOWS | ||
|
r9175 | Interrupt this process when the parent is signaled. | ||
|
r3970 | """) | ||
def init_crash_handler(self): | ||||
# Install minimal exception handling | ||||
sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor', | ||||
ostream=sys.__stdout__) | ||||
def init_poller(self): | ||||
if sys.platform == 'win32': | ||||
|
r11064 | if self.interrupt or self.parent_handle: | ||
self.poller = ParentPollerWindows(self.interrupt, self.parent_handle) | ||||
elif self.parent_handle: | ||||
|
r3970 | self.poller = ParentPollerUnix() | ||
def _bind_socket(self, s, port): | ||||
|
r7321 | iface = '%s://%s' % (self.transport, self.ip) | ||
|
r9175 | if self.transport == 'tcp': | ||
if port <= 0: | ||||
port = s.bind_to_random_port(iface) | ||||
else: | ||||
s.bind("tcp://%s:%i" % (self.ip, port)) | ||||
elif self.transport == 'ipc': | ||||
if port <= 0: | ||||
|
r9243 | port = 1 | ||
path = "%s-%i" % (self.ip, port) | ||||
while os.path.exists(path): | ||||
port = port + 1 | ||||
|
r9175 | path = "%s-%i" % (self.ip, port) | ||
else: | ||||
path = "%s-%i" % (self.ip, port) | ||||
s.bind("ipc://%s" % path) | ||||
|
r3970 | return port | ||
|
r4958 | def load_connection_file(self): | ||
"""load ip/port/hmac config from JSON connection file""" | ||||
try: | ||||
fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir]) | ||||
except IOError: | ||||
self.log.debug("Connection file not found: %s", self.connection_file) | ||||
|
r6889 | # This means I own it, so I will clean it up: | ||
atexit.register(self.cleanup_connection_file) | ||||
|
r4958 | return | ||
self.log.debug(u"Loading connection file %s", fname) | ||||
with open(fname) as f: | ||||
s = f.read() | ||||
cfg = json.loads(s) | ||||
|
r7321 | self.transport = cfg.get('transport', self.transport) | ||
|
r9175 | if self.ip == self._ip_default() and 'ip' in cfg: | ||
|
r4958 | # not overridden by config or cl_args | ||
self.ip = cfg['ip'] | ||||
|
r10296 | for channel in ('hb', 'shell', 'iopub', 'stdin', 'control'): | ||
|
r4958 | name = channel + '_port' | ||
if getattr(self, name) == 0 and name in cfg: | ||||
# not overridden by config or cl_args | ||||
setattr(self, name, cfg[name]) | ||||
if 'key' in cfg: | ||||
|
r4967 | self.config.Session.key = str_to_bytes(cfg['key']) | ||
|
r4958 | |||
def write_connection_file(self): | ||||
"""write connection info to JSON file""" | ||||
|
r9175 | cf = self.abs_connection_file | ||
self.log.debug("Writing connection file: %s", cf) | ||||
|
r7321 | write_connection_file(cf, ip=self.ip, key=self.session.key, transport=self.transport, | ||
|
r4958 | shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port, | ||
|
r10296 | iopub_port=self.iopub_port, control_port=self.control_port) | ||
|
r6889 | |||
def cleanup_connection_file(self): | ||||
|
r9175 | cf = self.abs_connection_file | ||
self.log.debug("Cleaning up connection file: %s", cf) | ||||
|
r6889 | try: | ||
os.remove(cf) | ||||
except (IOError, OSError): | ||||
pass | ||||
|
r7321 | |||
|
r9119 | self.cleanup_ipc_files() | ||
|
r7321 | |||
|
r9119 | def cleanup_ipc_files(self): | ||
|
r7321 | """cleanup ipc files if we wrote them""" | ||
if self.transport != 'ipc': | ||||
return | ||||
|
r10296 | for port in (self.shell_port, self.iopub_port, self.stdin_port, self.hb_port, self.control_port): | ||
|
r7321 | ipcfile = "%s-%i" % (self.ip, port) | ||
try: | ||||
os.remove(ipcfile) | ||||
except (IOError, OSError): | ||||
pass | ||||
|
r4958 | |||
def init_connection_file(self): | ||||
if not self.connection_file: | ||||
self.connection_file = "kernel-%s.json"%os.getpid() | ||||
|
r4986 | try: | ||
self.load_connection_file() | ||||
except Exception: | ||||
self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True) | ||||
self.exit(1) | ||||
|
r4962 | |||
|
r3970 | def init_sockets(self): | ||
# Create a context, a session, and the kernel sockets. | ||||
|
r4240 | self.log.info("Starting the kernel at pid: %i", os.getpid()) | ||
|
r3970 | context = zmq.Context.instance() | ||
# Uncomment this to try closing the context. | ||||
# atexit.register(context.term) | ||||
|
r4725 | self.shell_socket = context.socket(zmq.ROUTER) | ||
|
r3970 | self.shell_port = self._bind_socket(self.shell_socket, self.shell_port) | ||
|
r10296 | self.log.debug("shell ROUTER Channel on port: %i" % self.shell_port) | ||
|
r3970 | |||
self.iopub_socket = context.socket(zmq.PUB) | ||||
self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port) | ||||
|
r10296 | self.log.debug("iopub PUB Channel on port: %i" % self.iopub_port) | ||
|
r3970 | |||
|
r4952 | self.stdin_socket = context.socket(zmq.ROUTER) | ||
|
r3970 | self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port) | ||
|
r10296 | self.log.debug("stdin ROUTER Channel on port: %i" % self.stdin_port) | ||
self.control_socket = context.socket(zmq.ROUTER) | ||||
self.control_port = self._bind_socket(self.control_socket, self.control_port) | ||||
self.log.debug("control ROUTER Channel on port: %i" % self.control_port) | ||||
|
r6885 | |||
def init_heartbeat(self): | ||||
"""start the heart beating""" | ||||
|
r5883 | # heartbeat doesn't share context, because it mustn't be blocked | ||
# by the GIL, which is accessed by libzmq when freeing zero-copy messages | ||||
hb_ctx = zmq.Context() | ||||
|
r7321 | self.heartbeat = Heartbeat(hb_ctx, (self.transport, self.ip, self.hb_port)) | ||
|
r3970 | self.hb_port = self.heartbeat.port | ||
|
r10296 | self.log.debug("Heartbeat REP Channel on port: %i" % self.hb_port) | ||
|
r6826 | self.heartbeat.start() | ||
|
r6885 | |||
def log_connection_info(self): | ||||
"""display connection info, and store ports""" | ||||
|
r4980 | basename = os.path.basename(self.connection_file) | ||
if basename == self.connection_file or \ | ||||
os.path.dirname(self.connection_file) == self.profile_dir.security_dir: | ||||
|
r4958 | # use shortname | ||
|
r4980 | tail = basename | ||
|
r4958 | if self.profile != 'default': | ||
|
r4980 | tail += " --profile %s" % self.profile | ||
|
r4958 | else: | ||
tail = self.connection_file | ||||
|
r10563 | lines = [ | ||
"To connect another client to this kernel, use:", | ||||
" --existing %s" % tail, | ||||
] | ||||
# log connection info | ||||
# info-level, so often not shown. | ||||
# frontends should use the %connect_info magic | ||||
# to see the connection info | ||||
for line in lines: | ||||
self.log.info(line) | ||||
|
r11064 | # also raw print to the terminal if no parent_handle (`ipython kernel`) | ||
if not self.parent_handle: | ||||
|
r10563 | for line in lines: | ||
io.rprint(line) | ||||
|
r3970 | |||
self.ports = dict(shell=self.shell_port, iopub=self.iopub_port, | ||||
|
r10296 | stdin=self.stdin_port, hb=self.hb_port, | ||
control=self.control_port) | ||||
|
r3970 | |||
def init_session(self): | ||||
"""create our session object""" | ||||
|
r4962 | default_secure(self.config) | ||
|
r11064 | self.session = Session(parent=self, username=u'kernel') | ||
|
r3970 | |||
|
r4112 | def init_blackhole(self): | ||
"""redirects stdout/stderr to devnull if necessary""" | ||||
|
r3970 | if self.no_stdout or self.no_stderr: | ||
|
r6650 | blackhole = open(os.devnull, 'w') | ||
|
r3970 | if self.no_stdout: | ||
sys.stdout = sys.__stdout__ = blackhole | ||||
if self.no_stderr: | ||||
sys.stderr = sys.__stderr__ = blackhole | ||||
|
r4112 | |||
def init_io(self): | ||||
"""Redirect input streams and set a display hook.""" | ||||
|
r3970 | if self.outstream_class: | ||
outstream_factory = import_item(str(self.outstream_class)) | ||||
sys.stdout = outstream_factory(self.session, self.iopub_socket, u'stdout') | ||||
sys.stderr = outstream_factory(self.session, self.iopub_socket, u'stderr') | ||||
if self.displayhook_class: | ||||
displayhook_factory = import_item(str(self.displayhook_class)) | ||||
sys.displayhook = displayhook_factory(self.session, self.iopub_socket) | ||||
|
r6790 | def init_signal(self): | ||
signal.signal(signal.SIGINT, signal.SIG_IGN) | ||||
|
r3970 | def init_kernel(self): | ||
"""Create the Kernel object itself""" | ||||
|
r9357 | shell_stream = ZMQStream(self.shell_socket) | ||
|
r10296 | control_stream = ZMQStream(self.control_socket) | ||
|
r10046 | |||
kernel_factory = import_item(str(self.kernel_class)) | ||||
|
r9357 | |||
|
r11064 | kernel = kernel_factory(parent=self, session=self.session, | ||
|
r10296 | shell_streams=[shell_stream, control_stream], | ||
|
r3970 | iopub_socket=self.iopub_socket, | ||
stdin_socket=self.stdin_socket, | ||||
|
r9357 | log=self.log, | ||
profile_dir=self.profile_dir, | ||||
|
r3970 | ) | ||
|
r9357 | kernel.record_ports(self.ports) | ||
self.kernel = kernel | ||||
def init_gui_pylab(self): | ||||
"""Enable GUI event loop integration, taking pylab into account.""" | ||||
# Provide a wrapper for :meth:`InteractiveShellApp.init_gui_pylab` | ||||
# to ensure that any exception is printed straight to stderr. | ||||
# Normally _showtraceback associates the reply with an execution, | ||||
# which means frontends will never draw it, as this exception | ||||
# is not associated with any execute request. | ||||
shell = self.shell | ||||
_showtraceback = shell._showtraceback | ||||
try: | ||||
# replace pyerr-sending traceback with stderr | ||||
def print_tb(etype, evalue, stb): | ||||
print ("GUI event loop or pylab initialization failed", | ||||
file=io.stderr) | ||||
print (shell.InteractiveTB.stb2text(stb), file=io.stderr) | ||||
shell._showtraceback = print_tb | ||||
InteractiveShellApp.init_gui_pylab(self) | ||||
finally: | ||||
shell._showtraceback = _showtraceback | ||||
def init_shell(self): | ||||
self.shell = self.kernel.shell | ||||
self.shell.configurables.append(self) | ||||
|
r3970 | |||
|
r5214 | @catch_config_error | ||
|
r3970 | def initialize(self, argv=None): | ||
|
r9357 | super(IPKernelApp, self).initialize(argv) | ||
|
r4112 | self.init_blackhole() | ||
|
r4958 | self.init_connection_file() | ||
|
r3970 | self.init_session() | ||
self.init_poller() | ||||
self.init_sockets() | ||||
|
r6885 | self.init_heartbeat() | ||
# writing/displaying connection info must be *after* init_sockets/heartbeat | ||||
self.log_connection_info() | ||||
|
r4958 | self.write_connection_file() | ||
|
r3970 | self.init_io() | ||
|
r6790 | self.init_signal() | ||
|
r3970 | self.init_kernel() | ||
|
r9357 | # shell init steps | ||
self.init_path() | ||||
self.init_shell() | ||||
self.init_gui_pylab() | ||||
self.init_extensions() | ||||
self.init_code() | ||||
|
r5361 | # flush stdout/stderr, so that anything written to these streams during | ||
# initialization do not get associated with the first execution request | ||||
sys.stdout.flush() | ||||
sys.stderr.flush() | ||||
|
r3970 | |||
def start(self): | ||||
if self.poller is not None: | ||||
self.poller.start() | ||||
|
r6790 | self.kernel.start() | ||
|
r3970 | try: | ||
|
r6790 | ioloop.IOLoop.instance().start() | ||
|
r3970 | except KeyboardInterrupt: | ||
pass | ||||
|
r4021 | |||
|
r9357 | |||
def main(): | ||||
"""Run an IPKernel as an application""" | ||||
app = IPKernelApp.instance() | ||||
app.initialize() | ||||
app.start() | ||||
if __name__ == '__main__': | ||||
main() | ||||