qtconsole autorestarts

IPython/frontend/qt/console/frontend_widget.py

@@ -445,18 +445,30 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
             self._reading = False
         self._readline(msg['content']['prompt'], callback=callback)
 
+    def _kernel_restarted_message(self, died=True):
+        msg = "Kernel died, restarting" if died else "Kernel restarting"
+        self._append_html("<br>%s<hr><br>" % msg,
+            before_prompt=False
+        )
+
     def _handle_kernel_died(self, since_last_heartbeat):
-        """ Handle the kernel's death by asking if the user wants to restart.
+        """Handle the kernel's death (if we do not own the kernel).
         """
-        self.log.debug("kernel died: %s", since_last_heartbeat)
+        self.log.warn("kernel died: %s", since_last_heartbeat)
         if self.custom_restart:
             self.custom_restart_kernel_died.emit(since_last_heartbeat)
         else:
-            message = 'The kernel heartbeat has been inactive for %.2f ' \
-                'seconds. Do you want to restart the kernel? You may ' \
-                'first want to check the network connection.' % \
-                since_last_heartbeat
-            self.restart_kernel(message, now=True)
+            self._kernel_restarted_message(died=True)
+            self.reset()
+
+    def _handle_kernel_restarted(self, died=True):
+        """Notice that the autorestarter restarted the kernel.
+
+        There's nothing to do but show a message.
+        """
+        self.log.warn("kernel restarted")
+        self._kernel_restarted_message(died=died)
+        self.reset()
 
     def _handle_object_info_reply(self, rep):
         """ Handle replies for call tips.
@@ -506,37 +518,28 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
     def _handle_shutdown_reply(self, msg):
         """ Handle shutdown signal, only if from other console.
         """
-        self.log.debug("shutdown: %s", msg.get('content', ''))
+        self.log.warn("shutdown: %s", msg.get('content', ''))
+        restart = msg.get('content', {}).get('restart', False)
         if not self._hidden and not self._is_from_this_session(msg):
-            if self._local_kernel:
-                if not msg['content']['restart']:
+            # got shutdown reply, request came from session other than ours
+            if restart:
+                # someone restarted the kernel, handle it
+                self._handle_kernel_restarted(died=False)
+            else:
+                # kernel was shutdown permanently
+                # this triggers exit_requested if the kernel was local,
+                # and a dialog if the kernel was remote,
+                # so we don't suddenly clear the qtconsole without asking.
+                if self._local_kernel:
                     self.exit_requested.emit(self)
                 else:
-                    # we just got notified of a restart!
-                    time.sleep(0.25) # wait 1/4 sec to reset
-                                     # lest the request for a new prompt
-                                     # goes to the old kernel
-                    self.reset()
-            else: # remote kernel, prompt on Kernel shutdown/reset
-                title = self.window().windowTitle()
-                if not msg['content']['restart']:
+                    title = self.window().windowTitle()
                     reply = QtGui.QMessageBox.question(self, title,
                         "Kernel has been shutdown permanently. "
                         "Close the Console?",
                         QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
                     if reply == QtGui.QMessageBox.Yes:
                         self.exit_requested.emit(self)
-                else:
-                    # XXX: remove message box in favor of using the
-                    # clear_on_kernel_restart setting?
-                    reply = QtGui.QMessageBox.question(self, title,
-                        "Kernel has been reset. Clear the Console?",
-                        QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
-                    if reply == QtGui.QMessageBox.Yes:
-                        time.sleep(0.25) # wait 1/4 sec to reset
-                                         # lest the request for a new prompt
-                                         # goes to the old kernel
-                        self.reset()
 
     def _started_channels(self):
         """ Called when the KernelManager channels have started listening or
@@ -573,12 +576,11 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
             self._reading = False
             self.kernel_manager.interrupt_kernel()
         else:
-            self._append_plain_text('Kernel process is either remote or '
-                                    'unspecified. Cannot interrupt.\n')
+            self._append_plain_text('Cannot interrupt a kernel I did not start.\n')
 
     def reset(self, clear=False):
-        """ Resets the widget to its initial state if ``clear`` parameter or
-        ``clear_on_kernel_restart`` configuration setting is True, otherwise
+        """ Resets the widget to its initial state if ``clear`` parameter
+        is True, otherwise
         prints a visual indication of the fact that the kernel restarted, but
         does not clear the traces from previous usage of the kernel before it
         was restarted.  With ``clear=True``, it is similar to ``%clear``, but
@@ -590,15 +592,9 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
         self._reading = False
         self._highlighter.highlighting_on = False
 
-        if self.clear_on_kernel_restart or clear:
+        if clear:
             self._control.clear()
             self._append_plain_text(self.banner)
-        else:
-            self._append_plain_text("# restarting kernel...")
-            self._append_html("<hr><br>")
-            # XXX: Reprinting the full banner may be too much, but once #1680 is
-            # addressed, that will mitigate it.
-            #self._append_plain_text(self.banner)
         # update output marker for stdout/stderr, so that startup
         # messages appear after banner:
         self._append_before_prompt_pos = self._get_cursor().position()
@@ -615,8 +611,9 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
 
         if self.custom_restart:
             self.custom_restart_requested.emit()
+            return
 
-        elif self.kernel_manager:
+        if self.kernel_manager:
             # Pause the heart beat channel to prevent further warnings.
             self.kernel_client.hb_channel.pause()
 
@@ -635,21 +632,23 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
             if do_restart:
                 try:
                     self.kernel_manager.restart_kernel(now=now)
-                except RuntimeError:
-                    self._append_plain_text('Kernel started externally. '
-                                            'Cannot restart.\n',
-                                            before_prompt=True
-                                            )
+                except RuntimeError as e:
+                    self._append_plain_text(
+                        'Error restarting kernel: %s\n' % e,
+                        before_prompt=True
+                    )
                 else:
-                    self.reset()
+                    self._append_html("<br>Restarting kernel...\n<hr><br>",
+                        before_prompt=True,
+                    )
             else:
                 self.kernel_client.hb_channel.unpause()
 
         else:
-            self._append_plain_text('Kernel process is either remote or '
-                                    'unspecified. Cannot restart.\n',
-                                    before_prompt=True
-                                    )
+            self._append_plain_text(
+                'Cannot restart a Kernel I did not start\n',
+                before_prompt=True
+            )
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface

IPython/frontend/qt/console/qtconsoleapp.py

@@ -62,6 +62,7 b' from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget'
 from IPython.frontend.qt.console import styles
 from IPython.frontend.qt.console.mainwindow import MainWindow
 from IPython.frontend.qt.client import QtKernelClient
+from IPython.frontend.qt.manager import QtKernelManager
 from IPython.kernel import tunnel_to_kernel, find_connection_file
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CBool, Any
@@ -160,6 +161,7 b' class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):'
     frontend_flags = Any(qt_flags)
     frontend_aliases = Any(qt_aliases)
     kernel_client_class = QtKernelClient
+    kernel_manager_class = QtKernelManager
 
     stylesheet = Unicode('', config=True,
         help="path to a custom CSS stylesheet")
@@ -189,19 +191,15 b' class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):'
         kernel_manager = self.kernel_manager_class(
                                 connection_file=self._new_connection_file(),
                                 config=self.config,
+                                autorestart=True,
         )
         # start the kernel
         kwargs = dict()
         kwargs['extra_arguments'] = self.kernel_argv
         kernel_manager.start_kernel(**kwargs)
-
-        # connect to the kernel
-        kernel_client = self.kernel_client_class(
-                                connection_file=kernel_manager.connection_file,
-                                config=self.config,
-        )
-        kernel_client.load_connection_file()
-        kernel_client.start_channels()
+        kernel_manager.client_factory = self.kernel_client_class
+        kernel_client = kernel_manager.client()
+        kernel_client.start_channels(shell=True, iopub=True)
         widget = self.widget_factory(config=self.config,
                                    local_kernel=True)
         self.init_colors(widget)
@@ -220,7 +218,6 b' class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):'
         current_widget : IPythonWidget
             The IPythonWidget whose kernel this frontend is to share
         """
-
         kernel_client = self.kernel_client_class(
                                 connection_file=current_widget.kernel_client.connection_file,
                                 config = self.config,
@@ -234,11 +231,15 b' class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):'
         widget._may_close = False
         widget._confirm_exit = False
         widget.kernel_client = kernel_client
+        widget.kernel_manager = current_widget.kernel_manager
         return widget
 
+    def init_qt_app(self):
+        # separate from qt_elements, because it must run first
+        self.app = QtGui.QApplication([])
+
     def init_qt_elements(self):
         # Create the widget.
-        self.app = QtGui.QApplication([])
 
         base_path = os.path.abspath(os.path.dirname(__file__))
         icon_path = os.path.join(base_path, 'resources', 'icon', 'IPythonConsole.svg')
@@ -345,6 +346,7 b' class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):'
 
     @catch_config_error
     def initialize(self, argv=None):
+        self.init_qt_app()
         super(IPythonQtConsoleApp, self).initialize(argv)
         IPythonConsoleApp.initialize(self,argv)
         self.init_qt_elements()