Merge pull request #6305 from minrk/switch-kernel-close-ws

JS: close WebSockets when killing kernels

IPython/html/tests/services/session.js

@@ -0,0 +1,43 b''
+
+//
+// Tests for the Session object
+//
+
+casper.notebook_test(function () {
+    this.evaluate(function () {
+        var kernel = IPython.notebook.session.kernel;
+        IPython._channels = [
+            kernel.shell_channel,
+            kernel.iopub_channel,
+            kernel.stdin_channel
+        ];
+        IPython.notebook.session.delete();
+    });
+    
+    this.waitFor(function () {
+        return this.evaluate(function(){
+            for (var i=0; i < IPython._channels.length; i++) {
+                var ws = IPython._channels[i];
+                if (ws.readyState !== ws.CLOSED) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    });
+
+    this.then(function () {
+        var states = this.evaluate(function() {
+            var states = [];
+            for (var i = 0; i < IPython._channels.length; i++) {
+                states.push(IPython._channels[i].readyState);
+            }
+            return states;
+        });
+        
+        for (var i = 0; i < states.length; i++) {
+            this.test.assertEquals(states[i], WebSocket.CLOSED,
+                "Session.delete closes websockets[" + i + "]");
+        }
+    });
+});

IPython/html/services/kernels/handlers.py

@@ -84,6 +84,9 b' class KernelActionHandler(IPythonHandler):'
 
 class ZMQChannelHandler(AuthenticatedZMQStreamHandler):
     
+    def __repr__(self):
+        return "%s(%s)" % (self.__class__.__name__, getattr(self, 'kernel_id', 'uninitialized'))
+    
     def create_stream(self):
         km = self.kernel_manager
         meth = getattr(km, 'connect_%s' % self.channel)
@@ -145,6 +148,12 b' class ZMQChannelHandler(AuthenticatedZMQStreamHandler):'
             self.zmq_stream.on_recv(self._on_zmq_reply)
 
     def on_message(self, msg):
+        if self.zmq_stream is None:
+            return
+        elif self.zmq_stream.closed():
+            self.log.info("%s closed, closing websocket.", self)
+            self.close()
+            return
         msg = json.loads(msg)
         self.session.send(self.zmq_stream, msg)
 

IPython/html/static/notebook/js/kernelselector.js

@@ -54,9 +54,19 b' define(['
             return;
         }
         var ks = this.kernelspecs[kernel_name];
+        try {
+            this.notebook.start_session(kernel_name);
+        } catch (e) {
+            if (e.name === 'SessionAlreadyStarting') {
+                console.log("Cannot change kernel while waiting for pending session start.");
+            } else {
+                // unhandled error
+                throw e;
+            }
+            // only trigger spec_changed if change was successful
+            return;
+        }
         this.events.trigger('spec_changed.Kernel', ks);
-        this.notebook.session.delete();
-        this.notebook.start_session(kernel_name);
     };
     
     KernelSelector.prototype.bind_events = function() {

IPython/html/static/notebook/js/menubar.js

@@ -157,12 +157,13 b' define(['
             }
         });
         this.element.find('#kill_and_exit').click(function () {
-            that.notebook.session.delete();
-            setTimeout(function(){
+            var close_window = function () {
                 // allow closing of new tabs in Chromium, impossible in FF
                 window.open('', '_self', '');
                 window.close();
-            }, 500);
+            };
+            // finish with close on success or failure
+            that.notebook.session.delete(close_window, close_window);
         });
         // Edit
         this.element.find('#cut_cell').click(function () {

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

@@ -62,6 +62,7 b' define(['
         this.save_widget = options.save_widget;
         this.tooltip = new tooltip.Tooltip(this.events);
         this.ws_url = options.ws_url;
+        this._session_starting = false;
         // default_kernel_name is a temporary measure while we implement proper
         // kernel selection and delayed start. Do not rely on it.
         this.default_kernel_name = 'python';
@@ -1525,9 +1526,38 b' define(['
      * @method start_session
      */
     Notebook.prototype.start_session = function (kernel_name) {
+        var that = this;
         if (kernel_name === undefined) {
             kernel_name = this.default_kernel_name;
         }
+        if (this._session_starting) {
+            throw new session.SessionAlreadyStarting();
+        }
+        this._session_starting = true;
+        
+        if (this.session !== null) {
+            var s = this.session;
+            this.session = null;
+            // need to start the new session in a callback after delete,
+            // because javascript does not guarantee the ordering of AJAX requests (?!)
+            s.delete(function () {
+                    // on successful delete, start new session
+                    that._session_starting = false;
+                    that.start_session(kernel_name);
+                }, function (jqXHR, status, error) {
+                    // log the failed delete, but still create a new session
+                    // 404 just means it was already deleted by someone else,
+                    // but other errors are possible.
+                    utils.log_ajax_error(jqXHR, status, error);
+                    that._session_starting = false;
+                    that.start_session(kernel_name);
+                }
+            );
+            return;
+        }
+        
+        
+    
         this.session = new session.Session({
             base_url: this.base_url,
             ws_url: this.ws_url,
@@ -1539,7 +1569,10 b' define(['
             kernel_name: kernel_name,
             notebook: this});
 
-        this.session.start($.proxy(this._session_started, this));
+        this.session.start(
+            $.proxy(this._session_started, this),
+            $.proxy(this._session_start_failed, this)
+        );
     };
 
 
@@ -1548,7 +1581,8 b' define(['
      * comm manager to the widget manager
      *
      */
-    Notebook.prototype._session_started = function(){
+    Notebook.prototype._session_started = function (){
+        this._session_starting = false;
         this.kernel = this.session.kernel;
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
@@ -1558,7 +1592,11 b' define(['
             }
         }
     };
-    
+    Notebook.prototype._session_start_failed = function (jqxhr, status, error){
+        this._session_starting = false;
+        utils.log_ajax_error(jqxhr, status, error);
+    };
+
     /**
      * Prompt the user to restart the IPython kernel.
      * 

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

@@ -109,6 +109,12 b' define(['
             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);
         });
@@ -118,6 +124,8 b' define(['
         $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');
             });
@@ -153,8 +161,13 b' define(['
             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.set_message('Reconnecting WebSockets', 1000);
+                    knw.warning('Reconnecting');
                     setTimeout(function () {
                         kernel.start_channels();
                     }, 5000);
@@ -173,7 +186,7 b' define(['
                     "OK": {},
                     "Reconnect": {
                         click: function () {
-                            knw.set_message('Reconnecting WebSockets', 1000);
+                            knw.warning('Reconnecting');
                             setTimeout(function () {
                                 kernel.start_channels();
                             }, 5000);

IPython/html/static/notebook/less/notificationarea.less

@@ -43,4 +43,12 b''
     .icon(@fa-var-circle);
 }
 
+.kernel_dead_icon:before {
+    .icon(@fa-var-bomb);
+}
+
+.kernel_disconnected_icon:before {
+    .icon(@fa-var-chain-broken);
+}
+
 

IPython/html/static/services/kernels/js/kernel.js

@@ -179,10 +179,18 b' define(['
                 that._websocket_closed(ws_host_url, false);
             }
         };
+        var ws_error = function(evt){
+            if (already_called_onclose){
+                return;
+            }
+            already_called_onclose = true;
+            that._websocket_closed(ws_host_url, false);
+        };
         var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel];
         for (var i=0; i < channels.length; i++) {
             channels[i].onopen = $.proxy(this._ws_opened, this);
             channels[i].onclose = ws_closed_early;
+            channels[i].onerror = ws_error;
         }
         // switch from early-close to late-close message after 1s
         setTimeout(function() {
@@ -211,7 +219,7 b' define(['
         var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel];
         for (var i=0; i < channels.length; i++) {
             // if any channel is not ready, don't trigger event.
-            if ( !channels[i].readyState ) return;
+            if ( channels[i].readyState == WebSocket.OPEN ) return;
         }
         // all events ready, trigger started event.
         this.events.trigger('status_started.Kernel', {kernel: this});
@@ -385,15 +393,17 b' define(['
     };
 
 
-    Kernel.prototype.kill = function () {
+    Kernel.prototype.kill = function (success, error) {
         if (this.running) {
             this.running = false;
             var settings = {
                 cache : false,
                 type : "DELETE",
-                error : utils.log_ajax_error,
+                success : success,
+                error : error || utils.log_ajax_error,
             };
             $.ajax(utils.url_join_encode(this.kernel_url), settings);
+            this.stop_channels();
         }
     };
 

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

@@ -21,7 +21,7 b' define(['
         this.ws_url = options.ws_url;
     };
     
-    Session.prototype.start = function(callback) {
+    Session.prototype.start = function (success, error) {
         var that = this;
         var model = {
             notebook : {
@@ -40,11 +40,17 b' define(['
             dataType : "json",
             success : function (data, status, xhr) {
                 that._handle_start_success(data);
-                if (callback) {
-                    callback(data, status, xhr);
+                if (success) {
+                    success(data, status, xhr);
                 }
             },
-            error : utils.log_ajax_error,
+            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);
@@ -71,15 +77,19 b' define(['
         $.ajax(url, settings);
     };
     
-    Session.prototype.delete = function() {
+    Session.prototype.delete = function (success, error) {
         var settings = {
             processData : false,
             cache : false,
             type : "DELETE",
             dataType : "json",
-            error : utils.log_ajax_error,
+            success : success,
+            error : error || utils.log_ajax_error,
         };
-        this.kernel.running = false;
+        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);
     };
@@ -99,6 +109,11 b' define(['
         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.
@@ -118,8 +133,18 b' define(['
         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};
+    return {
+        Session: Session,
+        SessionAlreadyStarting: SessionAlreadyStarting,
+    };
 });

IPython/html/static/style/style.min.css

@@ -9998,6 +9998,38 b' ul#help_menu li a i {'
 .kernel_busy_icon:before.pull-right {
   margin-left: .3em;
 }
+.kernel_dead_icon:before {
+  display: inline-block;
+  font-family: FontAwesome;
+  font-style: normal;
+  font-weight: normal;
+  line-height: 1;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  content: "\f1e2";
+}
+.kernel_dead_icon:before.pull-left {
+  margin-right: .3em;
+}
+.kernel_dead_icon:before.pull-right {
+  margin-left: .3em;
+}
+.kernel_disconnected_icon:before {
+  display: inline-block;
+  font-family: FontAwesome;
+  font-style: normal;
+  font-weight: normal;
+  line-height: 1;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  content: "\f127";
+}
+.kernel_disconnected_icon:before.pull-left {
+  margin-right: .3em;
+}
+.kernel_disconnected_icon:before.pull-right {
+  margin-left: .3em;
+}
 .notification_widget {
   color: #777777;
   padding: 1px 12px;

IPython/html/tests/services/kernel.js

@@ -1,12 +1,12 b''
 
 //
-// Miscellaneous javascript tests
+// Kernel tests
 //
 casper.notebook_test(function () {
     this.evaluate(function () {
         IPython.notebook.kernel.kernel_info(
             function(msg){
-                    IPython._kernel_info_response = msg;
+                IPython._kernel_info_response = msg;
             })
     });
 
@@ -24,5 +24,41 b' casper.notebook_test(function () {'
         this.test.assertTrue( kernel_info_response.msg_type === 'kernel_info_reply', 'Kernel info request return kernel_info_reply');
         this.test.assertTrue( kernel_info_response.content !== undefined, 'Kernel_info_reply is not undefined');
     });
-
+    
+    this.thenEvaluate(function () {
+        var kernel = IPython.notebook.session.kernel;
+        IPython._channels = [
+            kernel.shell_channel,
+            kernel.iopub_channel,
+            kernel.stdin_channel
+        ];
+        kernel.kill();
+    });
+    
+    this.waitFor(function () {
+        return this.evaluate(function(){
+            for (var i=0; i < IPython._channels.length; i++) {
+                var ws = IPython._channels[i];
+                if (ws.readyState !== ws.CLOSED) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    });
+    
+    this.then(function () {
+        var states = this.evaluate(function() {
+            var states = [];
+            for (var i = 0; i < IPython._channels.length; i++) {
+                states.push(IPython._channels[i].readyState);
+            }
+            return states;
+        });
+        
+        for (var i = 0; i < states.length; i++) {
+            this.test.assertEquals(states[i], WebSocket.CLOSED,
+                "Kernel.kill closes websockets[" + i + "]");
+        }
+    });
 });