store current kernel selection in frontend config

instead of localStorage

IPython/html/static/tree/js/main.js

@@ -1,144 +1,150 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 require([
     'jquery',
     'base/js/namespace',
     'base/js/dialog',
     'base/js/events',
     'base/js/page',
     'base/js/utils',
+    'services/config',
     'contents',
     'tree/js/notebooklist',
     'tree/js/clusterlist',
     'tree/js/sessionlist',
     'tree/js/kernellist',
     'tree/js/terminallist',
     'tree/js/newnotebook',
     'auth/js/loginwidget',
     // only loaded, not used:
     'jqueryui',
     'bootstrap',
     'custom/custom',
 ], function(
     $,
     IPython,
     dialog,
     events,
     page,
     utils,
+    config,
     contents_service,
     notebooklist,
     clusterlist,
     sesssionlist,
     kernellist,
     terminallist,
     newnotebook,
     loginwidget){
     "use strict";
 
     page = new page.Page();
     
     var common_options = {
         base_url: utils.get_body_data("baseUrl"),
         notebook_path: utils.get_body_data("notebookPath"),
     };
+    var cfg = new config.ConfigSection('tree', common_options);
+    cfg.load();
+    common_options.config = cfg;
+    
     var session_list = new sesssionlist.SesssionList($.extend({
         events: events}, 
         common_options));
     var contents = new contents_service.Contents($.extend({
         events: events},
         common_options));
     var notebook_list = new notebooklist.NotebookList('#notebook_list', $.extend({
         contents: contents,
         session_list:  session_list}, 
         common_options));
     var cluster_list = new clusterlist.ClusterList('#cluster_list', common_options);
     var kernel_list = new kernellist.KernelList('#running_list',  $.extend({
         session_list:  session_list}, 
         common_options));
     
     var terminal_list;
     if (utils.get_body_data("terminalsAvailable") === "True") {
         terminal_list = new terminallist.TerminalList('#terminal_list', common_options);
     }
 
     var login_widget = new loginwidget.LoginWidget('#login_widget', common_options);
 
     var nnw = new newnotebook.NewNotebookWidget("#new-notebook-buttons",
         $.extend(
             {contents: contents},
             common_options
         )
     );
 
     var interval_id=0;
     // auto refresh every xx secondes, no need to be fast,
     //  update is done at least when page get focus
     var time_refresh = 60; // in sec
 
     var enable_autorefresh = function(){
         /**
          *refresh immediately , then start interval
          */
         session_list.load_sessions();
         cluster_list.load_list();
 	if (terminal_list) {
 	    terminal_list.load_terminals();
 	}
         if (!interval_id){
             interval_id = setInterval(function(){
                     session_list.load_sessions();
                     cluster_list.load_list();
 		    if (terminal_list) {
 		        terminal_list.load_terminals();
 		    }
                 }, time_refresh*1000);
             }
     };
 
     var disable_autorefresh = function(){
         clearInterval(interval_id);
         interval_id = 0;
     };
 
     // stop autorefresh when page lose focus
     $(window).blur(function() {
         disable_autorefresh();
     });
 
     //re-enable when page get focus back
     $(window).focus(function() {
         enable_autorefresh();
     });
 
     // finally start it, it will refresh immediately
     enable_autorefresh();
 
     page.show();
 
     // For backwards compatability.
     IPython.page = page;
     IPython.notebook_list = notebook_list;
     IPython.cluster_list = cluster_list;
     IPython.session_list = session_list;
     IPython.kernel_list = kernel_list;
     IPython.login_widget = login_widget;
 
     events.trigger('app_initialized.DashboardApp');
     
     // bound the upload method to the on change of the file select list
     $("#alternate_upload").change(function (event){
         notebook_list.handleFilesUpload(event,'form');
     });
     
     // set hash on tab click
     $("#tabs").find("a").click(function() {
         window.location.hash = $(this).attr("href");
     });
     
     // load tab if url hash
     if (window.location.hash) {
         $("#tabs").find("a[href=" + window.location.hash + "]").click();
     }
 });

IPython/html/static/tree/js/newnotebook.js

@@ -1,143 +1,158 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'jquery',
     'base/js/namespace',
     'base/js/utils',
     'base/js/dialog',
 ], function ($, IPython, utils, dialog) {
     "use strict";
     
     var NewNotebookWidget = function (selector, options) {
         this.selector = selector;
         this.base_url = options.base_url;
         this.notebook_path = options.notebook_path;
         this.contents = options.contents;
         this.current_selection = null;
+        this.config = options.config;
         this.kernelspecs = {};
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.request_kernelspecs();
         }
         this.bind_events();
     };
     
     NewNotebookWidget.prototype.bind_events = function () {
         var that = this;
         this.element.find('#new_notebook').click(function () {
             that.new_notebook();
         });
     };
     
     NewNotebookWidget.prototype.request_kernelspecs = function () {
         /** request and then load kernel specs */
         var url = utils.url_join_encode(this.base_url, 'api/kernelspecs');
         utils.promising_ajax(url).then($.proxy(this._load_kernelspecs, this));
     };
     
     NewNotebookWidget.prototype._load_kernelspecs = function (data) {
         /** load kernelspec list */
+        var that = this;
         this.kernelspecs = data.kernelspecs;
         var menu = this.element.find("#new-notebook-menu");
         var keys = Object.keys(data.kernelspecs).sort(function (a, b) {
             var da = data.kernelspecs[a].display_name;
             var db = data.kernelspecs[b].display_name;
             if (da === db) {
                 return 0;
             } else if (da > db) {
                 return 1;
             } else {
                 return -1;
             }
         });
         for (var i = 0; i < keys.length; i++) {
             var ks = this.kernelspecs[keys[i]];
             var li = $("<li>")
                 .attr("id", "kernel-" +ks.name)
                 .data('kernelspec', ks).append(
                     $('<a>').attr('href', '#').append($('<i>')
                         .addClass('kernel-menu-icon fa')
                         .attr('href', '#')
                         .click($.proxy(this.select_kernel, this, ks.name))
                     ).append($('<span>')
                         .attr('href', '#')
                         .click($.proxy(this.new_notebook, this, ks.name))
                         .text(ks.display_name)
                         .attr('title', 'Create a new notebook with ' + ks.display_name)
                     )
             );
             menu.append(li);
         }
-        this._load_default_kernelspec(data['default']);
+        this.config.loaded.then(function () {
+            that._load_default_kernelspec(data['default']);
+        });
     };
     
     NewNotebookWidget.prototype._load_default_kernelspec = function (default_name) {
         /** load default kernelspec name from localStorage, if defined */
-        this.select_kernel(localStorage.default_kernel_name || default_name);
+        if (this.config.data.NewNotebookWidget &&
+            this.config.data.NewNotebookWidget.current_selection &&
+            this.kernelspecs[this.config.data.NewNotebookWidget.current_selection] !== undefined
+        ) {
+            default_name = this.config.data.NewNotebookWidget.current_selection;
+        }
+        this.select_kernel(default_name);
     };
 
     NewNotebookWidget.prototype.select_kernel = function (kernel_name) {
         /** select the current default kernel */
         this.current_selection = kernel_name;
+        this.config.update({
+            NewNotebookWidget: {
+                current_selection: kernel_name
+            }
+        });
         var spec = this.kernelspecs[kernel_name];
         var display_name;
         if (spec) {
             display_name = spec.display_name;
             localStorage.default_kernel_name = kernel_name;
             this.element.find("#current-kernel").text(display_name);
         } else {
             display_name = 'default kernel';
             delete localStorage.default_kernel_name;
         }
         this.element.find("#new_notebook").attr('title',
             'Create a new notebook with ' + display_name
         );
         this.element.find("li").map(function (i, li) {
             li = $(li);
             var ks = li.data('kernelspec');
             if (ks.name == kernel_name) {
                 li.find(".kernel-menu-icon")
                     .attr('title', display_name + ' is the default kernel')
                     .addClass("kernel-menu-icon-current");
             } else {
                 li.find(".kernel-menu-icon")
                     .attr('title', 'Make ' + ks.display_name + ' the default kernel')
                     .removeClass("kernel-menu-icon-current");
             }
         });
     };
     
     NewNotebookWidget.prototype.new_with_kernel = function (kernel_name) {
         /** record current selection and open a new notebook */
         this.new_notebook(kernel_name);
     };
     
     NewNotebookWidget.prototype.new_notebook = function (kernel_name) {
         /** create and open a new notebook */
         var that = this;
         kernel_name = kernel_name || this.current_selection;
         var w = window.open();
         this.contents.new_untitled(that.notebook_path, {type: "notebook"}).then(
             function (data) {
                 var url = utils.url_join_encode(
                     that.base_url, 'notebooks', data.path
                 );
                 if (kernel_name) {
                     url += "?kernel_name=" + kernel_name;
                 }
                 w.location = url;
             },
             function (error) {
                 w.close();
                 dialog.modal({
                     title : 'Creating Notebook Failed',
                     body : "The error was: " + error.message,
                     buttons : {'OK' : {'class' : 'btn-primary'}}
                 });
             }
         );
     };
     
     return {'NewNotebookWidget': NewNotebookWidget};
 });