kernelapp.py
372 lines
| 14.4 KiB
| text/x-python
|
PythonLexer
MinRK
|
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 | ||||
#----------------------------------------------------------------------------- | ||||
MinRK
|
r6790 | # Standard library imports | ||
MinRK
|
r6889 | import atexit | ||
MinRK
|
r4986 | import json | ||
MinRK
|
r3970 | import os | ||
import sys | ||||
MinRK
|
r6790 | import signal | ||
MinRK
|
r3970 | |||
MinRK
|
r6790 | # System library imports | ||
MinRK
|
r3970 | import zmq | ||
MinRK
|
r6790 | from zmq.eventloop import ioloop | ||
MinRK
|
r3970 | |||
MinRK
|
r6790 | # IPython imports | ||
MinRK
|
r3970 | from IPython.core.ultratb import FormattedTB | ||
MinRK
|
r4023 | from IPython.core.application import ( | ||
MinRK
|
r5214 | BaseIPythonApplication, base_flags, base_aliases, catch_config_error | ||
MinRK
|
r3970 | ) | ||
from IPython.utils import io | ||||
from IPython.utils.localinterfaces import LOCALHOST | ||||
MinRK
|
r4958 | from IPython.utils.path import filefind | ||
MinRK
|
r4967 | from IPython.utils.py3compat import str_to_bytes | ||
MinRK
|
r7321 | from IPython.utils.traitlets import ( | ||
Any, Instance, Dict, Unicode, Integer, Bool, CaselessStrEnum, | ||||
DottedObjectName, | ||||
) | ||||
MinRK
|
r3970 | from IPython.utils.importstring import import_item | ||
MinRK
|
r9353 | from IPython.kernel import write_connection_file | ||
MinRK
|
r3970 | # local imports | ||
from IPython.zmq.heartbeat import Heartbeat | ||||
from IPython.zmq.parentpoller import ParentPollerUnix, ParentPollerWindows | ||||
MinRK
|
r4962 | from IPython.zmq.session import ( | ||
Session, session_flags, session_aliases, default_secure, | ||||
) | ||||
MinRK
|
r3970 | |||
#----------------------------------------------------------------------------- | ||||
# Flags and Aliases | ||||
#----------------------------------------------------------------------------- | ||||
kernel_aliases = dict(base_aliases) | ||||
kernel_aliases.update({ | ||||
'ip' : 'KernelApp.ip', | ||||
'hb' : 'KernelApp.hb_port', | ||||
'shell' : 'KernelApp.shell_port', | ||||
'iopub' : 'KernelApp.iopub_port', | ||||
'stdin' : 'KernelApp.stdin_port', | ||||
MinRK
|
r4958 | 'f' : 'KernelApp.connection_file', | ||
MinRK
|
r3970 | 'parent': 'KernelApp.parent', | ||
MinRK
|
r9175 | 'transport': 'KernelApp.transport', | ||
MinRK
|
r3970 | }) | ||
if sys.platform.startswith('win'): | ||||
kernel_aliases['interrupt'] = 'KernelApp.interrupt' | ||||
kernel_flags = dict(base_flags) | ||||
kernel_flags.update({ | ||||
'no-stdout' : ( | ||||
{'KernelApp' : {'no_stdout' : True}}, | ||||
"redirect stdout to the null device"), | ||||
'no-stderr' : ( | ||||
{'KernelApp' : {'no_stderr' : True}}, | ||||
"redirect stderr to the null device"), | ||||
}) | ||||
MinRK
|
r4962 | # inherit flags&aliases for Sessions | ||
kernel_aliases.update(session_aliases) | ||||
kernel_flags.update(session_flags) | ||||
MinRK
|
r3970 | |||
#----------------------------------------------------------------------------- | ||||
# Application class for starting a Kernel | ||||
#----------------------------------------------------------------------------- | ||||
class KernelApp(BaseIPythonApplication): | ||||
MinRK
|
r6806 | name='ipkernel' | ||
MinRK
|
r3970 | aliases = Dict(kernel_aliases) | ||
flags = Dict(kernel_flags) | ||||
MinRK
|
r4015 | classes = [Session] | ||
MinRK
|
r3970 | # the kernel class, as an importstring | ||
MinRK
|
r6806 | kernel_class = DottedObjectName('IPython.zmq.ipkernel.Kernel') | ||
MinRK
|
r3970 | kernel = Any() | ||
poller = Any() # don't restrict this even though current pollers are all Threads | ||||
heartbeat = Instance(Heartbeat) | ||||
session = Instance('IPython.zmq.session.Session') | ||||
ports = Dict() | ||||
MinRK
|
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 | ||||
self.config_file_specified = False | ||||
MinRK
|
r3970 | # connection info: | ||
MinRK
|
r7321 | transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True) | ||
MinRK
|
r9175 | ip = Unicode(config=True, | ||
MinRK
|
r3970 | help="Set the IP or interface on which the kernel will listen.") | ||
MinRK
|
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 | ||||
MinRK
|
r5344 | hb_port = Integer(0, config=True, help="set the heartbeat port [default: random]") | ||
MinRK
|
r7538 | shell_port = Integer(0, config=True, help="set the shell (ROUTER) port [default: random]") | ||
MinRK
|
r5344 | iopub_port = Integer(0, config=True, help="set the iopub (PUB) port [default: random]") | ||
MinRK
|
r7538 | stdin_port = Integer(0, config=True, help="set the stdin (DEALER) port [default: random]") | ||
MinRK
|
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 | ||||
MinRK
|
r9175 | clients to this kernel. By default, this file will be created in the security dir | ||
MinRK
|
r4958 | of the current profile, but can be specified by absolute path. | ||
""") | ||||
MinRK
|
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 | ||||
MinRK
|
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") | ||||
Thomas Kluyver
|
r4055 | outstream_class = DottedObjectName('IPython.zmq.iostream.OutStream', | ||
config=True, help="The importstring for the OutStream factory") | ||||
Thomas Kluyver
|
r4073 | displayhook_class = DottedObjectName('IPython.zmq.displayhook.ZMQDisplayHook', | ||
Thomas Kluyver
|
r4055 | config=True, help="The importstring for the DisplayHook factory") | ||
MinRK
|
r3970 | |||
# polling | ||||
MinRK
|
r5344 | parent = Integer(0, config=True, | ||
MinRK
|
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. | ||||
""") | ||||
MinRK
|
r5344 | interrupt = Integer(0, config=True, | ||
MinRK
|
r3970 | help="""ONLY USED ON WINDOWS | ||
MinRK
|
r9175 | Interrupt this process when the parent is signaled. | ||
MinRK
|
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': | ||||
if self.interrupt or self.parent: | ||||
self.poller = ParentPollerWindows(self.interrupt, self.parent) | ||||
elif self.parent: | ||||
self.poller = ParentPollerUnix() | ||||
def _bind_socket(self, s, port): | ||||
MinRK
|
r7321 | iface = '%s://%s' % (self.transport, self.ip) | ||
MinRK
|
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: | ||||
MinRK
|
r9243 | port = 1 | ||
path = "%s-%i" % (self.ip, port) | ||||
while os.path.exists(path): | ||||
port = port + 1 | ||||
MinRK
|
r9175 | path = "%s-%i" % (self.ip, port) | ||
else: | ||||
path = "%s-%i" % (self.ip, port) | ||||
s.bind("ipc://%s" % path) | ||||
MinRK
|
r3970 | return port | ||
MinRK
|
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) | ||||
MinRK
|
r6889 | # This means I own it, so I will clean it up: | ||
atexit.register(self.cleanup_connection_file) | ||||
MinRK
|
r4958 | return | ||
self.log.debug(u"Loading connection file %s", fname) | ||||
with open(fname) as f: | ||||
s = f.read() | ||||
cfg = json.loads(s) | ||||
MinRK
|
r7321 | self.transport = cfg.get('transport', self.transport) | ||
MinRK
|
r9175 | if self.ip == self._ip_default() and 'ip' in cfg: | ||
MinRK
|
r4958 | # not overridden by config or cl_args | ||
self.ip = cfg['ip'] | ||||
for channel in ('hb', 'shell', 'iopub', 'stdin'): | ||||
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: | ||||
MinRK
|
r4967 | self.config.Session.key = str_to_bytes(cfg['key']) | ||
MinRK
|
r4958 | |||
def write_connection_file(self): | ||||
"""write connection info to JSON file""" | ||||
MinRK
|
r9175 | cf = self.abs_connection_file | ||
self.log.debug("Writing connection file: %s", cf) | ||||
MinRK
|
r7321 | write_connection_file(cf, ip=self.ip, key=self.session.key, transport=self.transport, | ||
MinRK
|
r4958 | shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port, | ||
iopub_port=self.iopub_port) | ||||
MinRK
|
r6889 | |||
def cleanup_connection_file(self): | ||||
MinRK
|
r9175 | cf = self.abs_connection_file | ||
self.log.debug("Cleaning up connection file: %s", cf) | ||||
MinRK
|
r6889 | try: | ||
os.remove(cf) | ||||
except (IOError, OSError): | ||||
pass | ||||
MinRK
|
r7321 | |||
Brian Granger
|
r9119 | self.cleanup_ipc_files() | ||
MinRK
|
r7321 | |||
Brian Granger
|
r9119 | def cleanup_ipc_files(self): | ||
MinRK
|
r7321 | """cleanup ipc files if we wrote them""" | ||
if self.transport != 'ipc': | ||||
return | ||||
for port in (self.shell_port, self.iopub_port, self.stdin_port, self.hb_port): | ||||
ipcfile = "%s-%i" % (self.ip, port) | ||||
try: | ||||
os.remove(ipcfile) | ||||
except (IOError, OSError): | ||||
pass | ||||
MinRK
|
r4958 | |||
def init_connection_file(self): | ||||
if not self.connection_file: | ||||
self.connection_file = "kernel-%s.json"%os.getpid() | ||||
MinRK
|
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) | ||||
MinRK
|
r4962 | |||
MinRK
|
r3970 | def init_sockets(self): | ||
# Create a context, a session, and the kernel sockets. | ||||
MinRK
|
r4240 | self.log.info("Starting the kernel at pid: %i", os.getpid()) | ||
MinRK
|
r3970 | context = zmq.Context.instance() | ||
# Uncomment this to try closing the context. | ||||
# atexit.register(context.term) | ||||
MinRK
|
r4725 | self.shell_socket = context.socket(zmq.ROUTER) | ||
MinRK
|
r3970 | self.shell_port = self._bind_socket(self.shell_socket, self.shell_port) | ||
MinRK
|
r4725 | self.log.debug("shell ROUTER Channel on port: %i"%self.shell_port) | ||
MinRK
|
r3970 | |||
self.iopub_socket = context.socket(zmq.PUB) | ||||
self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port) | ||||
self.log.debug("iopub PUB Channel on port: %i"%self.iopub_port) | ||||
MinRK
|
r4952 | self.stdin_socket = context.socket(zmq.ROUTER) | ||
MinRK
|
r3970 | self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port) | ||
MinRK
|
r4952 | self.log.debug("stdin ROUTER Channel on port: %i"%self.stdin_port) | ||
MinRK
|
r6885 | |||
def init_heartbeat(self): | ||||
"""start the heart beating""" | ||||
MinRK
|
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() | ||||
MinRK
|
r7321 | self.heartbeat = Heartbeat(hb_ctx, (self.transport, self.ip, self.hb_port)) | ||
MinRK
|
r3970 | self.hb_port = self.heartbeat.port | ||
self.log.debug("Heartbeat REP Channel on port: %i"%self.hb_port) | ||||
MinRK
|
r6826 | self.heartbeat.start() | ||
MinRK
|
r3970 | |||
MinRK
|
r4958 | # Helper to make it easier to connect to an existing kernel. | ||
MinRK
|
r4121 | # set log-level to critical, to make sure it is output | ||
self.log.critical("To connect another client to this kernel, use:") | ||||
MinRK
|
r6885 | |||
def log_connection_info(self): | ||||
"""display connection info, and store ports""" | ||||
MinRK
|
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: | ||||
MinRK
|
r4958 | # use shortname | ||
MinRK
|
r4980 | tail = basename | ||
MinRK
|
r4958 | if self.profile != 'default': | ||
MinRK
|
r4980 | tail += " --profile %s" % self.profile | ||
MinRK
|
r4958 | else: | ||
tail = self.connection_file | ||||
self.log.critical("--existing %s", tail) | ||||
MinRK
|
r3970 | |||
self.ports = dict(shell=self.shell_port, iopub=self.iopub_port, | ||||
stdin=self.stdin_port, hb=self.hb_port) | ||||
def init_session(self): | ||||
"""create our session object""" | ||||
MinRK
|
r4962 | default_secure(self.config) | ||
MinRK
|
r4015 | self.session = Session(config=self.config, username=u'kernel') | ||
MinRK
|
r3970 | |||
Min RK
|
r4112 | def init_blackhole(self): | ||
"""redirects stdout/stderr to devnull if necessary""" | ||||
MinRK
|
r3970 | if self.no_stdout or self.no_stderr: | ||
Brandon Parsons
|
r6650 | blackhole = open(os.devnull, 'w') | ||
MinRK
|
r3970 | if self.no_stdout: | ||
sys.stdout = sys.__stdout__ = blackhole | ||||
if self.no_stderr: | ||||
sys.stderr = sys.__stderr__ = blackhole | ||||
Min RK
|
r4112 | |||
def init_io(self): | ||||
"""Redirect input streams and set a display hook.""" | ||||
MinRK
|
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) | ||||
MinRK
|
r6790 | def init_signal(self): | ||
signal.signal(signal.SIGINT, signal.SIG_IGN) | ||||
MinRK
|
r3970 | def init_kernel(self): | ||
"""Create the Kernel object itself""" | ||||
kernel_factory = import_item(str(self.kernel_class)) | ||||
self.kernel = kernel_factory(config=self.config, session=self.session, | ||||
shell_socket=self.shell_socket, | ||||
iopub_socket=self.iopub_socket, | ||||
stdin_socket=self.stdin_socket, | ||||
MinRK
|
r3981 | log=self.log | ||
MinRK
|
r3970 | ) | ||
self.kernel.record_ports(self.ports) | ||||
MinRK
|
r5214 | @catch_config_error | ||
MinRK
|
r3970 | def initialize(self, argv=None): | ||
super(KernelApp, self).initialize(argv) | ||||
Min RK
|
r4112 | self.init_blackhole() | ||
MinRK
|
r4958 | self.init_connection_file() | ||
MinRK
|
r3970 | self.init_session() | ||
self.init_poller() | ||||
self.init_sockets() | ||||
MinRK
|
r6885 | self.init_heartbeat() | ||
# writing/displaying connection info must be *after* init_sockets/heartbeat | ||||
self.log_connection_info() | ||||
MinRK
|
r4958 | self.write_connection_file() | ||
MinRK
|
r3970 | self.init_io() | ||
MinRK
|
r6790 | self.init_signal() | ||
MinRK
|
r3970 | self.init_kernel() | ||
MinRK
|
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() | ||||
MinRK
|
r3970 | |||
def start(self): | ||||
if self.poller is not None: | ||||
self.poller.start() | ||||
MinRK
|
r6790 | self.kernel.start() | ||
MinRK
|
r3970 | try: | ||
MinRK
|
r6790 | ioloop.IOLoop.instance().start() | ||
MinRK
|
r3970 | except KeyboardInterrupt: | ||
pass | ||||
MinRK
|
r4021 | |||