Better user experience when kernel isn't found

IPython/html/services/sessions/handlers.py

@@ -1,118 +1,122 b''
 """Tornado handlers for the sessions web service."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 
 from tornado import web
 
 from ...base.handlers import IPythonHandler, json_errors
 from IPython.utils.jsonutil import date_default
 from IPython.html.utils import url_path_join, url_escape
 from IPython.kernel.kernelspec import NoSuchKernel
 
 
 class SessionRootHandler(IPythonHandler):
 
     @web.authenticated
     @json_errors
     def get(self):
         # Return a list of running sessions
         sm = self.session_manager
         sessions = sm.list_sessions()
         self.finish(json.dumps(sessions, default=date_default))
 
     @web.authenticated
     @json_errors
     def post(self):
         # Creates a new session
         #(unless a session already exists for the named nb)
         sm = self.session_manager
         cm = self.contents_manager
         km = self.kernel_manager
 
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, "No JSON data provided")
         try:
             name = model['notebook']['name']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: notebook.name")
         try:
             path = model['notebook']['path']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: notebook.path")
         try:
             kernel_name = model['kernel']['name']
         except KeyError:
             self.log.debug("No kernel name specified, using default kernel")
             kernel_name = None
 
         # Check to see if session exists
         if sm.session_exists(name=name, path=path):
             model = sm.get_session(name=name, path=path)
         else:
             try:
                 model = sm.create_session(name=name, path=path, kernel_name=kernel_name)
             except NoSuchKernel:
-                raise web.HTTPError(400, "No such kernel: %s" % kernel_name)
+                msg = ("The '%s' kernel is not available. Please pick another "
+                       "suitable kernel instead, or install that kernel." % kernel_name)
+                status_msg = 'Kernel not found'
+                msg = dict(full=msg, short=status_msg)
+                raise web.HTTPError(400, json.dumps(msg))
 
         location = url_path_join(self.base_url, 'api', 'sessions', model['id'])
         self.set_header('Location', url_escape(location))
         self.set_status(201)
         self.finish(json.dumps(model, default=date_default))
 
 class SessionHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'PATCH', 'DELETE')
 
     @web.authenticated
     @json_errors
     def get(self, session_id):
         # Returns the JSON model for a single session
         sm = self.session_manager
         model = sm.get_session(session_id=session_id)
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     def patch(self, session_id):
         # Currently, this handler is strictly for renaming notebooks
         sm = self.session_manager
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, "No JSON data provided")
         changes = {}
         if 'notebook' in model:
             notebook = model['notebook']
             if 'name' in notebook:
                 changes['name'] = notebook['name']
             if 'path' in notebook:
                 changes['path'] = notebook['path']
 
         sm.update_session(session_id, **changes)
         model = sm.get_session(session_id=session_id)
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     def delete(self, session_id):
         # Deletes the session with given session_id
         sm = self.session_manager
         sm.delete_session(session_id)
         self.set_status(204)
         self.finish()
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 _session_id_regex = r"(?P<session_id>\w+-\w+-\w+-\w+-\w+)"
 
 default_handlers = [
     (r"/api/sessions/%s" % _session_id_regex, SessionHandler),
     (r"/api/sessions",  SessionRootHandler)
 ]
 

IPython/html/static/notebook/js/notificationarea.js

@@ -1,319 +1,309 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/dialog',
     'notebook/js/notificationwidget',
     'moment'
 ], function(IPython, $, utils, dialog, notificationwidget, moment) {
     "use strict";
 
     // store reference to the NotificationWidget class
     var NotificationWidget = notificationwidget.NotificationWidget;
 
     /**
      * Construct the NotificationArea object. Options are:
      *     events: $(Events) instance
      *     save_widget: SaveWidget instance
      *     notebook: Notebook instance
      *     keyboard_manager: KeyboardManager instance
      *
      * @constructor
      * @param {string} selector - a jQuery selector string for the
      * notification area element
      * @param {Object} [options] - a dictionary of keyword arguments.
      */
     var NotificationArea = function (selector, options) {
         this.selector = selector;
         this.events = options.events;
         this.save_widget = options.save_widget;
         this.notebook = options.notebook;
         this.keyboard_manager = options.keyboard_manager;
         if (this.selector !== undefined) {
             this.element = $(selector);
         }
         this.widget_dict = {};
     };
 
     /**
      * Get a widget by name, creating it if it doesn't exist.
      *
      * @method widget
      * @param {string} name - the widget name
      */
     NotificationArea.prototype.widget = function (name) {
         if (this.widget_dict[name] === undefined) {
             return this.new_notification_widget(name);
         }
         return this.get_widget(name);
     };
 
     /**
      * Get a widget by name, throwing an error if it doesn't exist.
      *
      * @method get_widget
      * @param {string} name - the widget name
      */
     NotificationArea.prototype.get_widget = function (name) {
         if(this.widget_dict[name] === undefined) {
             throw('no widgets with this name');
         }
         return this.widget_dict[name];
     };
 
     /**
      * Create a new notification widget with the given name. The
      * widget must not already exist.
      *
      * @method new_notification_widget
      * @param {string} name - the widget name
      */
     NotificationArea.prototype.new_notification_widget = function (name) {
         if (this.widget_dict[name] !== undefined) {
             throw('widget with that name already exists!');
         }
 
         // create the element for the notification widget and add it
         // to the notification aread element
         var div = $('<div/>').attr('id', 'notification_' + name);
         $(this.selector).append(div);
 
         // create the widget object and return it
         this.widget_dict[name] = new NotificationWidget('#notification_' + name);
         return this.widget_dict[name];
     };
 
     /**
      * Initialize the default set of notification widgets.
      *
      * @method init_notification_widgets
      */
     NotificationArea.prototype.init_notification_widgets = function () {
         this.init_kernel_notification_widget();
         this.init_notebook_notification_widget();
     };
 
     /**
      * Initialize the notification widget for kernel status messages.
      *
      * @method init_kernel_notification_widget
      */
     NotificationArea.prototype.init_kernel_notification_widget = function () {
         var that = this;
         var knw = this.new_notification_widget('kernel');
         var $kernel_ind_icon = $("#kernel_indicator_icon");
         var $modal_ind_icon = $("#modal_indicator_icon");
 
         // Command/Edit mode
         this.events.on('edit_mode.Notebook',function () {
             that.save_widget.update_document_title();
             $modal_ind_icon.attr('class','edit_mode_icon').attr('title','Edit Mode');
         });
 
         this.events.on('command_mode.Notebook',function () {
             that.save_widget.update_document_title();
             $modal_ind_icon.attr('class','command_mode_icon').attr('title','Command Mode');
         });
 
         // Implicitly start off in Command mode, switching to Edit mode will trigger event
         $modal_ind_icon.attr('class','command_mode_icon').attr('title','Command Mode');
 
         // Kernel events
         this.events.on('status_idle.Kernel',function () {
             that.save_widget.update_document_title();
             $kernel_ind_icon.attr('class','kernel_idle_icon').attr('title','Kernel Idle');
         });
 
         this.events.on('status_busy.Kernel',function () {
             window.document.title='(Busy) '+window.document.title;
             $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel Busy');
         });
 
         this.events.on('status_restarting.Kernel',function () {
             that.save_widget.update_document_title();
             knw.set_message("Restarting kernel", 2000);
         });
 
         this.events.on('status_dead.Kernel',function () {
             that.save_widget.update_document_title();
             knw.danger("Dead kernel");
             $kernel_ind_icon.attr('class','kernel_dead_icon').attr('title','Kernel Dead');
         });
 
         this.events.on('status_interrupting.Kernel',function () {
             knw.set_message("Interrupting kernel", 2000);
         });
         
         // Start the kernel indicator in the busy state, and send a kernel_info request.
         // When the kernel_info reply arrives, the kernel is idle.
         $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel Busy');
 
         this.events.on('status_started.Kernel', function (evt, data) {
             knw.info("Websockets Connected", 500);
             that.events.trigger('status_busy.Kernel');
             data.kernel.kernel_info(function () {
                 that.events.trigger('status_idle.Kernel');
             });
         });
 
         this.events.on('status_restart_failed.Kernel',function () {
             var msg = 'The kernel has died, and the automatic restart has failed.' +
                 ' It is possible the kernel cannot be restarted.' +
                 ' If you are not able to restart the kernel, you will still be able to save' +
                 ' the notebook, but running code will no longer work until the notebook' +
                 ' is reopened.';
 
             dialog.modal({
                 title: "Dead kernel",
                 body : msg,
                 keyboard_manager: that.keyboard_manager,
                 notebook: that.notebook,
                 buttons : {
                     "Manual Restart": {
                         class: "btn-danger",
                         click: function () {
                             that.events.trigger('status_restarting.Kernel');
                             that.notebook.start_kernel();
                         }
                     },
                     "Don't restart": {}
                 }
             });
         });
 
         this.events.on('start_failed.Session',function (session, xhr, status, error) {
-            var msg = $('<div/>');
-            msg.append($('<div/>')
-                       .text('The kernel could not be started. This might ' +
-                             'happen if the notebook was previously run with a kernel ' +
-                             'that you do not have installed. Please choose a different kernel, ' +
-                             'or install the needed kernel and then refresh this page.')
-                       .css('margin-bottom', '1em'));
-
-            msg.append($('<div/>')
-                       .text('The exact error was:')
-                       .css('margin-bottom', '1em'));
-
-            msg.append($('<div/>')
-                       .attr('class', 'alert alert-danger')
-                       .attr('role', 'alert')
-                       .text(JSON.parse(status.responseText).message));
+            var msg = JSON.parse(status.responseJSON.message);
 
+            that.save_widget.update_document_title();
+            $kernel_ind_icon.attr('class','kernel_dead_icon').attr('title','Kernel Dead');
+            knw.danger(msg.short, undefined, function () {
             dialog.modal({
                 title: "Failed to start the kernel",
-                body : msg,
+                    body : msg.full,
                 keyboard_manager: that.keyboard_manager,
                 notebook: that.notebook,
                 buttons : {
                     "Ok": { class: 'btn-primary' }
                 }
             });
+                return false;
+            });
         });
 
         this.events.on('websocket_closed.Kernel', function (event, data) {
             var kernel = data.kernel;
             var ws_url = data.ws_url;
             var early = data.early;
             var msg;
 
             $kernel_ind_icon
                 .attr('class', 'kernel_disconnected_icon')
                 .attr('title', 'No Connection to Kernel');
             
             if (!early) {
                     knw.warning('Reconnecting');
                     setTimeout(function () {
                         kernel.start_channels();
                     }, 5000);
                 return;
             }
             console.log('WebSocket connection failed: ', ws_url);
             msg = "A WebSocket connection could not be established." +
                 " You will NOT be able to run code. Check your" +
                 " network connection or notebook server configuration.";
             dialog.modal({
                 title: "WebSocket connection failed",
                 body: msg,
                 keyboard_manager: that.keyboard_manager,
                 notebook: that.notebook,
                 buttons : {
                     "OK": {},
                     "Reconnect": {
                         click: function () {
                             knw.warning('Reconnecting');
                             setTimeout(function () {
                                 kernel.start_channels();
                             }, 5000);
                         }
                     }
                 }
             });
         });
     };
 
     /**
      * Initialize the notification widget for notebook status messages.
      *
      * @method init_notebook_notification_widget
      */
     NotificationArea.prototype.init_notebook_notification_widget = function () {
         var nnw = this.new_notification_widget('notebook');
 
         // Notebook events
         this.events.on('notebook_loading.Notebook', function () {
             nnw.set_message("Loading notebook",500);
         });
         this.events.on('notebook_loaded.Notebook', function () {
             nnw.set_message("Notebook loaded",500);
         });
         this.events.on('notebook_saving.Notebook', function () {
             nnw.set_message("Saving notebook",500);
         });
         this.events.on('notebook_saved.Notebook', function () {
             nnw.set_message("Notebook saved",2000);
         });
         this.events.on('notebook_save_failed.Notebook', function (evt, xhr, status, data) {
             nnw.warning(data || "Notebook save failed");
         });
         
         // Checkpoint events
         this.events.on('checkpoint_created.Notebook', function (evt, data) {
             var msg = "Checkpoint created";
             if (data.last_modified) {
                 var d = new Date(data.last_modified);
                 msg = msg + ": " + moment(d).format("HH:mm:ss");
             }
             nnw.set_message(msg, 2000);
         });
         this.events.on('checkpoint_failed.Notebook', function () {
             nnw.warning("Checkpoint failed");
         });
         this.events.on('checkpoint_deleted.Notebook', function () {
             nnw.set_message("Checkpoint deleted", 500);
         });
         this.events.on('checkpoint_delete_failed.Notebook', function () {
             nnw.warning("Checkpoint delete failed");
         });
         this.events.on('checkpoint_restoring.Notebook', function () {
             nnw.set_message("Restoring to checkpoint...", 500);
         });
         this.events.on('checkpoint_restore_failed.Notebook', function () {
             nnw.warning("Checkpoint restore failed");
         });
 
         // Autosave events
         this.events.on('autosave_disabled.Notebook', function () {
             nnw.set_message("Autosave disabled", 2000);
         });
         this.events.on('autosave_enabled.Notebook', function (evt, interval) {
             nnw.set_message("Saving every " + interval / 1000 + "s", 1000);
         });
     };
 
     IPython.NotificationArea = NotificationArea;
 
     return {'NotificationArea': NotificationArea};
 });

IPython/html/static/services/sessions/js/session.js

@@ -1,150 +1,149 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'services/kernels/js/kernel',
 ], function(IPython, $, utils, kernel) {
     "use strict";
 
     var Session = function(options){
         this.kernel = null;
         this.id = null;
         this.notebook = options.notebook;
         this.events = options.notebook.events;
         this.name = options.notebook_name;
         this.path = options.notebook_path;
         this.kernel_name = options.kernel_name;
         this.base_url = options.base_url;
         this.ws_url = options.ws_url;
     };
     
     Session.prototype.start = function (success, error) {
         var that = this;
         var model = {
             notebook : {
                 name : this.name,
                 path : this.path
             },
             kernel : {
                 name : this.kernel_name
             }
         };
         var settings = {
             processData : false,
             cache : false,
             type : "POST",
             data: JSON.stringify(model),
             dataType : "json",
             success : function (data, status, xhr) {
                 that._handle_start_success(data);
                 if (success) {
                     success(data, status, xhr);
                 }
             },
             error : function (xhr, status, err) {
                 that._handle_start_failure(xhr, status, err);
                 if (error !== undefined) {
                     error(xhr, status, err);
                 }
                 utils.log_ajax_error(xhr, status, err);
             }
         };
         var url = utils.url_join_encode(this.base_url, 'api/sessions');
         $.ajax(url, settings);
     };
     
     Session.prototype.rename_notebook = function (name, path) {
         this.name = name;
         this.path = path;
         var model = {
             notebook : {
                 name : this.name,
                 path : this.path
             }
         };
         var settings = {
             processData : false,
             cache : false,
             type : "PATCH",
             data: JSON.stringify(model),
             dataType : "json",
             error : utils.log_ajax_error,
         };
         var url = utils.url_join_encode(this.base_url, 'api/sessions', this.id);
         $.ajax(url, settings);
     };
     
     Session.prototype.delete = function (success, error) {
         var settings = {
             processData : false,
             cache : false,
             type : "DELETE",
             dataType : "json",
             success : success,
             error : error || utils.log_ajax_error,
         };
         if (this.kernel) {
             this.kernel.running = false;
             this.kernel.stop_channels();
         }
         var url = utils.url_join_encode(this.base_url, 'api/sessions', this.id);
         $.ajax(url, settings);
     };
     
     // Kernel related things
     /**
      * Create the Kernel object associated with this Session.
      * 
      * @method _handle_start_success
      */
     Session.prototype._handle_start_success = function (data, status, xhr) {
         this.id = data.id;
         // If we asked for 'python', the response will have 'python3' or 'python2'.
         this.kernel_name = data.kernel.name;
         this.events.trigger('started.Session', this);
         var kernel_service_url = utils.url_path_join(this.base_url, "api/kernels");
         this.kernel = new kernel.Kernel(kernel_service_url, this.ws_url, this.notebook, this.kernel_name);
         this.kernel._kernel_started(data.kernel);
     };
 
     Session.prototype._handle_start_failure = function (xhr, status, error) {
         this.events.trigger('start_failed.Session', [this, xhr, status, error]);
-        this.events.trigger('status_dead.Kernel');
     };
     
     /**
      * Prompt the user to restart the IPython kernel.
      * 
      * @method restart_kernel
      */
     Session.prototype.restart_kernel = function () {
         this.kernel.restart();
     };
     
     Session.prototype.interrupt_kernel = function() {
         this.kernel.interrupt();
     };
     
 
     Session.prototype.kill_kernel = function() {
         this.kernel.kill();
     };
     
     var SessionAlreadyStarting = function (message) {
         this.name = "SessionAlreadyStarting";
         this.message = (message || "");
     };
     
     SessionAlreadyStarting.prototype = Error.prototype;
     
     // For backwards compatability.
     IPython.Session = Session;
 
     return {
         Session: Session,
         SessionAlreadyStarting: SessionAlreadyStarting,
     };
 });