Merge pull request #6949 from minrk/kernel_created

fix event hookup for kernel changed

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

@@ -1,91 +1,91 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
 ], function(IPython, $, utils) {
     "use strict";
     
     var KernelSelector = function(selector, notebook) {
         this.selector = selector;
         this.notebook = notebook;
         this.events = notebook.events;
         this.current_selection = null;
         this.kernelspecs = {};
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.request_kernelspecs();
         }
         this.bind_events();
         // Make the object globally available for user convenience & inspection
         IPython.kernelselector = this;
     };
     
     KernelSelector.prototype.request_kernelspecs = function() {
         var url = utils.url_join_encode(this.notebook.base_url, 'api/kernelspecs');
         $.ajax(url, {success: $.proxy(this._got_kernelspecs, this)});
     };
     
     KernelSelector.prototype._got_kernelspecs = function(data, status, xhr) {
         this.kernelspecs = {};
         var menu = this.element.find("#kernel_selector");
         var change_kernel_submenu = $("#menu-change-kernel-submenu");
         for (var i = 0; i < data.length; i++) {
             var ks = data[i];
             this.kernelspecs[ks.name] = ks;
             var ksentry = $("<li>").attr("id", "kernel-" +ks.name).append($('<a>')
                 .attr('href', '#')
                 .click($.proxy(this.change_kernel, this, ks.name))
                 .text(ks.display_name));
             menu.append(ksentry);
 
             var ks_submenu_entry = $("<li>").attr("id", "kernel-submenu-"+ks.name).append($('<a>')
                 .attr('href', '#')
                 .click($.proxy(this.change_kernel, this, ks.name))
                 .text(ks.display_name));
             change_kernel_submenu.append(ks_submenu_entry);
         }
     };
 
     KernelSelector.prototype.change_kernel = function(kernel_name) {
         if (kernel_name === this.current_selection) {
             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);
     };
     
     KernelSelector.prototype.bind_events = function() {
         var that = this;
         this.events.on('spec_changed.Kernel', function(event, data) {
             that.current_selection = data.name;
             that.element.find("#current_kernel_spec").find('.kernel_name').text(data.display_name);
         });
         
-        this.events.on('started.Session', function(events, session) {
-            if (session.kernel_name !== that.current_selection) {
+        this.events.on('kernel_created.Session', function(event, data) {
+            if (data.kernel.name !== that.current_selection) {
                 // If we created a 'python' session, we only know if it's Python
                 // 3 or 2 on the server's reply, so we fire the event again to
                 // set things up.
-                var ks = that.kernelspecs[session.kernel_name];
+                var ks = that.kernelspecs[data.kernel.name];
                 that.events.trigger('spec_changed.Kernel', ks);
             }
         });
     };
 
     return {'KernelSelector': KernelSelector};
 });

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

@@ -1,317 +1,319 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/kernel',
 ], function(IPython, $, utils, kernel) {
     "use strict";
 
     /**
      * Session object for accessing the session REST api. The session
      * should be used to start kernels and then shut them down -- for
      * all other operations, the kernel object should be used.
      *
      * Options should include:
      *  - notebook_path: the path (not including name) to the notebook
      *  - kernel_name: the type of kernel (e.g. python3)
      *  - base_url: the root url of the notebook server
      *  - ws_url: the url to access websockets
      *  - notebook: Notebook object
      *
      * @class Session
      * @param {Object} options
      */
     var Session = function (options) {
         this.id = null;
         this.notebook_model = {
             path: options.notebook_path
         };
         this.kernel_model = {
             id: null,
             name: options.kernel_name
         };
 
         this.base_url = options.base_url;
         this.ws_url = options.ws_url;
         this.session_service_url = utils.url_join_encode(this.base_url, 'api/sessions');
         this.session_url = null;
 
         this.notebook = options.notebook;
         this.kernel = null;
         this.events = options.notebook.events;
 
         this.bind_events();
     };
 
     Session.prototype.bind_events = function () {
         var that = this;
         var record_status = function (evt, info) {
             console.log('Session: ' + evt.type + ' (' + info.session.id + ')');
         };
 
         this.events.on('kernel_created.Session', record_status);
         this.events.on('kernel_dead.Session', record_status);
         this.events.on('kernel_killed.Session', record_status);
 
         // if the kernel dies, then also remove the session
         this.events.on('kernel_dead.Kernel', function () {
             that.delete();
         });
     };
 
 
     // Public REST api functions
 
     /**
      * GET /api/sessions
      *
      * Get a list of the current sessions.
      *
      * @function list
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
     Session.prototype.list = function (success, error) {
         $.ajax(this.session_service_url, {
             processData: false,
             cache: false,
             type: "GET",
             dataType: "json",
             success: success,
             error: this._on_error(error)
         });
     };
 
     /**
      * POST /api/sessions
      *
      * Start a new session. This function can only executed once.
      *
      * @function start
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
     Session.prototype.start = function (success, error) {
         var that = this;
         var on_success = function (data, status, xhr) {
-            if (!that.kernel) {
+            if (that.kernel) {
+                that.kernel.name = that.kernel_model.name;
+            } else {
                 var kernel_service_url = utils.url_path_join(that.base_url, "api/kernels");
                 that.kernel = new kernel.Kernel(kernel_service_url, that.ws_url, that.notebook, that.kernel_model.name);
             }
             that.events.trigger('kernel_created.Session', {session: that, kernel: that.kernel});
             that.kernel._kernel_created(data.kernel);
             if (success) {
                 success(data, status, xhr);
             }
         };
         var on_error = function (xhr, status, err) {
             that.events.trigger('kernel_dead.Session', {session: that, xhr: xhr, status: status, error: err});
             if (error) {
                 error(xhr, status, err);
             }
         };
 
         $.ajax(this.session_service_url, {
             processData: false,
             cache: false,
             type: "POST",
             data: JSON.stringify(this._get_model()),
             dataType: "json",
             success: this._on_success(on_success),
             error: this._on_error(on_error)
         });
     };
 
     /**
      * GET /api/sessions/[:session_id]
      *
      * Get information about a session.
      *
      * @function get_info
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
     Session.prototype.get_info = function (success, error) {
         $.ajax(this.session_url, {
             processData: false,
             cache: false,
             type: "GET",
             dataType: "json",
             success: this._on_success(success),
             error: this._on_error(error)
         });
     };
 
     /**
      * PATCH /api/sessions/[:session_id]
      *
      * Rename or move a notebook. If the given name or path are
      * undefined, then they will not be changed.
      *
      * @function rename_notebook
      * @param {string} [path] - new notebook path
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
     Session.prototype.rename_notebook = function (path, success, error) {
         if (path !== undefined) {
             this.notebook_model.path = path;
         }
 
         $.ajax(this.session_url, {
             processData: false,
             cache: false,
             type: "PATCH",
             data: JSON.stringify(this._get_model()),
             dataType: "json",
             success: this._on_success(success),
             error: this._on_error(error)
         });
     };
 
     /**
      * DELETE /api/sessions/[:session_id]
      *
      * Kill the kernel and shutdown the session.
      *
      * @function delete
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
     Session.prototype.delete = function (success, error) {
         if (this.kernel) {
             this.events.trigger('kernel_killed.Session', {session: this, kernel: this.kernel});
             this.kernel._kernel_dead();
         }
 
         $.ajax(this.session_url, {
             processData: false,
             cache: false,
             type: "DELETE",
             dataType: "json",
             success: this._on_success(success),
             error: this._on_error(error)
         });
     };
 
     /**
      * Restart the session by deleting it and the starting it
      * fresh. If options are given, they can include any of the
      * following:
      *
      * - notebook_path - the path to the notebook
      * - kernel_name - the name (type) of the kernel
      *
      * @function restart
      * @param {Object} [options] - options for the new kernel
      * @param {function} [success] - function executed on ajax success
      * @param {function} [error] - functon executed on ajax error
      */
     Session.prototype.restart = function (options, success, error) {
         var that = this;
         var start = function () {
             if (options && options.notebook_path) {
                 that.notebook_model.path = options.notebook_path;
             }
             if (options && options.kernel_name) {
                 that.kernel_model.name = options.kernel_name;
             }
             that.kernel_model.id = null;
             that.start(success, error);
         };
         this.delete(start, start);
     };
 
     // Helper functions
 
     /**
      * Get the data model for the session, which includes the notebook path
      * and kernel (name and id).
      *
      * @function _get_model
      * @returns {Object} - the data model
      */
     Session.prototype._get_model = function () {
         return {
             notebook: this.notebook_model,
             kernel: this.kernel_model
         };
     };
 
     /**
      * Update the data model from the given JSON object, which should
      * have attributes of `id`, `notebook`, and/or `kernel`. If
      * provided, the notebook data must include name and path, and the
      * kernel data must include name and id.
      *
      * @function _update_model
      * @param {Object} data - updated data model
      */
     Session.prototype._update_model = function (data) {
         if (data && data.id) {
             this.id = data.id;
             this.session_url = utils.url_join_encode(this.session_service_url, this.id);
         }
         if (data && data.notebook) {
             this.notebook_model.path = data.notebook.path;
         }
         if (data && data.kernel) {
             this.kernel_model.name = data.kernel.name;
             this.kernel_model.id = data.kernel.id;
         }
     };
 
     /**
      * Handle a successful AJAX request by updating the session data
      * model with the response, and then optionally calling a provided
      * callback.
      *
      * @function _on_success
      * @param {function} success - callback
      */
     Session.prototype._on_success = function (success) {
         var that = this;
         return function (data, status, xhr) {
             that._update_model(data);
             if (success) {
                 success(data, status, xhr);
             }
         };
     };
 
     /**
      * Handle a failed AJAX request by logging the error message, and
      * then optionally calling a provided callback.
      *
      * @function _on_error
      * @param {function} error - callback
      */
     Session.prototype._on_error = function (error) {
         return function (xhr, status, err) {
             utils.log_ajax_error(xhr, status, err);
             if (error) {
                 error(xhr, status, err);
             }
         };
     };
 
     /**
      * Error type indicating that the session is already starting.
      */
     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
     };
 });