Made is_alive a method of KernelManager and MultiKernelManager.

It was a property, but it is better suited as a method now.
Added tests in both the KM and MKM case.

IPython/frontend/terminal/console/interactiveshell.py

@@ -1,466 +1,466 b''
 # -*- coding: utf-8 -*-
 """Frontend of ipython working with python-zmq
 
 Ipython's frontend, is a ipython interface that send request to kernel and proccess the kernel's outputs.
 
 For more details, see the ipython-zmq design
 """
 #-----------------------------------------------------------------------------
 # Copyright (C) 2011 The IPython Development Team
 #
 # Distributed under the terms of the BSD License. The full license is in
 # the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 import bdb
 import signal
 import os
 import sys
 import time
 import subprocess
 from io import BytesIO
 import base64
 
 from Queue import Empty
 
 try:
     from contextlib import nested
 except:
     from IPython.utils.nested_context import nested
 
 from IPython.core.alias import AliasManager, AliasError
 from IPython.core import page
 from IPython.utils.warn import warn, error, fatal
 from IPython.utils import io
 from IPython.utils.traitlets import List, Enum, Any
 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 
 from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.frontend.terminal.console.completer import ZMQCompleter
 
 
 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
     _executing = False
 
     image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
                          config=True, help=
         """
         Handler for image type output.  This is useful, for example,
         when connecting to the kernel in which pylab inline backend is
         activated.  There are four handlers defined.  'PIL': Use
         Python Imaging Library to popup image; 'stream': Use an
         external program to show the image.  Image will be fed into
         the STDIN of the program.  You will need to configure
         `stream_image_handler`; 'tempfile': Use an external program to
         show the image.  Image will be saved in a temporally file and
         the program is called with the temporally file.  You will need
         to configure `tempfile_image_handler`; 'callable': You can set
         any Python callable which is called with the image data.  You
         will need to configure `callable_image_handler`.
         """
     )
 
     stream_image_handler = List(config=True, help=
         """
         Command to invoke an image viewer program when you are using
         'stream' image handler.  This option is a list of string where
         the first element is the command itself and reminders are the
         options for the command.  Raw image data is given as STDIN to
         the program.
         """
     )
 
     tempfile_image_handler = List(config=True, help=
         """
         Command to invoke an image viewer program when you are using
         'tempfile' image handler.  This option is a list of string
         where the first element is the command itself and reminders
         are the options for the command.  You can use {file} and
         {format} in the string to represent the location of the
         generated image file and image format.
         """
     )
 
     callable_image_handler = Any(config=True, help=
         """
         Callable object called via 'callable' image handler with one
         argument, `data`, which is `msg["content"]["data"]` where
         `msg` is the message from iopub channel.  For exmaple, you can
         find base64 encoded PNG data as `data['image/png']`.
         """
     )
 
     mime_preference = List(
         default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
         config=True, allow_none=False, help=
         """
         Preferred object representation MIME type in order.  First
         matched MIME type will be used.
         """
     )
 
     def __init__(self, *args, **kwargs):
         self.km = kwargs.pop('kernel_manager')
         self.session_id = self.km.session.session
         super(ZMQTerminalInteractiveShell, self).__init__(*args, **kwargs)
         
     def init_completer(self):
         """Initialize the completion machinery.
 
         This creates completion machinery that can be used by client code,
         either interactively in-process (typically triggered by the readline
         library), programatically (such as in test suites) or out-of-prcess
         (typically over the network by remote frontends).
         """
         from IPython.core.completerlib import (module_completer,
                                                magic_run_completer, cd_completer)
         
         self.Completer = ZMQCompleter(self, self.km)
         
 
         self.set_hook('complete_command', module_completer, str_key = 'import')
         self.set_hook('complete_command', module_completer, str_key = 'from')
         self.set_hook('complete_command', magic_run_completer, str_key = '%run')
         self.set_hook('complete_command', cd_completer, str_key = '%cd')
 
         # Only configure readline if we truly are using readline.  IPython can
         # do tab-completion over the network, in GUIs, etc, where readline
         # itself may be absent
         if self.has_readline:
             self.set_readline_completer()
     
     def run_cell(self, cell, store_history=True):
         """Run a complete IPython cell.
         
         Parameters
         ----------
         cell : str
           The code (including IPython code such as %magic functions) to run.
         store_history : bool
           If True, the raw and translated cell will be stored in IPython's
           history. For user code calling back into IPython's machinery, this
           should be set to False.
         """
         if (not cell) or cell.isspace():
             return
 
         if cell.strip() == 'exit':
             # explicitly handle 'exit' command
             return self.ask_exit()
 
         self._executing = True
         # flush stale replies, which could have been ignored, due to missed heartbeats
         while self.km.shell_channel.msg_ready():
             self.km.shell_channel.get_msg()
         # shell_channel.execute takes 'hidden', which is the inverse of store_hist
         msg_id = self.km.shell_channel.execute(cell, not store_history)
-        while not self.km.shell_channel.msg_ready() and self.km.is_alive:
+        while not self.km.shell_channel.msg_ready() and self.km.is_alive():
             try:
                 self.handle_stdin_request(timeout=0.05)
             except Empty:
                 # display intermediate print statements, etc.
                 self.handle_iopub()
                 pass
         if self.km.shell_channel.msg_ready():
             self.handle_execute_reply(msg_id)
         self._executing = False
 
     #-----------------
     # message handlers
     #-----------------
 
     def handle_execute_reply(self, msg_id):
         msg = self.km.shell_channel.get_msg()
         if msg["parent_header"].get("msg_id", None) == msg_id:
             
             self.handle_iopub()
             
             content = msg["content"]
             status = content['status']
             
             if status == 'aborted':
                 self.write('Aborted\n')
                 return
             elif status == 'ok':
                 # print execution payloads as well:
                 for item in content["payload"]:
                     text = item.get('text', None)
                     if text:
                         page.page(text)
                
             elif status == 'error':
                 for frame in content["traceback"]:
                     print(frame, file=io.stderr)
             
             self.execution_count = int(content["execution_count"] + 1)
 
 
     def handle_iopub(self):
         """ Method to procces subscribe channel's messages
 
            This method reads a message and processes the content in different
            outputs like stdout, stderr, pyout and status
 
            Arguments:
            sub_msg:  message receive from kernel in the sub socket channel
                      capture by kernel manager.
         """
         while self.km.iopub_channel.msg_ready():
             sub_msg = self.km.iopub_channel.get_msg()
             msg_type = sub_msg['header']['msg_type']
             parent = sub_msg["parent_header"]
             if (not parent) or self.session_id == parent['session']:
                 if msg_type == 'status' :
                     if sub_msg["content"]["execution_state"] == "busy" :
                         pass
 
                 elif msg_type == 'stream' :
                     if sub_msg["content"]["name"] == "stdout":
                         print(sub_msg["content"]["data"], file=io.stdout, end="")
                         io.stdout.flush()
                     elif sub_msg["content"]["name"] == "stderr" :
                         print(sub_msg["content"]["data"], file=io.stderr, end="")
                         io.stderr.flush()
 
                 elif msg_type == 'pyout':
                     self.execution_count = int(sub_msg["content"]["execution_count"])
                     format_dict = sub_msg["content"]["data"]
                     self.handle_rich_data(format_dict)
                     # taken from DisplayHook.__call__:
                     hook = self.displayhook
                     hook.start_displayhook()
                     hook.write_output_prompt()
                     hook.write_format_data(format_dict)
                     hook.log_output(format_dict)
                     hook.finish_displayhook()
 
                 elif msg_type == 'display_data':
                     self.handle_rich_data(sub_msg["content"]["data"])
 
     _imagemime = {
         'image/png': 'png',
         'image/jpeg': 'jpeg',
         'image/svg+xml': 'svg',
     }
 
     def handle_rich_data(self, data):
         for mime in self.mime_preference:
             if mime in data and mime in self._imagemime:
                 self.handle_image(data, mime)
                 return
 
     def handle_image(self, data, mime):
         handler = getattr(
             self, 'handle_image_{0}'.format(self.image_handler), None)
         if handler:
             handler(data, mime)
 
     def handle_image_PIL(self, data, mime):
         if mime not in ('image/png', 'image/jpeg'):
             return
         import PIL.Image
         raw = base64.decodestring(data[mime].encode('ascii'))
         img = PIL.Image.open(BytesIO(raw))
         img.show()
 
     def handle_image_stream(self, data, mime):
         raw = base64.decodestring(data[mime].encode('ascii'))
         imageformat = self._imagemime[mime]
         fmt = dict(format=imageformat)
         args = [s.format(**fmt) for s in self.stream_image_handler]
         with open(os.devnull, 'w') as devnull:
             proc = subprocess.Popen(
                 args, stdin=subprocess.PIPE,
                 stdout=devnull, stderr=devnull)
             proc.communicate(raw)
 
     def handle_image_tempfile(self, data, mime):
         raw = base64.decodestring(data[mime].encode('ascii'))
         imageformat = self._imagemime[mime]
         filename = 'tmp.{0}'.format(imageformat)
         with nested(NamedFileInTemporaryDirectory(filename),
                     open(os.devnull, 'w')) as (f, devnull):
             f.write(raw)
             f.flush()
             fmt = dict(file=f.name, format=imageformat)
             args = [s.format(**fmt) for s in self.tempfile_image_handler]
             subprocess.call(args, stdout=devnull, stderr=devnull)
 
     def handle_image_callable(self, data, mime):
         self.callable_image_handler(data)
 
     def handle_stdin_request(self, timeout=0.1):
         """ Method to capture raw_input
         """
         msg_rep = self.km.stdin_channel.get_msg(timeout=timeout)
         # in case any iopub came while we were waiting:
         self.handle_iopub()
         if self.session_id == msg_rep["parent_header"].get("session"):
             # wrap SIGINT handler
             real_handler = signal.getsignal(signal.SIGINT)
             def double_int(sig,frame):
                 # call real handler (forwards sigint to kernel),
                 # then raise local interrupt, stopping local raw_input
                 real_handler(sig,frame)
                 raise KeyboardInterrupt
             signal.signal(signal.SIGINT, double_int)
             
             try:
                 raw_data = raw_input(msg_rep["content"]["prompt"])
             except EOFError:
                 # turn EOFError into EOF character
                 raw_data = '\x04'
             except KeyboardInterrupt:
                 sys.stdout.write('\n')
                 return
             finally:
                 # restore SIGINT handler
                 signal.signal(signal.SIGINT, real_handler)
             
             # only send stdin reply if there *was not* another request
             # or execution finished while we were reading.
             if not (self.km.stdin_channel.msg_ready() or self.km.shell_channel.msg_ready()):
                 self.km.stdin_channel.input(raw_data)
 
     def mainloop(self, display_banner=False):
         while True:
             try:
                 self.interact(display_banner=display_banner)
                 #self.interact_with_readline()                
                 # XXX for testing of a readline-decoupled repl loop, call
                 # interact_with_readline above
                 break
             except KeyboardInterrupt:
                 # this should not be necessary, but KeyboardInterrupt
                 # handling seems rather unpredictable...
                 self.write("\nKeyboardInterrupt in interact()\n")
     
     def wait_for_kernel(self, timeout=None):
         """method to wait for a kernel to be ready"""
         tic = time.time()
         self.km.hb_channel.unpause()
         while True:
             self.run_cell('1', False)
             if self.km.hb_channel.is_beating():
                 # heart failure was not the reason this returned
                 break
             else:
                 # heart failed
                 if timeout is not None and (time.time() - tic) > timeout:
                     return False
         return True
     
     def interact(self, display_banner=None):
         """Closely emulate the interactive Python console."""
 
         # batch run -> do not interact
         if self.exit_now:
             return
 
         if display_banner is None:
             display_banner = self.display_banner
         
         if isinstance(display_banner, basestring):
             self.show_banner(display_banner)
         elif display_banner:
             self.show_banner()
 
         more = False
         
         # run a non-empty no-op, so that we don't get a prompt until
         # we know the kernel is ready. This keeps the connection
         # message above the first prompt.
         if not self.wait_for_kernel(3):
             error("Kernel did not respond\n")
             return
         
         if self.has_readline:
             self.readline_startup_hook(self.pre_readline)
             hlen_b4_cell = self.readline.get_current_history_length()
         else:
             hlen_b4_cell = 0
         # exit_now is set by a call to %Exit or %Quit, through the
         # ask_exit callback.
 
         while not self.exit_now:
-            if not self.km.is_alive:
+            if not self.km.is_alive():
                 # kernel died, prompt for action or exit
                 action = "restart" if self.km.has_kernel else "wait for restart"
                 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
                 if ans:
                     if self.km.has_kernel:
                         self.km.restart_kernel(True)
                     self.wait_for_kernel(3)
                 else:
                     self.exit_now = True
                 continue
             try:
                 # protect prompt block from KeyboardInterrupt
                 # when sitting on ctrl-C
                 self.hooks.pre_prompt_hook()
                 if more:
                     try:
                         prompt = self.prompt_manager.render('in2')
                     except Exception:
                         self.showtraceback()
                     if self.autoindent:
                         self.rl_do_indent = True
                     
                 else:
                     try:
                         prompt = self.separate_in + self.prompt_manager.render('in')
                     except Exception:
                         self.showtraceback()
                 
                 line = self.raw_input(prompt)
                 if self.exit_now:
                     # quick exit on sys.std[in|out] close
                     break
                 if self.autoindent:
                     self.rl_do_indent = False
                     
             except KeyboardInterrupt:
                 #double-guard against keyboardinterrupts during kbdint handling
                 try:
                     self.write('\nKeyboardInterrupt\n')
                     source_raw = self.input_splitter.source_raw_reset()[1]
                     hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
                     more = False
                 except KeyboardInterrupt:
                     pass
             except EOFError:
                 if self.autoindent:
                     self.rl_do_indent = False
                     if self.has_readline:
                         self.readline_startup_hook(None)
                 self.write('\n')
                 self.exit()
             except bdb.BdbQuit:
                 warn('The Python debugger has exited with a BdbQuit exception.\n'
                      'Because of how pdb handles the stack, it is impossible\n'
                      'for IPython to properly format this particular exception.\n'
                      'IPython will resume normal operation.')
             except:
                 # exceptions here are VERY RARE, but they can be triggered
                 # asynchronously by signal handlers, for example.
                 self.showtraceback()
             else:
                 self.input_splitter.push(line)
                 more = self.input_splitter.push_accepts_more()
                 if (self.SyntaxTB.last_syntax_error and
                     self.autoedit_syntax):
                     self.edit_syntax_error()
                 if not more:
                     source_raw = self.input_splitter.source_raw_reset()[1]
                     hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
                     self.run_cell(source_raw)
                 
 
         # Turn off the exit flag, so the mainloop can be restarted if desired
         self.exit_now = False

IPython/kernel/inprocess/kernelmanager.py

@@ -1,314 +1,313 b''
 """ A kernel manager for in-process kernels. """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2012  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Local imports.
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Any, Instance, Type
 from IPython.kernel.kernelmanagerabc import (
     ShellChannelABC, IOPubChannelABC,
     HBChannelABC, StdInChannelABC,
     KernelManagerABC
 )
 
 from .socket import DummySocket
 
 #-----------------------------------------------------------------------------
 # Channel classes
 #-----------------------------------------------------------------------------
 
 class InProcessChannel(object):
     """Base class for in-process channels."""
 
     def __init__(self, manager):
         super(InProcessChannel, self).__init__()
         self.manager = manager
         self._is_alive = False
 
     #--------------------------------------------------------------------------
     # Channel interface
     #--------------------------------------------------------------------------
 
     def is_alive(self):
         return self._is_alive
 
     def start(self):
         self._is_alive = True
 
     def stop(self):
         self._is_alive = False
 
     def call_handlers(self, msg):
         """ This method is called in the main thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     #--------------------------------------------------------------------------
     # InProcessChannel interface
     #--------------------------------------------------------------------------
 
     def call_handlers_later(self, *args, **kwds):
         """ Call the message handlers later.
 
         The default implementation just calls the handlers immediately, but this
         method exists so that GUI toolkits can defer calling the handlers until
         after the event loop has run, as expected by GUI frontends.
         """
         self.call_handlers(*args, **kwds)
 
     def process_events(self):
         """ Process any pending GUI events.
 
         This method will be never be called from a frontend without an event
         loop (e.g., a terminal frontend).
         """
         raise NotImplementedError
 
 
 class InProcessShellChannel(InProcessChannel):
     """See `IPython.kernel.kernelmanager.ShellChannel` for docstrings."""
 
     # flag for whether execute requests should be allowed to call raw_input
     allow_stdin = True
 
     #--------------------------------------------------------------------------
     # ShellChannel interface
     #--------------------------------------------------------------------------
 
     def execute(self, code, silent=False, store_history=True,
                 user_variables=[], user_expressions={}, allow_stdin=None):
         if allow_stdin is None:
             allow_stdin = self.allow_stdin
         content = dict(code=code, silent=silent, store_history=store_history,
                        user_variables=user_variables,
                        user_expressions=user_expressions,
                        allow_stdin=allow_stdin)
         msg = self.manager.session.msg('execute_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def complete(self, text, line, cursor_pos, block=None):
         content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
         msg = self.manager.session.msg('complete_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def object_info(self, oname, detail_level=0):
         content = dict(oname=oname, detail_level=detail_level)
         msg = self.manager.session.msg('object_info_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def history(self, raw=True, output=False, hist_access_type='range', **kwds):
         content = dict(raw=raw, output=output,
                        hist_access_type=hist_access_type, **kwds)
         msg = self.manager.session.msg('history_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def shutdown(self, restart=False):
         # FIXME: What to do here?
         raise NotImplementedError('Cannot shutdown in-process kernel')
 
     #--------------------------------------------------------------------------
     # Protected interface
     #--------------------------------------------------------------------------
 
     def _dispatch_to_kernel(self, msg):
         """ Send a message to the kernel and handle a reply.
         """
         kernel = self.manager.kernel
         if kernel is None:
             raise RuntimeError('Cannot send request. No kernel exists.')
 
         stream = DummySocket()
         self.manager.session.send(stream, msg)
         msg_parts = stream.recv_multipart()
         kernel.dispatch_shell(stream, msg_parts)
 
         idents, reply_msg = self.manager.session.recv(stream, copy=False)
         self.call_handlers_later(reply_msg)
 
 
 class InProcessIOPubChannel(InProcessChannel):
     """See `IPython.kernel.kernelmanager.IOPubChannel` for docstrings."""
 
     def flush(self, timeout=1.0):
         pass
 
 
 class InProcessStdInChannel(InProcessChannel):
     """See `IPython.kernel.kernelmanager.StdInChannel` for docstrings."""
 
     def input(self, string):
         kernel = self.manager.kernel
         if kernel is None:
             raise RuntimeError('Cannot send input reply. No kernel exists.')
         kernel.raw_input_str = string
 
 
 class InProcessHBChannel(InProcessChannel):
     """See `IPython.kernel.kernelmanager.HBChannel` for docstrings."""
 
     time_to_dead = 3.0
 
     def __init__(self, *args, **kwds):
         super(InProcessHBChannel, self).__init__(*args, **kwds)
         self._pause = True
 
     def pause(self):
         self._pause = True
 
     def unpause(self):
         self._pause = False
 
     def is_beating(self):
         return not self._pause
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class InProcessKernelManager(Configurable):
     """A manager for an in-process kernel.
 
     This class implements the interface of
     `IPython.kernel.kernelmanagerabc.KernelManagerABC` and allows
     (asynchronous) frontends to be used seamlessly with an in-process kernel.
     
     See `IPython.kernel.kernelmanager.KernelManager` for docstrings.
     """
 
     # The Session to use for building messages.
     session = Instance('IPython.kernel.zmq.session.Session')
     def _session_default(self):
         from IPython.kernel.zmq.session import Session
         return Session(config=self.config)
 
     # The kernel process with which the KernelManager is communicating.
     kernel = Instance('IPython.kernel.inprocess.ipkernel.InProcessKernel')
 
     # The classes to use for the various channels.
     shell_channel_class = Type(InProcessShellChannel)
     iopub_channel_class = Type(InProcessIOPubChannel)
     stdin_channel_class = Type(InProcessStdInChannel)
     hb_channel_class = Type(InProcessHBChannel)
 
     # Protected traits.
     _shell_channel = Any
     _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
 
     #--------------------------------------------------------------------------
     # Channel management methods.
     #--------------------------------------------------------------------------
 
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         if shell:
             self.shell_channel.start()
         if iopub:
             self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.shell_channel.allow_stdin = True
         else:
             self.shell_channel.allow_stdin = False
         if hb:
             self.hb_channel.start()
 
     def stop_channels(self):
         if self.shell_channel.is_alive():
             self.shell_channel.stop()
         if self.iopub_channel.is_alive():
             self.iopub_channel.stop()
         if self.stdin_channel.is_alive():
             self.stdin_channel.stop()
         if self.hb_channel.is_alive():
             self.hb_channel.stop()
 
     @property
     def channels_running(self):
         return (self.shell_channel.is_alive() or self.iopub_channel.is_alive() or
                 self.stdin_channel.is_alive() or self.hb_channel.is_alive())
 
     @property
     def shell_channel(self):
         if self._shell_channel is None:
             self._shell_channel = self.shell_channel_class(self)
         return self._shell_channel
 
     @property
     def iopub_channel(self):
         if self._iopub_channel is None:
             self._iopub_channel = self.iopub_channel_class(self)
         return self._iopub_channel
 
     @property
     def stdin_channel(self):
         if self._stdin_channel is None:
             self._stdin_channel = self.stdin_channel_class(self)
         return self._stdin_channel
 
     @property
     def hb_channel(self):
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(self)
         return self._hb_channel
 
     #--------------------------------------------------------------------------
     # Kernel management methods:
     #--------------------------------------------------------------------------
     
     def start_kernel(self, **kwds):
         from IPython.kernel.inprocess.ipkernel import InProcessKernel
         self.kernel = InProcessKernel()
         self.kernel.frontends.append(self)
 
     def shutdown_kernel(self):
         self._kill_kernel()
 
     def restart_kernel(self, now=False, **kwds):
         self.shutdown_kernel()
         self.start_kernel(**kwds)
 
     @property
     def has_kernel(self):
         return self.kernel is not None
 
     def _kill_kernel(self):
         self.kernel.frontends.remove(self)
         self.kernel = None
 
     def interrupt_kernel(self):
         raise NotImplementedError("Cannot interrupt in-process kernel.")
 
     def signal_kernel(self, signum):
         raise NotImplementedError("Cannot signal in-process kernel.")
 
-    @property
     def is_alive(self):
         return True
 
 
 #-----------------------------------------------------------------------------
 # ABC Registration
 #-----------------------------------------------------------------------------
 
 ShellChannelABC.register(InProcessShellChannel)
 IOPubChannelABC.register(InProcessIOPubChannel)
 HBChannelABC.register(InProcessHBChannel)
 StdInChannelABC.register(InProcessStdInChannel)
 KernelManagerABC.register(InProcessKernelManager)

IPython/kernel/kernelmanager.py

@@ -1,1130 +1,1129 b''
 """Base classes to manage the interaction with a running kernel.
 
 TODO
 * Create logger to handle debugging and console messages.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 # Standard library imports
 import atexit
 import errno
 import json
 from subprocess import Popen
 import os
 import signal
 import sys
 from threading import Thread
 import time
 
 # System library imports
 import zmq
 # import ZMQError in top-level namespace, to avoid ugly attribute-error messages
 # during garbage collection of threads at exit:
 from zmq import ZMQError
 from zmq.eventloop import ioloop, zmqstream
 
 # Local imports
 from IPython.config.configurable import Configurable
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 from IPython.utils.traitlets import (
     Any, Instance, Type, Unicode, List, Integer, Bool, CaselessStrEnum
 )
 from IPython.utils.py3compat import str_to_bytes
 from IPython.kernel import (
     write_connection_file,
     make_ipkernel_cmd,
     launch_kernel,
 )
 from .zmq.session import Session
 from .kernelmanagerabc import (
     ShellChannelABC, IOPubChannelABC,
     HBChannelABC, StdInChannelABC,
     KernelManagerABC
 )
 
 
 #-----------------------------------------------------------------------------
 # Constants and exceptions
 #-----------------------------------------------------------------------------
 
 class InvalidPortNumber(Exception):
     pass
 
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 def validate_string_list(lst):
     """Validate that the input is a list of strings.
 
     Raises ValueError if not."""
     if not isinstance(lst, list):
         raise ValueError('input %r must be a list' % lst)
     for x in lst:
         if not isinstance(x, basestring):
             raise ValueError('element %r in list must be a string' % x)
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in dct.iteritems():
         if not isinstance(k, basestring):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, basestring):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 #-----------------------------------------------------------------------------
 # ZMQ Socket Channel classes
 #-----------------------------------------------------------------------------
 
 class ZMQSocketChannel(Thread):
     """The base class for the channels that use ZMQ sockets."""
     context = None
     session = None
     socket = None
     ioloop = None
     stream = None
     _address = None
     _exiting = False
 
     def __init__(self, context, session, address):
         """Create a channel.
 
         Parameters
         ----------
         context : :class:`zmq.Context`
             The ZMQ context to use.
         session : :class:`session.Session`
             The session to use.
         address : zmq url
             Standard (ip, port) tuple that the kernel is listening on.
         """
         super(ZMQSocketChannel, self).__init__()
         self.daemon = True
 
         self.context = context
         self.session = session
         if isinstance(address, tuple):
             if address[1] == 0:
                 message = 'The port number for a channel cannot be 0.'
                 raise InvalidPortNumber(message)
             address = "tcp://%s:%i" % address
         self._address = address
         atexit.register(self._notice_exit)
     
     def _notice_exit(self):
         self._exiting = True
 
     def _run_loop(self):
         """Run my loop, ignoring EINTR events in the poller"""
         while True:
             try:
                 self.ioloop.start()
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     continue
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
 
     def stop(self):
         """Stop the channel's event loop and join its thread.
 
         This calls :method:`Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if
         :method:`self.start` is called again.
         """
         self.join()
 
     @property
     def address(self):
         """Get the channel's address as a zmq url string.
 
         These URLS have the form: 'tcp://127.0.0.1:5555'.
         """
         return self._address
 
     def _queue_send(self, msg):
         """Queue a message to be sent from the IOLoop's thread.
         
         Parameters
         ----------
         msg : message to send
         
         This is threadsafe, as it uses IOLoop.add_callback to give the loop's
         thread control of the action.
         """
         def thread_send():
             self.session.send(self.stream, msg)
         self.ioloop.add_callback(thread_send)
 
     def _handle_recv(self, msg):
         """Callback for stream.on_recv.
 
         Unpacks message, and calls handlers with it.
         """
         ident,smsg = self.session.feed_identities(msg)
         self.call_handlers(self.session.unserialize(smsg))
     
 
 
 class ShellChannel(ZMQSocketChannel):
     """The shell channel for issuing request/replies to the kernel."""
 
     command_queue = None
     # flag for whether execute requests should be allowed to call raw_input:
     allow_stdin = True
 
     def __init__(self, context, session, address):
         super(ShellChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.DEALER)
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
         self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
         try:
             self.socket.close()
         except:
             pass
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self.ioloop.stop()
         super(ShellChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def execute(self, code, silent=False, store_history=True,
                 user_variables=None, user_expressions=None, allow_stdin=None):
         """Execute code in the kernel.
 
         Parameters
         ----------
         code : str
             A string of Python code.
 
         silent : bool, optional (default False)
             If set, the kernel will execute the code as quietly possible, and
             will force store_history to be False.
 
         store_history : bool, optional (default True)
             If set, the kernel will store command history.  This is forced
             to be False if silent is True.
 
         user_variables : list, optional
             A list of variable names to pull from the user's namespace.  They
             will come back as a dict with these names as keys and their
             :func:`repr` as values.
 
         user_expressions : dict, optional
             A dict mapping names to expressions to be evaluated in the user's
             dict. The expression values are returned as strings formatted using
             :func:`repr`.
 
         allow_stdin : bool, optional (default self.allow_stdin)
             Flag for whether the kernel can send stdin requests to frontends.
 
             Some frontends (e.g. the Notebook) do not support stdin requests. 
             If raw_input is called from code executed from such a frontend, a
             StdinNotImplementedError will be raised.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         if user_variables is None:
             user_variables = []
         if user_expressions is None:
             user_expressions = {}
         if allow_stdin is None:
             allow_stdin = self.allow_stdin
         
         
         # Don't waste network traffic if inputs are invalid
         if not isinstance(code, basestring):
             raise ValueError('code %r must be a string' % code)
         validate_string_list(user_variables)
         validate_string_dict(user_expressions)
 
         # Create class for content/msg creation. Related to, but possibly
         # not in Session.
         content = dict(code=code, silent=silent, store_history=store_history,
                        user_variables=user_variables,
                        user_expressions=user_expressions,
                        allow_stdin=allow_stdin,
                        )
         msg = self.session.msg('execute_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def complete(self, text, line, cursor_pos, block=None):
         """Tab complete text in the kernel's namespace.
 
         Parameters
         ----------
         text : str
             The text to complete.
         line : str
             The full line of text that is the surrounding context for the
             text to complete.
         cursor_pos : int
             The position of the cursor in the line where the completion was
             requested.
         block : str, optional
             The full block of code in which the completion is being requested.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
         msg = self.session.msg('complete_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def object_info(self, oname, detail_level=0):
         """Get metadata information about an object in the kernel's namespace.
 
         Parameters
         ----------
         oname : str
             A string specifying the object name.
         detail_level : int, optional
             The level of detail for the introspection (0-2)
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(oname=oname, detail_level=detail_level)
         msg = self.session.msg('object_info_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def history(self, raw=True, output=False, hist_access_type='range', **kwargs):
         """Get entries from the kernel's history list.
 
         Parameters
         ----------
         raw : bool
             If True, return the raw input.
         output : bool
             If True, then return the output as well.
         hist_access_type : str
             'range' (fill in session, start and stop params), 'tail' (fill in n)
              or 'search' (fill in pattern param).
 
         session : int
             For a range request, the session from which to get lines. Session
             numbers are positive integers; negative ones count back from the
             current session.
         start : int
             The first line number of a history range.
         stop : int
             The final (excluded) line number of a history range.
 
         n : int
             The number of lines of history to get for a tail request.
 
         pattern : str
             The glob-syntax pattern for a search request.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(raw=raw, output=output, hist_access_type=hist_access_type,
                                                                     **kwargs)
         msg = self.session.msg('history_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def kernel_info(self):
         """Request kernel info."""
         msg = self.session.msg('kernel_info_request')
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def shutdown(self, restart=False):
         """Request an immediate kernel shutdown.
 
         Upon receipt of the (empty) reply, client code can safely assume that
         the kernel has shut down and it's safe to forcefully terminate it if
         it's still alive.
 
         The kernel will send the reply via a function registered with Python's
         atexit module, ensuring it's truly done as the kernel is done with all
         normal operation.
         """
         # Send quit message to kernel. Once we implement kernel-side setattr,
         # this should probably be done that way, but for now this will do.
         msg = self.session.msg('shutdown_request', {'restart':restart})
         self._queue_send(msg)
         return msg['header']['msg_id']
 
 
 
 class IOPubChannel(ZMQSocketChannel):
     """The iopub channel which listens for messages that the kernel publishes.
 
     This channel is where all output is published to frontends.
     """
 
     def __init__(self, context, session, address):
         super(IOPubChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.SUB)
         self.socket.setsockopt(zmq.SUBSCRIBE,b'')
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
         self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
         try:
             self.socket.close()
         except:
             pass
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self.ioloop.stop()
         super(IOPubChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def flush(self, timeout=1.0):
         """Immediately processes all pending messages on the iopub channel.
 
         Callers should use this method to ensure that :method:`call_handlers`
         has been called for all messages that have been received on the
         0MQ SUB socket of this channel.
 
         This method is thread safe.
 
         Parameters
         ----------
         timeout : float, optional
             The maximum amount of time to spend flushing, in seconds. The
             default is one second.
         """
         # We do the IOLoop callback process twice to ensure that the IOLoop
         # gets to perform at least one full poll.
         stop_time = time.time() + timeout
         for i in xrange(2):
             self._flushed = False
             self.ioloop.add_callback(self._flush)
             while not self._flushed and time.time() < stop_time:
                 time.sleep(0.01)
 
     def _flush(self):
         """Callback for :method:`self.flush`."""
         self.stream.flush()
         self._flushed = True
 
 
 class StdInChannel(ZMQSocketChannel):
     """The stdin channel to handle raw_input requests that the kernel makes."""
 
     msg_queue = None
 
     def __init__(self, context, session, address):
         super(StdInChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.DEALER)
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
         self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
         try:
             self.socket.close()
         except:
             pass
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self.ioloop.stop()
         super(StdInChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def input(self, string):
         """Send a string of raw input to the kernel."""
         content = dict(value=string)
         msg = self.session.msg('input_reply', content)
         self._queue_send(msg)
 
 
 class HBChannel(ZMQSocketChannel):
     """The heartbeat channel which monitors the kernel heartbeat.
 
     Note that the heartbeat channel is paused by default. As long as you start
     this channel, the kernel manager will ensure that it is paused and un-paused
     as appropriate.
     """
 
     time_to_dead = 3.0
     socket = None
     poller = None
     _running = None
     _pause = None
     _beating = None
 
     def __init__(self, context, session, address):
         super(HBChannel, self).__init__(context, session, address)
         self._running = False
         self._pause =True
         self.poller = zmq.Poller()
 
     def _create_socket(self):
         if self.socket is not None:
             # close previous socket, before opening a new one
             self.poller.unregister(self.socket)
             self.socket.close()
         self.socket = self.context.socket(zmq.REQ)
         self.socket.setsockopt(zmq.LINGER, 0)
         self.socket.connect(self.address)
         
         self.poller.register(self.socket, zmq.POLLIN)
     
     def _poll(self, start_time):
         """poll for heartbeat replies until we reach self.time_to_dead.
         
         Ignores interrupts, and returns the result of poll(), which
         will be an empty list if no messages arrived before the timeout,
         or the event tuple if there is a message to receive.
         """
         
         until_dead = self.time_to_dead - (time.time() - start_time)
         # ensure poll at least once
         until_dead = max(until_dead, 1e-3)
         events = []
         while True:
             try:
                 events = self.poller.poll(1000 * until_dead)
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     # ignore interrupts during heartbeat
                     # this may never actually happen
                     until_dead = self.time_to_dead - (time.time() - start_time)
                     until_dead = max(until_dead, 1e-3)
                     pass
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
         return events
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self._create_socket()
         self._running = True
         self._beating = True
         
         while self._running:
             if self._pause:
                 # just sleep, and skip the rest of the loop
                 time.sleep(self.time_to_dead)
                 continue
             
             since_last_heartbeat = 0.0
             # io.rprint('Ping from HB channel') # dbg
             # no need to catch EFSM here, because the previous event was
             # either a recv or connect, which cannot be followed by EFSM
             self.socket.send(b'ping')
             request_time = time.time()
             ready = self._poll(request_time)
             if ready:
                 self._beating = True
                 # the poll above guarantees we have something to recv
                 self.socket.recv()
                 # sleep the remainder of the cycle
                 remainder = self.time_to_dead - (time.time() - request_time)
                 if remainder > 0:
                     time.sleep(remainder)
                 continue
             else:
                 # nothing was received within the time limit, signal heart failure
                 self._beating = False
                 since_last_heartbeat = time.time() - request_time
                 self.call_handlers(since_last_heartbeat)
                 # and close/reopen the socket, because the REQ/REP cycle has been broken
                 self._create_socket()
                 continue
         try:
             self.socket.close()
         except:
             pass
 
     def pause(self):
         """Pause the heartbeat."""
         self._pause = True
 
     def unpause(self):
         """Unpause the heartbeat."""
         self._pause = False
 
     def is_beating(self):
         """Is the heartbeat running and responsive (and not paused)."""
         if self.is_alive() and not self._pause and self._beating:
             return True
         else:
             return False
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self._running = False
         super(HBChannel, self).stop()
 
     def call_handlers(self, since_last_heartbeat):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application level
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class KernelManager(Configurable):
     """Manages a single kernel on this host along with its channels.
 
     There are four channels associated with each kernel:
 
     * shell: for request/reply calls to the kernel.
     * iopub: for the kernel to publish results to frontends.
     * hb: for monitoring the kernel's heartbeat.
     * stdin: for frontends to reply to raw_input calls in the kernel.
 
     The usage of the channels that this class manages is optional. It is
     entirely possible to connect to the kernels directly using ZeroMQ
     sockets. These channels are useful primarily for talking to a kernel
     whose :class:`KernelManager` is in the same process.
 
     This version manages kernels started using Popen.
     """
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context)
     def _context_default(self):
         return zmq.Context.instance()
 
     # The Session to use for communication with the kernel.
     session = Instance(Session)
     def _session_default(self):
         return Session(config=self.config)
 
     # The kernel process with which the KernelManager is communicating.
     # generally a Popen instance
     kernel = Any() 
     
     kernel_cmd = List(Unicode, config=True,
         help="""The Popen Command to launch the kernel.
         Override this if you have a custom 
         """
     )
     def _kernel_cmd_changed(self, name, old, new):
         self.ipython_kernel = False
 
     ipython_kernel = Bool(True)
     
 
     # The addresses for the communication channels.
     connection_file = Unicode('')
     
     transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
 
     ip = Unicode(LOCALHOST, config=True,
         help="""Set the kernel\'s IP address [default localhost].
         If the IP address is something other than localhost, then
         Consoles on other machines will be able to connect
         to the Kernel, so be careful!"""
     )
     def _ip_default(self):
         if self.transport == 'ipc':
             if self.connection_file:
                 return os.path.splitext(self.connection_file)[0] + '-ipc'
             else:
                 return 'kernel-ipc'
         else:
             return LOCALHOST
     def _ip_changed(self, name, old, new):
         if new == '*':
             self.ip = '0.0.0.0'
     shell_port = Integer(0)
     iopub_port = Integer(0)
     stdin_port = Integer(0)
     hb_port = Integer(0)
 
     # The classes to use for the various channels.
     shell_channel_class = Type(ShellChannel)
     iopub_channel_class = Type(IOPubChannel)
     stdin_channel_class = Type(StdInChannel)
     hb_channel_class = Type(HBChannel)
 
     # Protected traits.
     _launch_args = Any
     _shell_channel = Any
     _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
     _connection_file_written=Bool(False)
 
     def __del__(self):
         self.cleanup_connection_file()
 
     #--------------------------------------------------------------------------
     # Channel management methods:
     #--------------------------------------------------------------------------
 
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         """Starts the channels for this kernel.
 
         This will create the channels if they do not exist and then start
         them (their activity runs in a thread). If port numbers of 0 are
         being used (random ports) then you must first call 
         :method:`start_kernel`. If the channels have been stopped and you
         call this, :class:`RuntimeError` will be raised.
         """
         if shell:
             self.shell_channel.start()
         if iopub:
             self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.shell_channel.allow_stdin = True
         else:
             self.shell_channel.allow_stdin = False
         if hb:
             self.hb_channel.start()
 
     def stop_channels(self):
         """Stops all the running channels for this kernel.
 
         This stops their event loops and joins their threads.
         """
         if self.shell_channel.is_alive():
             self.shell_channel.stop()
         if self.iopub_channel.is_alive():
             self.iopub_channel.stop()
         if self.stdin_channel.is_alive():
             self.stdin_channel.stop()
         if self.hb_channel.is_alive():
             self.hb_channel.stop()
 
     @property
     def channels_running(self):
         """Are any of the channels created and running?"""
         return (self.shell_channel.is_alive() or self.iopub_channel.is_alive() or
                 self.stdin_channel.is_alive() or self.hb_channel.is_alive())
 
     def _make_url(self, port):
         """Make a zmq url with a port.
 
         There are two cases that this handles:
 
         * tcp: tcp://ip:port
         * ipc: ipc://ip-port
         """
         if self.transport == 'tcp':
             return "tcp://%s:%i" % (self.ip, port)
         else:
             return "%s://%s-%s" % (self.transport, self.ip, port)
 
     @property
     def shell_channel(self):
         """Get the shell channel object for this kernel."""
         if self._shell_channel is None:
             self._shell_channel = self.shell_channel_class(
                 self.context, self.session, self._make_url(self.shell_port)
             )
         return self._shell_channel
 
     @property
     def iopub_channel(self):
         """Get the iopub channel object for this kernel."""
         if self._iopub_channel is None:
             self._iopub_channel = self.iopub_channel_class(
                 self.context, self.session, self._make_url(self.iopub_port)
             )
         return self._iopub_channel
 
     @property
     def stdin_channel(self):
         """Get the stdin channel object for this kernel."""
         if self._stdin_channel is None:
             self._stdin_channel = self.stdin_channel_class(
                 self.context, self.session, self._make_url(self.stdin_port)
             )
         return self._stdin_channel
 
     @property
     def hb_channel(self):
         """Get the hb channel object for this kernel."""
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(
                 self.context, self.session, self._make_url(self.hb_port)
             )
         return self._hb_channel
 
     #--------------------------------------------------------------------------
     # Connection and ipc file management
     #--------------------------------------------------------------------------
     
     def cleanup_connection_file(self):
         """Cleanup connection file *if we wrote it*
         
         Will not raise if the connection file was already removed somehow.
         """
         if self._connection_file_written:
             # cleanup connection files on full shutdown of kernel we started
             self._connection_file_written = False
             try:
                 os.remove(self.connection_file)
             except (IOError, OSError, AttributeError):
                 pass
     
     def cleanup_ipc_files(self):
         """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
 
     def load_connection_file(self):
         """Load connection info from JSON dict in self.connection_file."""
         with open(self.connection_file) as f:
             cfg = json.loads(f.read())
 
         from pprint import pprint
         pprint(cfg)
         self.transport = cfg.get('transport', 'tcp')
         self.ip = cfg['ip']
         self.shell_port = cfg['shell_port']
         self.stdin_port = cfg['stdin_port']
         self.iopub_port = cfg['iopub_port']
         self.hb_port = cfg['hb_port']
         self.session.key = str_to_bytes(cfg['key'])
     
     def write_connection_file(self):
         """Write connection info to JSON dict in self.connection_file."""
         if self._connection_file_written:
             return
         self.connection_file,cfg = write_connection_file(self.connection_file,
             transport=self.transport, ip=self.ip, key=self.session.key,
             stdin_port=self.stdin_port, iopub_port=self.iopub_port,
             shell_port=self.shell_port, hb_port=self.hb_port)
         # write_connection_file also sets default ports:
         self.shell_port = cfg['shell_port']
         self.stdin_port = cfg['stdin_port']
         self.iopub_port = cfg['iopub_port']
         self.hb_port = cfg['hb_port']
         
         self._connection_file_written = True
 
     #--------------------------------------------------------------------------
     # Kernel management
     #--------------------------------------------------------------------------
     
     def format_kernel_cmd(self, **kw):
         """format templated args (e.g. {connection_file})"""
         if self.kernel_cmd:
             cmd = self.kernel_cmd
         else:
             cmd = make_ipkernel_cmd(
                 'from IPython.kernel.zmq.kernelapp import main; main()',
                 **kw
             )
         ns = dict(connection_file=self.connection_file)
         ns.update(self._launch_args)
         return [ c.format(**ns) for c in cmd ]
     
     def _launch_kernel(self, kernel_cmd, **kw):
         """actually launch the kernel
         
         override in a subclass to launch kernel subprocesses differently
         """
         return launch_kernel(kernel_cmd, **kw)
     
     def start_kernel(self, **kw):
         """Starts a kernel on this host in a separate process.
 
         If random ports (port=0) are being used, this method must be called
         before the channels are created.
 
         Parameters:
         -----------
         **kw : optional
              keyword arguments that are passed down to build the kernel_cmd
              and launching the kernel (e.g. Popen kwargs).
         """
         if self.transport == 'tcp' and self.ip not in LOCAL_IPS:
             raise RuntimeError("Can only launch a kernel on a local interface. "
                                "Make sure that the '*_address' attributes are "
                                "configured properly. "
                                "Currently valid addresses are: %s"%LOCAL_IPS
                                )
         
         # write connection file / get default ports
         self.write_connection_file()
 
         # save kwargs for use in restart
         self._launch_args = kw.copy()
         # build the Popen cmd
         kernel_cmd = self.format_kernel_cmd(**kw)
         # launch the kernel subprocess
         self.kernel = self._launch_kernel(kernel_cmd,
                                     ipython_kernel=self.ipython_kernel,
                                     **kw)
 
     def shutdown_kernel(self, now=False, restart=False):
         """Attempts to the stop the kernel process cleanly. 
 
         This attempts to shutdown the kernels cleanly by:
 
         1. Sending it a shutdown message over the shell channel.
         2. If that fails, the kernel is shutdown forcibly by sending it
            a signal.
 
         Parameters:
         -----------
         now : bool
             Should the kernel be forcible killed *now*. This skips the
             first, nice shutdown attempt.
         restart: bool
             Will this kernel be restarted after it is shutdown. When this
             is True, connection files will not be cleaned up.
         """
         # FIXME: Shutdown does not work on Windows due to ZMQ errors!
         if sys.platform == 'win32':
             self._kill_kernel()
             return
 
         # Pause the heart beat channel if it exists.
         if self._hb_channel is not None:
             self._hb_channel.pause()
 
         if now:
             if self.has_kernel:
                 self._kill_kernel()
         else:
             # Don't send any additional kernel kill messages immediately, to give
             # the kernel a chance to properly execute shutdown actions. Wait for at
             # most 1s, checking every 0.1s.
             self.shell_channel.shutdown(restart=restart)
             for i in range(10):
-                if self.is_alive:
+                if self.is_alive():
                     time.sleep(0.1)
                 else:
                     break
             else:
                 # OK, we've waited long enough.
                 if self.has_kernel:
                     self._kill_kernel()
 
         if not restart:
             self.cleanup_connection_file()
             self.cleanup_ipc_files()
         else:
             self.cleanup_ipc_files()
 
     def restart_kernel(self, now=False, **kw):
         """Restarts a kernel with the arguments that were used to launch it.
 
         If the old kernel was launched with random ports, the same ports will be
         used for the new kernel. The same connection file is used again.
 
         Parameters
         ----------
         now : bool, optional
             If True, the kernel is forcefully restarted *immediately*, without
             having a chance to do any cleanup action.  Otherwise the kernel is
             given 1s to clean up before a forceful restart is issued.
 
             In all cases the kernel is restarted, the only difference is whether
             it is given a chance to perform a clean shutdown or not.
 
         **kw : optional
             Any options specified here will overwrite those used to launch the
             kernel.
         """
         if self._launch_args is None:
             raise RuntimeError("Cannot restart the kernel. "
                                "No previous call to 'start_kernel'.")
         else:
             # Stop currently running kernel.
             self.shutdown_kernel(now=now, restart=True)
 
             # Start new kernel.
             self._launch_args.update(kw)
             self.start_kernel(**self._launch_args)
 
             # FIXME: Messages get dropped in Windows due to probable ZMQ bug
             # unless there is some delay here.
             if sys.platform == 'win32':
                 time.sleep(0.2)
 
     @property
     def has_kernel(self):
         """Has a kernel been started that we are managing."""
         return self.kernel is not None
 
     def _kill_kernel(self):
         """Kill the running kernel.
 
         This is a private method, callers should use shutdown_kernel(now=True).
         """
         if self.has_kernel:
             # Pause the heart beat channel if it exists.
             if self._hb_channel is not None:
                 self._hb_channel.pause()
 
             # Signal the kernel to terminate (sends SIGKILL on Unix and calls
             # TerminateProcess() on Win32).
             try:
                 self.kernel.kill()
             except OSError as e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if sys.platform == 'win32':
                     if e.winerror != 5:
                         raise
                 # On Unix, we may get an ESRCH error if the process has already
                 # terminated. Ignore it.
                 else:
                     from errno import ESRCH
                     if e.errno != ESRCH:
                         raise
 
             # Block until the kernel terminates.
             self.kernel.wait()
             self.kernel = None
         else:
             raise RuntimeError("Cannot kill kernel. No kernel is running!")
 
     def interrupt_kernel(self):
         """Interrupts the kernel by sending it a signal.
 
         Unlike ``signal_kernel``, this operation is well supported on all
         platforms.
         """
         if self.has_kernel:
             if sys.platform == 'win32':
                 from .zmq.parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(self.kernel.win32_interrupt_event)
             else:
                 self.kernel.send_signal(signal.SIGINT)
         else:
             raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
 
     def signal_kernel(self, signum):
         """Sends a signal to the kernel.
 
         Note that since only SIGTERM is supported on Windows, this function is
         only useful on Unix systems.
         """
         if self.has_kernel:
             self.kernel.send_signal(signum)
         else:
             raise RuntimeError("Cannot signal kernel. No kernel is running!")
 
-    @property
     def is_alive(self):
         """Is the kernel process still running?"""
         if self.has_kernel:
             if self.kernel.poll() is None:
                 return True
             else:
                 return False
         elif self._hb_channel is not None:
             # We didn't start the kernel with this KernelManager so we
             # use the heartbeat.
             return self._hb_channel.is_beating()
         else:
             # no heartbeat and not local, we can't tell if it's running,
             # so naively return True
             return True
 
 
 #-----------------------------------------------------------------------------
 # ABC Registration
 #-----------------------------------------------------------------------------
 
 ShellChannelABC.register(ShellChannel)
 IOPubChannelABC.register(IOPubChannel)
 HBChannelABC.register(HBChannel)
 StdInChannelABC.register(StdInChannel)
 KernelManagerABC.register(KernelManager)
 

IPython/kernel/kernelmanagerabc.py

@@ -1,226 +1,226 b''
 """Abstract base classes for kernel manager and channels."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 import abc
 
 #-----------------------------------------------------------------------------
 # Channels
 #-----------------------------------------------------------------------------
 
 
 class ChannelABC(object):
     """A base class for all channel ABCs."""
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
     def start(self):
         pass
 
     @abc.abstractmethod
     def stop(self):
         pass
 
     @abc.abstractmethod
     def is_alive(self):
         pass
 
 
 class ShellChannelABC(ChannelABC):
     """ShellChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
     `IPython.kernel.kernelmanager.ShellChannel`
     """
 
     @abc.abstractproperty
     def allow_stdin(self):
         pass
 
     @abc.abstractmethod
     def execute(self, code, silent=False, store_history=True,
                 user_variables=None, user_expressions=None, allow_stdin=None):
         pass
 
     @abc.abstractmethod
     def complete(self, text, line, cursor_pos, block=None):
         pass
 
     @abc.abstractmethod
     def object_info(self, oname, detail_level=0):
         pass
 
     @abc.abstractmethod
     def history(self, raw=True, output=False, hist_access_type='range', **kwargs):
         pass
 
     @abc.abstractmethod
     def kernel_info(self):
         pass
 
     @abc.abstractmethod
     def shutdown(self, restart=False):
         pass
 
 
 class IOPubChannelABC(ChannelABC):
     """IOPubChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
     `IPython.kernel.kernelmanager.IOPubChannel`
     """
 
     @abc.abstractmethod
     def flush(self, timeout=1.0):
         pass
 
 
 class StdInChannelABC(ChannelABC):
     """StdInChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
     `IPython.kernel.kernelmanager.StdInChannel`
     """
 
     @abc.abstractmethod
     def input(self, string):
         pass
 
 
 class HBChannelABC(ChannelABC):
     """HBChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
     `IPython.kernel.kernelmanager.HBChannel`
     """
 
     @abc.abstractproperty
     def time_to_dead(self):
         pass
 
     @abc.abstractmethod
     def pause(self):
         pass
 
     @abc.abstractmethod
     def unpause(self):
         pass
 
     @abc.abstractmethod
     def is_beating(self):
         pass
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class KernelManagerABC(object):
     """KernelManager ABC.
 
     The docstrings for this class can be found in the base implementation:
 
     `IPython.kernel.kernelmanager.KernelManager`
     """
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractproperty
     def kernel(self):
         pass
 
     @abc.abstractproperty
     def shell_channel_class(self):
         pass
 
     @abc.abstractproperty
     def iopub_channel_class(self):
         pass
 
     @abc.abstractproperty
     def hb_channel_class(self):
         pass
 
     @abc.abstractproperty
     def stdin_channel_class(self):
         pass
 
     #--------------------------------------------------------------------------
     # Channel management methods
     #--------------------------------------------------------------------------
 
     @abc.abstractmethod
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         pass
 
     @abc.abstractmethod
     def stop_channels(self):
         pass
 
     @abc.abstractproperty
     def channels_running(self):
         pass
 
     @abc.abstractproperty
     def shell_channel(self):
         pass
 
     @abc.abstractproperty
     def iopub_channel(self):
         pass
 
     @abc.abstractproperty
     def stdin_channel(self):
         pass
 
     @abc.abstractproperty
     def hb_channel(self):
         pass
 
     #--------------------------------------------------------------------------
     # Kernel management
     #--------------------------------------------------------------------------
 
     @abc.abstractmethod
     def start_kernel(self, **kw):
         pass
 
     @abc.abstractmethod
     def shutdown_kernel(self, now=False, restart=False):
         pass
 
     @abc.abstractmethod
     def restart_kernel(self, now=False, **kw):
         pass
 
     @abc.abstractproperty
     def has_kernel(self):
         pass
 
     @abc.abstractmethod
     def interrupt_kernel(self):
         pass
 
     @abc.abstractmethod
     def signal_kernel(self, signum):
         pass
 
-    @abc.abstractproperty
+    @abc.abstractmethod
     def is_alive(self):
         pass
 

IPython/kernel/multikernelmanager.py

@@ -1,259 +1,272 b''
 """A kernel manager for multiple kernels
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import os
 import uuid
 
 import zmq
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import (
     Instance, Dict, Unicode, Any, DottedObjectName,
 )
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class DuplicateKernelError(Exception):
     pass
 
 
 class MultiKernelManager(LoggingConfigurable):
     """A class for managing multiple kernels."""
     
     kernel_manager_class = DottedObjectName(
         "IPython.kernel.blockingkernelmanager.BlockingKernelManager", config=True,
         help="""The kernel manager class.  This is configurable to allow
         subclassing of the KernelManager for customized behavior.
         """
     )
     def _kernel_manager_class_changed(self, name, old, new):
         self.kernel_manager_factory = import_item(new)
     
     kernel_manager_factory = Any(help="this is kernel_manager_class after import")
     def _kernel_manager_factory_default(self):
         return import_item(self.kernel_manager_class)
     
     context = Instance('zmq.Context')
     def _context_default(self):
         return zmq.Context.instance()
     
     connection_dir = Unicode('')
 
     _kernels = Dict()
 
     def list_kernel_ids(self):
         """Return a list of the kernel ids of the active kernels."""
         # Create a copy so we can iterate over kernels in operations
         # that delete keys.
         return list(self._kernels.keys())
 
     def __len__(self):
         """Return the number of running kernels."""
         return len(self.list_kernel_ids())
 
     def __contains__(self, kernel_id):
         return kernel_id in self._kernels
 
     def start_kernel(self, **kwargs):
         """Start a new kernel.
 
         The caller can pick a kernel_id by passing one in as a keyword arg,
         otherwise one will be picked using a uuid.
 
         To silence the kernel's stdout/stderr, call this using::
 
             km.start_kernel(stdout=PIPE, stderr=PIPE)
 
         """
         kernel_id = kwargs.pop('kernel_id', unicode(uuid.uuid4()))
         if kernel_id in self:
             raise DuplicateKernelError('Kernel already exists: %s' % kernel_id)
         # kernel_manager_factory is the constructor for the KernelManager
         # subclass we are using. It can be configured as any Configurable,
         # including things like its transport and ip.
         km = self.kernel_manager_factory(connection_file=os.path.join(
                     self.connection_dir, "kernel-%s.json" % kernel_id),
                     config=self.config,
         )
         km.start_kernel(**kwargs)
         # start just the shell channel, needed for graceful restart
         km.start_channels(shell=True, iopub=False, stdin=False, hb=False)
         self._kernels[kernel_id] = km
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         """Shutdown a kernel by its kernel uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to shutdown.
         now : bool
             Should the kernel be shutdown forcibly using a signal.
         """
         k = self.get_kernel(kernel_id)
         k.shutdown_kernel(now=now)
         k.shell_channel.stop()
         del self._kernels[kernel_id]
 
     def shutdown_all(self, now=False):
         """Shutdown all kernels."""
         for kid in self.list_kernel_ids():
             self.shutdown_kernel(kid, now=now)
 
     def interrupt_kernel(self, kernel_id):
         """Interrupt (SIGINT) the kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         return self.get_kernel(kernel_id).interrupt_kernel()
 
     def signal_kernel(self, kernel_id, signum):
         """Sends a signal to the kernel by its uuid.
 
         Note that since only SIGTERM is supported on Windows, this function
         is only useful on Unix systems.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to signal.
         """
         return self.get_kernel(kernel_id).signal_kernel(signum)
 
     def restart_kernel(self, kernel_id):
         """Restart a kernel by its uuid, keeping the same ports.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         return self.get_kernel(kernel_id).restart_kernel()
 
+    def is_alive(self, kernel_id):
+        """Is the kernel alive.
+
+        This calls KernelManager.is_alive() which calls Popen.poll on the
+        actual kernel subprocess.
+
+        Parameters
+        ==========
+        kernel_id : uuid
+            The id of the kernel.
+        """
+        return self.get_kernel(kernel_id).is_alive()
+
     def get_kernel(self, kernel_id):
         """Get the single KernelManager object for a kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
         """
         km = self._kernels.get(kernel_id)
         if km is not None:
             return km
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_connection_info(self, kernel_id):
         """Return a dictionary of connection data for a kernel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         connection_dict : dict
             A dict of the information needed to connect to a kernel.
             This includes the ip address and the integer port
             numbers of the different channels (stdin_port, iopub_port,
             shell_port, hb_port).
         """
         km = self.get_kernel(kernel_id)
         return dict(transport=km.transport,
                     ip=km.ip,
                     shell_port=km.shell_port,
                     iopub_port=km.iopub_port,
                     stdin_port=km.stdin_port,
                     hb_port=km.hb_port,
         )  
 
     def _make_url(self, transport, ip, port):
         """Make a ZeroMQ URL for a given transport, ip and port."""
         if transport == 'tcp':
             return "tcp://%s:%i" % (ip, port)
         else:
             return "%s://%s-%s" % (transport, ip, port)
 
     def _create_connected_stream(self, kernel_id, socket_type, channel):
         """Create a connected ZMQStream for a kernel."""
         cinfo = self.get_connection_info(kernel_id)
         url = self._make_url(cinfo['transport'], cinfo['ip'],
                 cinfo['%s_port' % channel]
         )
         sock = self.context.socket(socket_type)
         self.log.info("Connecting to: %s" % url)
         sock.connect(url)
         return ZMQStream(sock)
 
     def create_iopub_stream(self, kernel_id):
         """Return a ZMQStream object connected to the iopub channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         stream : ZMQStream
         """
         iopub_stream = self._create_connected_stream(kernel_id, zmq.SUB, 'iopub')
         iopub_stream.socket.setsockopt(zmq.SUBSCRIBE, b'')
         return iopub_stream
 
     def create_shell_stream(self, kernel_id):
         """Return a ZMQStream object connected to the shell channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         stream : ZMQStream
         """
         shell_stream = self._create_connected_stream(kernel_id, zmq.DEALER, 'shell')
         return shell_stream
 
     def create_hb_stream(self, kernel_id):
         """Return a ZMQStream object connected to the hb channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         stream : ZMQStream
         """
         hb_stream = self._create_connected_stream(kernel_id, zmq.REQ, 'hb')
         return hb_stream
 

IPython/kernel/tests/test_kernelmanager.py

@@ -1,48 +1,50 b''
 """Tests for the notebook kernel and session manager"""
 
 from subprocess import PIPE
 import time
 from unittest import TestCase
 
 from IPython.testing import decorators as dec
 
 from IPython.config.loader import Config
 from IPython.kernel.kernelmanager import KernelManager
 
 class TestKernelManager(TestCase):
 
     def _get_tcp_km(self):
         return KernelManager()
 
     def _get_ipc_km(self):
         c = Config()
         c.KernelManager.transport = 'ipc'
         c.KernelManager.ip = 'test'
         km = KernelManager(config=c)
         return km
 
     def _run_lifecycle(self, km):
         km.start_kernel(stdout=PIPE, stderr=PIPE)
+        self.assertTrue(km.is_alive())
         km.start_channels(shell=True, iopub=False, stdin=False, hb=False)
         km.restart_kernel()
+        self.assertTrue(km.is_alive())
         # We need a delay here to give the restarting kernel a chance to
         # restart. Otherwise, the interrupt will kill it, causing the test
         # suite to hang. The reason it *hangs* is that the shutdown
         # message for the restart sometimes hasn't been sent to the kernel.
         # Because linger is oo on the shell channel, the context can't
         # close until the message is sent to the kernel, which is not dead.
         time.sleep(1.0)
         km.interrupt_kernel()
         self.assertTrue(isinstance(km, KernelManager))
         km.shutdown_kernel()
         km.shell_channel.stop()
 
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
 
     @dec.skip_win32
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
 

IPython/kernel/tests/test_multikernelmanager.py

@@ -1,81 +1,83 b''
 """Tests for the notebook kernel and session manager."""
 
 from subprocess import PIPE
 import time
 from unittest import TestCase
 
 from IPython.testing import decorators as dec
 
 from IPython.config.loader import Config
 from IPython.utils.localinterfaces import LOCALHOST
 from IPython.kernel.kernelmanager import KernelManager
 from IPython.kernel.multikernelmanager import MultiKernelManager
 
 class TestKernelManager(TestCase):
 
     def _get_tcp_km(self):
         return MultiKernelManager()
 
     def _get_ipc_km(self):
         c = Config()
         c.KernelManager.transport = 'ipc'
         c.KernelManager.ip = 'test'
         km = MultiKernelManager(config=c)
         return km
 
     def _run_lifecycle(self, km):
         kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
+        self.assertTrue(km.is_alive(kid))
         self.assertTrue(kid in km)
         self.assertTrue(kid in km.list_kernel_ids())
         self.assertEqual(len(km),1)
         km.restart_kernel(kid)
+        self.assertTrue(km.is_alive(kid))
         self.assertTrue(kid in km.list_kernel_ids())
         # We need a delay here to give the restarting kernel a chance to
         # restart. Otherwise, the interrupt will kill it, causing the test
         # suite to hang. The reason it *hangs* is that the shutdown
         # message for the restart sometimes hasn't been sent to the kernel.
         # Because linger is oo on the shell channel, the context can't
         # close until the message is sent to the kernel, which is not dead.
         time.sleep(1.0)
         km.interrupt_kernel(kid)
         k = km.get_kernel(kid)
         self.assertTrue(isinstance(k, KernelManager))
         km.shutdown_kernel(kid)
         self.assertTrue(not kid in km)
 
     def _run_cinfo(self, km, transport, ip):
         kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
         k = km.get_kernel(kid)
         cinfo = km.get_connection_info(kid)
         self.assertEqual(transport, cinfo['transport'])
         self.assertEqual(ip, cinfo['ip'])
         self.assertTrue('stdin_port' in cinfo)
         self.assertTrue('iopub_port' in cinfo)
         stream = km.create_iopub_stream(kid)
         stream.close()
         self.assertTrue('shell_port' in cinfo)
         stream = km.create_shell_stream(kid)
         stream.close()
         self.assertTrue('hb_port' in cinfo)
         stream = km.create_hb_stream(kid)
         stream.close()
         km.shutdown_kernel(kid)
 
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
     
     def test_tcp_cinfo(self):
         km = self._get_tcp_km()
         self._run_cinfo(km, 'tcp', LOCALHOST)
 
     @dec.skip_win32
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
     
     @dec.skip_win32
     def test_ipc_cinfo(self):
         km = self._get_ipc_km()
         self._run_cinfo(km, 'ipc', 'test')