update terminal console to new KM / KC APIs

IPython/frontend/consoleapp.py

@@ -34,7 +34,7 import uuid
 from IPython.config.application import boolean_flag
 from IPython.config.configurable import Configurable
 from IPython.core.profiledir import ProfileDir
-from IPython.kernel.blocking import BlockingKernelManager
+from IPython.kernel.blocking import BlockingKernelClient
 from IPython.kernel import KernelManager
 from IPython.kernel import tunnel_to_kernel, find_connection_file, swallow_argv
 from IPython.utils.path import filefind
@@ -144,7 +144,8 class IPythonConsoleApp(Configurable):
     classes = classes
     flags = Dict(flags)
     aliases = Dict(aliases)
-    kernel_manager_class = BlockingKernelManager
+    kernel_manager_class = KernelManager
+    kernel_client_class = BlockingKernelClient
 
     kernel_argv = List(Unicode)
     # frontend flags&aliases to be stripped when building kernel_argv
@@ -328,6 +329,9 class IPythonConsoleApp(Configurable):
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
+        if self.existing:
+            self.kernel_manager = None
+            return
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
@@ -346,8 +350,29 class IPythonConsoleApp(Configurable):
         elif self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()
+
+        # in case KM defaults / ssh writing changes things:
+        km = self.kernel_manager
+        self.shell_port=km.shell_port
+        self.iopub_port=km.iopub_port
+        self.stdin_port=km.stdin_port
+        self.hb_port=km.hb_port
+        self.connection_file = km.connection_file
+
         atexit.register(self.kernel_manager.cleanup_connection_file)
-        self.kernel_manager.start_channels()
+
+    def init_kernel_client(self):
+        self.kernel_client = self.kernel_client_class(
+                                shell_port=self.shell_port,
+                                iopub_port=self.iopub_port,
+                                stdin_port=self.stdin_port,
+                                hb_port=self.hb_port,
+                                connection_file=self.connection_file,
+                                config=self.config,
+        )
+
+        self.kernel_client.start_channels()
+
 
 
     def initialize(self, argv=None):
@@ -359,4 +384,5 class IPythonConsoleApp(Configurable):
         default_secure(self.config)
         self.init_ssh()
         self.init_kernel_manager()
+        self.init_kernel_client()
 

IPython/frontend/terminal/console/app.py

@@ -114,7 +114,10 class ZMQTerminalIPythonApp(TerminalIPythonApp, IPythonConsoleApp):
         signal.signal(signal.SIGINT, self.handle_sigint)
         self.shell = ZMQTerminalInteractiveShell.instance(config=self.config,
                         display_banner=False, profile_dir=self.profile_dir,
-                        ipython_dir=self.ipython_dir, kernel_manager=self.kernel_manager)
+                        ipython_dir=self.ipython_dir,
+                        kernel_manager=self.kernel_manager,
+                        kernel_client=self.kernel_client,
+        )
 
     def init_gui_pylab(self):
         # no-op, because we don't want to import matplotlib in the frontend.

IPython/frontend/terminal/console/completer.py

@@ -9,9 +9,9 class ZMQCompleter(object):
     state=0,1,2,... When state=0 it should compute ALL the completion matches,
     and then return them for each value of state."""
     
-    def __init__(self, shell, km):
+    def __init__(self, shell, client):
         self.shell = shell
-        self.km =  km
+        self.client =  client
         self.matches = []
         
     def complete_request(self,text):
@@ -20,10 +20,10 class ZMQCompleter(object):
         
         # send completion request to kernel
         # Give the kernel up to 0.5s to respond
-        msg_id = self.km.shell_channel.complete(text=text, line=line,
+        msg_id = self.client.shell_channel.complete(text=text, line=line,
                                                         cursor_pos=cursor_pos)
         
-        msg = self.km.shell_channel.get_msg(timeout=0.5)
+        msg = self.client.shell_channel.get_msg(timeout=0.5)
         if msg['parent_header']['msg_id'] == msg_id:
             return msg["content"]["matches"]
         return []

IPython/frontend/terminal/console/interactiveshell.py

@@ -106,8 +106,9 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     )
 
     def __init__(self, *args, **kwargs):
-        self.km = kwargs.pop('kernel_manager')
-        self.session_id = self.km.session.session
+        self.manager = kwargs.pop('kernel_manager')
+        self.client = kwargs.pop('kernel_client')
+        self.session_id = self.client.session.session
         super(ZMQTerminalInteractiveShell, self).__init__(*args, **kwargs)
         
     def init_completer(self):
@@ -121,7 +122,7 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
         from IPython.core.completerlib import (module_completer,
                                                magic_run_completer, cd_completer)
         
-        self.Completer = ZMQCompleter(self, self.km)
+        self.Completer = ZMQCompleter(self, self.client)
         
 
         self.set_hook('complete_command', module_completer, str_key = 'import')
@@ -156,18 +157,18 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
 
         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()
+        while self.client.shell_channel.msg_ready():
+            self.client.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():
+        msg_id = self.client.shell_channel.execute(cell, not store_history)
+        while not self.client.shell_channel.msg_ready() and self.client.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():
+        if self.client.shell_channel.msg_ready():
             self.handle_execute_reply(msg_id)
         self._executing = False
 
@@ -176,7 +177,7 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     #-----------------
 
     def handle_execute_reply(self, msg_id):
-        msg = self.km.shell_channel.get_msg()
+        msg = self.client.shell_channel.get_msg()
         if msg["parent_header"].get("msg_id", None) == msg_id:
             
             self.handle_iopub()
@@ -211,8 +212,8 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
            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()
+        while self.client.iopub_channel.msg_ready():
+            sub_msg = self.client.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']:
@@ -298,7 +299,7 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     def handle_stdin_request(self, timeout=0.1):
         """ Method to capture raw_input
         """
-        msg_rep = self.km.stdin_channel.get_msg(timeout=timeout)
+        msg_rep = self.client.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"):
@@ -325,8 +326,8 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
             
             # 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)
+            if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
+                self.client.stdin_channel.input(raw_data)
 
     def mainloop(self, display_banner=False):
         while True:
@@ -344,10 +345,10 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     def wait_for_kernel(self, timeout=None):
         """method to wait for a kernel to be ready"""
         tic = time.time()
-        self.km.hb_channel.unpause()
+        self.client.hb_channel.unpause()
         while True:
             self.run_cell('1', False)
-            if self.km.hb_channel.is_beating():
+            if self.client.hb_channel.is_beating():
                 # heart failure was not the reason this returned
                 break
             else:
@@ -389,13 +390,14 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
         # ask_exit callback.
 
         while not self.exit_now:
-            if not self.km.is_alive():
+            if not self.client.is_alive():
                 # kernel died, prompt for action or exit
-                action = "restart" if self.km.has_kernel else "wait for restart"
+
+                action = "restart" if self.manager 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)
+                    if self.manager:
+                        self.manager.restart_kernel(True)
                     self.wait_for_kernel(3)
                 else:
                     self.exit_now = True

IPython/kernel/channels.py

@@ -203,7 +203,7 class ShellChannel(ZMQSocketChannel):
 
         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
+        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.')