session manager restructuring

Redid the sessionmanager, added tests for the session manager,
and added a sqlite database to hold kernel,session,nb mapping.

IPython/html/services/contents/tests/test_contentmanger.py

@@ -0,0 +1,12 b''
+"""Tests for the content manager."""
+
+import os
+from unittest import TestCase
+from tempfile import NamedTemporaryFile
+
+from IPython.utils.tempdir import TemporaryDirectory
+from IPython.utils.traitlets import TraitError
+
+from ..contentmanager import ContentManager
+
+#class TestContentManager(TestCase):

IPython/html/services/sessions/tests/test_sessionmanager.py

@@ -0,0 +1,86 b''
+"""Tests for the session manager."""
+
+import os
+
+from unittest import TestCase
+from tempfile import NamedTemporaryFile
+
+from IPython.utils.tempdir import TemporaryDirectory
+from IPython.utils.traitlets import TraitError
+
+from ..sessionmanager import SessionManager
+
+class TestSessionManager(TestCase):
+    
+    def test_get_session(self):
+        sm = SessionManager()
+        session_id = sm.get_session_id()
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel='5678')
+        model = sm.get_session(id=session_id)
+        expected = {'id':session_id, 'name':u'test.ipynb', 'path': u'/path/to/', 'kernel':{'id':u'5678', 'ws_url': u''}}
+        self.assertEqual(model, expected)
+
+    def test_bad_get_session(self):
+        # Should raise error if a bad key is passed to the database.
+        sm = SessionManager()
+        session_id = sm.get_session_id()
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel='5678')
+        self.assertRaises(TraitError, sm.get_session, bad_id=session_id) # Bad keyword
+
+    def test_list_sessions(self):
+        sm = SessionManager()
+        session_id1 = sm.get_session_id()
+        session_id2 = sm.get_session_id()
+        session_id3 = sm.get_session_id()
+        sm.save_session(session_id=session_id1, name='test1.ipynb', path='/path/to/1/', kernel='5678')
+        sm.save_session(session_id=session_id2, name='test2.ipynb', path='/path/to/2/', kernel='5678')
+        sm.save_session(session_id=session_id3, name='test3.ipynb', path='/path/to/3/', kernel='5678')
+        sessions = sm.list_sessions()
+        expected = [{'id':session_id1, 'name':u'test1.ipynb', 
+                    'path': u'/path/to/1/', 'kernel':{'id':u'5678', 'ws_url': u''}},
+                    {'id':session_id2, 'name':u'test2.ipynb', 
+                    'path': u'/path/to/2/', 'kernel':{'id':u'5678', 'ws_url': u''}},
+                    {'id':session_id3, 'name':u'test3.ipynb', 
+                    'path': u'/path/to/3/', 'kernel':{'id':u'5678', 'ws_url': u''}}]
+        self.assertEqual(sessions, expected)
+
+    def test_update_session(self):
+        sm = SessionManager()
+        session_id = sm.get_session_id()
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel=None)
+        sm.update_session(session_id, kernel='5678')
+        sm.update_session(session_id, name='new_name.ipynb')
+        model = sm.get_session(id=session_id)
+        expected = {'id':session_id, 'name':u'new_name.ipynb', 'path': u'/path/to/', 'kernel':{'id':u'5678', 'ws_url': u''}}
+        self.assertEqual(model, expected)
+    
+    def test_bad_update_session(self):
+        # try to update a session with a bad keyword ~ raise error
+        sm = SessionManager()
+        session_id = sm.get_session_id()
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel='5678')
+        self.assertRaises(TraitError, sm.update_session, session_id=session_id, bad_kw='test.ipynb') # Bad keyword
+
+    def test_delete_session(self):
+        sm = SessionManager()
+        session_id1 = sm.get_session_id()
+        session_id2 = sm.get_session_id()
+        session_id3 = sm.get_session_id()
+        sm.save_session(session_id=session_id1, name='test1.ipynb', path='/path/to/1/', kernel='5678')
+        sm.save_session(session_id=session_id2, name='test2.ipynb', path='/path/to/2/', kernel='5678')
+        sm.save_session(session_id=session_id3, name='test3.ipynb', path='/path/to/3/', kernel='5678')
+        sm.delete_session(session_id2)
+        sessions = sm.list_sessions()
+        expected = [{'id':session_id1, 'name':u'test1.ipynb', 
+                    'path': u'/path/to/1/', 'kernel':{'id':u'5678', 'ws_url': u''}},
+                    {'id':session_id3, 'name':u'test3.ipynb', 
+                    'path': u'/path/to/3/', 'kernel':{'id':u'5678', 'ws_url': u''}}]
+        self.assertEqual(sessions, expected)
+
+    def test_bad_delete_session(self):
+        # try to delete a session that doesn't exist ~ raise error
+        sm = SessionManager()
+        session_id = sm.get_session_id()
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel='5678')
+        self.assertRaises(TraitError, sm.delete_session, session_id='23424') # Bad keyword
+

IPython/html/services/kernels/kernelmanager.py

@@ -1,96 +1,95 b''
 """A kernel manager relating notebooks and kernels
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from tornado import web
 
 from IPython.kernel.multikernelmanager import MultiKernelManager
 from IPython.utils.traitlets import (
     Dict, List, Unicode,
 )
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 
 class MappingKernelManager(MultiKernelManager):
     """A KernelManager that handles notebook mapping and HTTP error handling"""
 
     def _kernel_manager_class_default(self):
         return "IPython.kernel.ioloop.IOLoopKernelManager"
 
     kernel_argv = List(Unicode)
     kernels = []
 
     #-------------------------------------------------------------------------
     # Methods for managing kernels and sessions
     #-------------------------------------------------------------------------
 
     def _handle_kernel_died(self, kernel_id):
         """notice that a kernel died"""
         self.log.warn("Kernel %s died, removing from map.", kernel_id)
         self.remove_kernel(kernel_id)
 
-    def start_kernel(self, **kwargs):
+    def start_kernel(self, kernel_id=None, **kwargs):
         """Start a kernel for a session an return its kernel_id.
 
         Parameters
         ----------
-        session_id : uuid
-            The uuid of the session to associate the new kernel with. If this
-            is not None, this kernel will be persistent whenever the session
-            requests a kernel.
+        kernel_id : uuid
+            The uuid to associate the new kernel with. If this
+            is not None, this kernel will be persistent whenever it is 
+            requested.
         """
-        kernel_id = None
         if kernel_id is None:
             kwargs['extra_arguments'] = self.kernel_argv
             kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs)
             self.log.info("Kernel started: %s" % kernel_id)
             self.log.debug("Kernel args: %r" % kwargs)
             # register callback for failed auto-restart
             self.add_restart_callback(kernel_id,
                 lambda : self._handle_kernel_died(kernel_id),
                 'dead',
             )
         else:
             self.log.info("Using existing kernel: %s" % kernel_id)
 
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         """Shutdown a kernel by kernel_id"""
         i = 0
         for kernel in self.kernels:
             if kernel['id'] == kernel_id:
                 del self.kernels[i]
             i = i+1
         super(MappingKernelManager, self).shutdown_kernel(kernel_id, now=now)
 
     def kernel_model(self, kernel_id, ws_url):
         model = {"id":kernel_id, "ws_url": ws_url}
         self.kernels.append(model)
         return model
 
     def list_kernels(self):
         return self.kernels
 
     # override _check_kernel_id to raise 404 instead of KeyError
     def _check_kernel_id(self, kernel_id):
         """Check a that a kernel_id exists and raise 404 if not."""
         if kernel_id not in self:
             raise web.HTTPError(404, u'Kernel does not exist: %s' % kernel_id)

IPython/html/services/sessions/handlers.py

@@ -1,104 +1,106 b''
 """Tornado handlers for the sessions web service.
 
 Authors:
 
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from tornado import web
 
 from zmq.utils import jsonapi
 
 from IPython.utils.jsonutil import date_default
 from ...base.handlers import IPythonHandler
 
 #-----------------------------------------------------------------------------
 # Session web service handlers
 #-----------------------------------------------------------------------------
 
 
-
 class SessionRootHandler(IPythonHandler):
 
     @web.authenticated
     def get(self):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         sessions = sm.list_sessions()
         self.finish(jsonapi.dumps(sessions))
 
     @web.authenticated
     def post(self):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         notebook_path = self.get_argument('notebook_path', default=None)
-        notebook_name, path = nbm.named_notebook_path(notebook_path)
-        session_id, model = sm.get_session(notebook_name, path)
-        if model == None:
-            kernel_id = km.start_kernel()
+        name, path = nbm.named_notebook_path(notebook_path)
+        if sm.session_exists(name=name, path=path):
+            model = sm.get_session(name=name, path=path)
+            kernel_id = model['kernel']['id']
+            km.start_kernel(kernel_id, cwd=nbm.notebook_dir)
+        else:
+            session_id = sm.get_session_id()
+            sm.save_session(session_id=session_id, name=name, path=path)
+            kernel_id = km.start_kernel(cwd=nbm.notebook_dir)
             kernel = km.kernel_model(kernel_id, self.ws_url)
-            model = sm.session_model(session_id, notebook_name, path, kernel)
+            sm.update_session(session_id, kernel=kernel_id)
+            model = sm.get_session(id=session_id)
+        self.set_header('Location', '{0}kernels/{1}'.format(self.base_kernel_url, kernel_id))
         self.finish(jsonapi.dumps(model))
 
 class SessionHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'PATCH', 'DELETE')
 
     @web.authenticated
     def get(self, session_id):
         sm = self.session_manager
-        model = sm.get_session_from_id(session_id)
+        model = sm.get_session(id=session_id)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def patch(self, session_id):
+        # Currently, this handler is strictly for renaming notebooks
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         notebook_path = self.request.body
-        notebook_name, path = nbm.named_notebook_path(notebook_path)
-        kernel_id = sm.get_kernel_from_session(session_id)
-        kernel = km.kernel_model(kernel_id, self.ws_url)
-        sm.delete_mapping_for_session(session_id)
-        model = sm.session_model(session_id, notebook_name, path, kernel)
+        name, path = nbm.named_notebook_path(notebook_path)
+        sm.update_session(id=session_id, name=name)
+        model = sm.get_session(id=session_id)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def delete(self, session_id):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
-        kernel_id = sm.get_kernel_from_session(session_id)
-        km.shutdown_kernel(kernel_id)
-        sm.delete_mapping_for_session(session_id)
+        session = sm.get_session(id=session_id)
+        sm.delete_session(session_id)        
+        km.shutdown_kernel(session['kernel']['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/services/sessions/sessionmanager.py

@@ -1,97 +1,170 b''
 """A base class session manager.
 
 Authors:
 
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import uuid
+import sqlite3
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.nbformat import current
 from IPython.utils.traitlets import List, Dict, Unicode, TraitError
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SessionManager(LoggingConfigurable):
     
-    # Use session_ids to map notebook names to kernel_ids
-    sessions = List()
+    # Session database initialized below
+    _cursor = None
+    _connection = None
     
-    def get_session(self, nb_name, nb_path=None):
-        """Get an existing session or create a new one"""
-        model = None
-        for session in self.sessions:
-            if session['name'] == nb_name and session['path'] == nb_path:
-                session_id = session['id']
-                model = session
-        if model != None:
-            return session_id, model
+    @property
+    def cursor(self):
+        """Start a cursor and create a database called 'session'"""
+        if self._cursor is None:
+            self._cursor = self.connection.cursor()
+            self._cursor.execute("""CREATE TABLE session 
+                (id, name, path, kernel)""")
+        return self._cursor
+
+    @property
+    def connection(self):
+        """Start a database connection"""
+        if self._connection is None:
+            self._connection = sqlite3.connect(':memory:')
+            self._connection.row_factory = sqlite3.Row
+        return self._connection
+        
+    def __del__(self):
+        """Close connection once SessionManager closes"""
+        self.cursor.close()
+
+    def session_exists(self, name, path):
+        """Check to see if the session for the given notebook exists"""
+        self.cursor.execute("SELECT * FROM session WHERE name=? AND path=?", (name,path))
+        reply = self.cursor.fetchone()
+        if reply is None:
+            return False
         else:
-            session_id = unicode(uuid.uuid4())
-            return session_id, model
-    
-    def session_model(self, session_id, notebook_name=None, notebook_path=None, kernel=None):
-        """ Create a session that links notebooks with kernels """
-        model = dict(id=session_id,
-                name=notebook_name, 
-                path=notebook_path, 
-                kernel=kernel)
-        if notebook_path == None:
-            model['path']=""
-        self.sessions.append(model)
-        return model
-    
-    def list_sessions(self):
-        """List all sessions and their information"""
-        return self.sessions
-    
-    def set_kernel_for_sessions(self, session_id, kernel_id):
-        """Maps the kernel_ids to the session_id in session_mapping"""
-        for session in self.sessions:
-            if session['id'] == session_id:
-                session['kernel']['id'] = kernel_id
-        return self.sessions
+            return True
+
+    def get_session_id(self):
+        "Create a uuid for a new session"
+        return unicode(uuid.uuid4())
+
+    def save_session(self, session_id, name=None, path=None, kernel=None):
+        """ Given a session_id (and any other of the arguments), this method
+        creates a row in the sqlite session database that holds the information
+        for a session.
         
-    def delete_mapping_for_session(self, session_id):
-        """Delete the session from session_mapping with the given session_id"""
-        i = 0
-        for session in self.sessions:
-            if session['id'] == session_id:
-                del self.sessions[i]
-            i = i + 1
-        return self.sessions
+        Parameters
+        ----------
+        session_id : str
+            uuid for the session; this method must be given a session_id
+        name : str
+            the .ipynb notebook name that started the session
+        path : str
+            the path to the named notebook
+        kernel : str
+            a uuid for the kernel associated with this session
+        """
+        self.cursor.execute("""INSERT INTO session VALUES 
+            (?,?,?,?)""", (session_id, name, path, kernel))
+        self.connection.commit()
+
+    def get_session(self, **kwargs):
+        """ Takes a keyword argument and searches for the value in the session
+        database, then returns the rest of the session's info.
+
+        Parameters
+        ----------
+        **kwargs : keyword argument
+            must be given one of the keywords and values from the session database
+            (i.e. session_id, name, path, kernel)
+
+        Returns
+        -------
+        model : dict
+            returns a dictionary that includes all the information from the 
+            session described by the kwarg.
+        """
+        column = kwargs.keys()[0] # uses only the first kwarg that is entered
+        value = kwargs.values()[0]
+        try:
+            self.cursor.execute("SELECT * FROM session WHERE %s=?" %column, (value,))
+        except sqlite3.OperationalError:
+            raise TraitError("The session database has no column: %s" %column)
+        reply = self.cursor.fetchone()
+        if reply is not None:
+            model = self.reply_to_dictionary_model(reply)
+        else:
+            model = None
+        return model
+
+    def update_session(self, session_id, **kwargs):
+        """Updates the values in the session with the given session_id
+        with the values from the keyword arguments. 
         
-    def get_session_from_id(self, session_id):
-        for session in self.sessions:
-            if session['id'] == session_id:
-                return session
-
-    def get_notebook_from_session(self, session_id):
-        """Returns the notebook_path for the given session_id"""
-        for session in self.sessions:
-            if session['id'] == session_id:
-                return session['name']
-    
-    def get_kernel_from_session(self, session_id):
-        """Returns the kernel_id for the given session_id"""
-        for session in self.sessions:
-            if session['id'] == session_id:
-                return session['kernel']['id']
+        Parameters
+        ----------
+        session_id : str
+            a uuid that identifies a session in the sqlite3 database
+        **kwargs : str
+            the key must correspond to a column title in session database,
+            and the value replaces the current value in the session 
+            with session_id.
+        """
+        column = kwargs.keys()[0] # uses only the first kwarg that is entered
+        value = kwargs.values()[0]
+        try:
+            self.cursor.execute("UPDATE session SET %s=? WHERE id=?" %column, (value, session_id))
+            self.connection.commit()
+        except sqlite3.OperationalError:
+            raise TraitError("No session exists with ID: %s" %session_id)
+
+    def reply_to_dictionary_model(self, reply):
+        """Takes sqlite database session row and turns it into a dictionary"""
+        model = {'id': reply['id'],
+                'name' : reply['name'],
+                'path' : reply['path'],
+                'kernel' : {'id':reply['kernel'], 'ws_url': ''}}
+        return model
         
+    def list_sessions(self):
+        """Returns a list of dictionaries containing all the information from
+        the session database"""
+        session_list=[]
+        self.cursor.execute("SELECT * FROM session")
+        sessions = self.cursor.fetchall()
+        for session in sessions:
+            model = self.reply_to_dictionary_model(session)
+            session_list.append(model)
+        return session_list
+
+    def delete_session(self, session_id):
+        """Deletes the row in the session database with given session_id"""
+        # Check that session exists before deleting
+        model = self.get_session(id=session_id)
+        if model is None:
+            raise TraitError("The session does not exist: %s" %session_id)
+        else: 
+            self.cursor.execute("DELETE FROM session WHERE id=?", (session_id,))
+            self.connection.commit()
  No newline at end of file

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

@@ -1,527 +1,525 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Kernel
 //============================================================================
 
 /**
  * @module IPython
  * @namespace IPython
  * @submodule Kernel
  */
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     // Initialization and connection.
     /**
      * A Kernel Class to communicate with the Python kernel
      * @Class Kernel
      */
-    var Kernel = function (base_url, session_id) {
+    var Kernel = function (base_url) {
         this.kernel_id = null;
-        this.session_id = session_id
         this.shell_channel = null;
         this.iopub_channel = null;
         this.stdin_channel = null;
         this.base_url = base_url;
         this.running = false;
-        this.username = "username";
-        this.base_session_id = utils.uuid();
+        this.username= "username";
+        this.session_id = utils.uuid();
         this._msg_callbacks = {};
 
         if (typeof(WebSocket) !== 'undefined') {
             this.WebSocket = WebSocket;
         } else if (typeof(MozWebSocket) !== 'undefined') {
             this.WebSocket = MozWebSocket;
         } else {
             alert('Your browser does not have WebSocket support, please try Chrome, Safari or Firefox ≥ 6. Firefox 4 and 5 are also supported by you have to enable WebSockets in about:config.');
         };
         this.bind_events();
     };
 
 
     Kernel.prototype._get_msg = function (msg_type, content) {
         var msg = {
             header : {
                 msg_id : utils.uuid(),
                 username : this.username,
-                session : this.base_session_id,
+                session : this.session_id,
                 msg_type : msg_type
             },
             metadata : {},
             content : content,
             parent_header : {}
         };
         return msg;
     };
     
     Kernel.prototype.bind_events = function() {
         var that = this;
         $([IPython.events]).on('send_input_reply.Kernel', function(evt, data) { 
             that.send_input_reply(data);
         });
     }
 
     /**
      * Start the Python kernel
      * @method start
      */
      Kernel.prototype.start = function (params) {
          var that = this;
          params = params || {};
-         params.session = this.session_id;
          if (!this.running) {
              var qs = $.param(params);
              var url = this.base_url + '?' + qs;
              $.post(url,
                  $.proxy(that._kernel_started,that),
                  'json'
              );
          };
      };
 
     /**
      * Restart the python kernel.
      *
      * Emit a 'status_restarting.Kernel' event with
      * the current object as parameter
      *
      * @method restart
      */
     Kernel.prototype.restart = function () {
         $([IPython.events]).trigger('status_restarting.Kernel', {kernel: this});
         var that = this;
         if (this.running) {
             this.stop_channels();
             var url = this.kernel_url + "/restart";
             $.post(url,
                 $.proxy(that._kernel_started, that),
                 'json'
             );
         };
     };
 
 
     Kernel.prototype._kernel_started = function (json) {
         console.log("Kernel started: ", json.id);
         this.running = true;
         this.kernel_id = json.id;
         var ws_url = json.ws_url;
         if (ws_url.match(/wss?:\/\//) == null) {
             // trailing 's' in https will become wss for secure web sockets
             prot = location.protocol.replace('http', 'ws') + "//";
             ws_url = prot + location.host + ws_url;
         };
         this.ws_url = ws_url;
         this.kernel_url = this.base_url + "/" + this.kernel_id;
         this.start_channels();
     };
 
 
     Kernel.prototype._websocket_closed = function(ws_url, early) {
         this.stop_channels();
         $([IPython.events]).trigger('websocket_closed.Kernel', 
             {ws_url: ws_url, kernel: this, early: early}
         );
     };
 
     /**
      * Start the `shell`and `iopub` channels.
      * Will stop and restart them if they already exist.
      *
      * @method start_channels
      */
     Kernel.prototype.start_channels = function () {
         var that = this;
         this.stop_channels();
         var ws_url = this.ws_url + this.kernel_url;
         console.log("Starting WebSockets:", ws_url);
         this.shell_channel = new this.WebSocket(ws_url + "/shell");
         this.stdin_channel = new this.WebSocket(ws_url + "/stdin");
         this.iopub_channel = new this.WebSocket(ws_url + "/iopub");
         
         var already_called_onclose = false; // only alert once
         var ws_closed_early = function(evt){
             if (already_called_onclose){
                 return;
             }
             already_called_onclose = true;
             if ( ! evt.wasClean ){
                 that._websocket_closed(ws_url, true);
             }
         };
         var ws_closed_late = function(evt){
             if (already_called_onclose){
                 return;
             }
             already_called_onclose = true;
             if ( ! evt.wasClean ){
                 that._websocket_closed(ws_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;
         }
         // switch from early-close to late-close message after 1s
         setTimeout(function() {
             for (var i=0; i < channels.length; i++) {
                 if (channels[i] !== null) {
                     channels[i].onclose = ws_closed_late;
                 }
             }
         }, 1000);
         this.shell_channel.onmessage = $.proxy(this._handle_shell_reply, this);
         this.iopub_channel.onmessage = $.proxy(this._handle_iopub_reply, this);
         this.stdin_channel.onmessage = $.proxy(this._handle_input_request, this);
     };
 
     /**
      * Handle a websocket entering the open state
      * sends session and cookie authentication info as first message.
      * Once all sockets are open, signal the Kernel.status_started event.
      * @method _ws_opened
      */
     Kernel.prototype._ws_opened = function (evt) {
         // send the session id so the Session object Python-side
         // has the same identity
         evt.target.send(this.session_id + ':' + document.cookie);
         
         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;
         }
         // all events ready, trigger started event.
         $([IPython.events]).trigger('status_started.Kernel', {kernel: this});
     };
     
     /**
      * Stop the websocket channels.
      * @method stop_channels
      */
     Kernel.prototype.stop_channels = function () {
         var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel];
         for (var i=0; i < channels.length; i++) {
             if ( channels[i] !== null ) {
                 channels[i].onclose = function (evt) {};
                 channels[i].close();
             }
         };
         this.shell_channel = this.iopub_channel = this.stdin_channel = null;
     };
 
     // Main public methods.
 
     /**
      * Get info on object asynchronoulsy
      *
      * @async
      * @param objname {string}
      * @param callback {dict}
      * @method object_info_request
      *
      * @example
      *
      * When calling this method pass a callbacks structure of the form:
      *
      *     callbacks = {
      *      'object_info_reply': object_info_reply_callback
      *     }
      *
      * The `object_info_reply_callback` will be passed the content object of the
      *
      * `object_into_reply` message documented in
      * [IPython dev documentation](http://ipython.org/ipython-doc/dev/development/messaging.html#object-information)
      */
     Kernel.prototype.object_info_request = function (objname, callbacks) {
         if(typeof(objname)!=null && objname!=null)
         {
             var content = {
                 oname : objname.toString(),
                 detail_level : 0,
             };
             var msg = this._get_msg("object_info_request", content);
             this.shell_channel.send(JSON.stringify(msg));
             this.set_callbacks_for_msg(msg.header.msg_id, callbacks);
             return msg.header.msg_id;
         }
         return;
     }
 
     /**
      * Execute given code into kernel, and pass result to callback.
      *
      * TODO: document input_request in callbacks
      *
      * @async
      * @method execute
      * @param {string} code
      * @param [callbacks] {Object} With the optional following keys
      *      @param callbacks.'execute_reply' {function}
      *      @param callbacks.'output' {function}
      *      @param callbacks.'clear_output' {function}
      *      @param callbacks.'set_next_input' {function}
      * @param {object} [options]
      *      @param [options.silent=false] {Boolean}
      *      @param [options.user_expressions=empty_dict] {Dict}
      *      @param [options.user_variables=empty_list] {List od Strings}
      *      @param [options.allow_stdin=false] {Boolean} true|false
      *
      * @example
      *
      * The options object should contain the options for the execute call. Its default
      * values are:
      *
      *      options = {
      *        silent : true,
      *        user_variables : [],
      *        user_expressions : {},
      *        allow_stdin : false
      *      }
      *
      * When calling this method pass a callbacks structure of the form:
      *
      *      callbacks = {
      *       'execute_reply': execute_reply_callback,
      *       'output': output_callback,
      *       'clear_output': clear_output_callback,
      *       'set_next_input': set_next_input_callback
      *      }
      *
      * The `execute_reply_callback` will be passed the content and metadata
      * objects of the `execute_reply` message documented
      * [here](http://ipython.org/ipython-doc/dev/development/messaging.html#execute)
      *
      * The `output_callback` will be passed `msg_type` ('stream','display_data','pyout','pyerr')
      * of the output and the content and metadata objects of the PUB/SUB channel that contains the
      * output:
      *
      * http://ipython.org/ipython-doc/dev/development/messaging.html#messages-on-the-pub-sub-socket
      *
      * The `clear_output_callback` will be passed a content object that contains
      * stdout, stderr and other fields that are booleans, as well as the metadata object.
      *
      * The `set_next_input_callback` will be passed the text that should become the next
      * input cell.
      */
     Kernel.prototype.execute = function (code, callbacks, options) {
 
         var content = {
             code : code,
             silent : true,
             store_history : false,
             user_variables : [],
             user_expressions : {},
             allow_stdin : false
         };
         callbacks = callbacks || {};
         if (callbacks.input_request !== undefined) {
             content.allow_stdin = true;
         }
         $.extend(true, content, options)
         $([IPython.events]).trigger('execution_request.Kernel', {kernel: this, content:content});
         var msg = this._get_msg("execute_request", content);
         this.shell_channel.send(JSON.stringify(msg));
         this.set_callbacks_for_msg(msg.header.msg_id, callbacks);
         return msg.header.msg_id;
     };
 
     /**
      * When calling this method pass a callbacks structure of the form:
      *
      *      callbacks = {
      *       'complete_reply': complete_reply_callback
      *      }
      *
      * The `complete_reply_callback` will be passed the content object of the
      * `complete_reply` message documented
      * [here](http://ipython.org/ipython-doc/dev/development/messaging.html#complete)
      *
      * @method complete
      * @param line {integer}
      * @param cursor_pos {integer}
      * @param {dict} callbacks
      *      @param callbacks.complete_reply {function} `complete_reply_callback`
      *
      */
     Kernel.prototype.complete = function (line, cursor_pos, callbacks) {
         callbacks = callbacks || {};
         var content = {
             text : '',
             line : line,
             block : null,
             cursor_pos : cursor_pos
         };
         var msg = this._get_msg("complete_request", content);
         this.shell_channel.send(JSON.stringify(msg));
         this.set_callbacks_for_msg(msg.header.msg_id, callbacks);
         return msg.header.msg_id;
     };
 
 
     Kernel.prototype.interrupt = function () {
         if (this.running) {
             $([IPython.events]).trigger('status_interrupting.Kernel', {kernel: this});
             $.post(this.kernel_url + "/interrupt");
         };
     };
 
 
     Kernel.prototype.kill = function () {
         if (this.running) {
             this.running = false;
             var settings = {
                 cache : false,
                 type : "DELETE"
             };
             $.ajax(this.kernel_url, settings);
         };
     };
 
     Kernel.prototype.send_input_reply = function (input) {
         var content = {
             value : input,
         };
         $([IPython.events]).trigger('input_reply.Kernel', {kernel: this, content:content});
         var msg = this._get_msg("input_reply", content);
         this.stdin_channel.send(JSON.stringify(msg));
         return msg.header.msg_id;
     };
 
 
     // Reply handlers
 
     Kernel.prototype.get_callbacks_for_msg = function (msg_id) {
         var callbacks = this._msg_callbacks[msg_id];
         return callbacks;
     };
 
 
     Kernel.prototype.clear_callbacks_for_msg = function (msg_id) {
         if (this._msg_callbacks[msg_id] !== undefined ) {
             delete this._msg_callbacks[msg_id];
         }
     };
 
 
     Kernel.prototype.set_callbacks_for_msg = function (msg_id, callbacks) {
         this._msg_callbacks[msg_id] = callbacks || {};
     };
 
 
     Kernel.prototype._handle_shell_reply = function (e) {
         var reply = $.parseJSON(e.data);
         $([IPython.events]).trigger('shell_reply.Kernel', {kernel: this, reply:reply});
         var header = reply.header;
         var content = reply.content;
         var metadata = reply.metadata;
         var msg_type = header.msg_type;
         var callbacks = this.get_callbacks_for_msg(reply.parent_header.msg_id);
         if (callbacks !== undefined) {
             var cb = callbacks[msg_type];
             if (cb !== undefined) {
                 cb(content, metadata);
             }
         };
 
         if (content.payload !== undefined) {
             var payload = content.payload || [];
             this._handle_payload(callbacks, payload);
         }
     };
 
 
     Kernel.prototype._handle_payload = function (callbacks, payload) {
         var l = payload.length;
         // Payloads are handled by triggering events because we don't want the Kernel
         // to depend on the Notebook or Pager classes.
         for (var i=0; i<l; i++) {
             if (payload[i].source === 'page') {
                 var data = {'text':payload[i].text}
                 $([IPython.events]).trigger('open_with_text.Pager', data);
             } else if (payload[i].source === 'set_next_input') {
                 if (callbacks.set_next_input !== undefined) {
                     callbacks.set_next_input(payload[i].text)
                 }
             }
         };
     };
 
 
     Kernel.prototype._handle_iopub_reply = function (e) {
         var reply = $.parseJSON(e.data);
         var content = reply.content;
         var msg_type = reply.header.msg_type;
         var metadata = reply.metadata;
         var callbacks = this.get_callbacks_for_msg(reply.parent_header.msg_id);
         if (msg_type !== 'status' && callbacks === undefined) {
             // Message not from one of this notebook's cells and there are no
             // callbacks to handle it.
             return;
         }
         var output_types = ['stream','display_data','pyout','pyerr'];
         if (output_types.indexOf(msg_type) >= 0) {
             var cb = callbacks['output'];
             if (cb !== undefined) {
                 cb(msg_type, content, metadata);
             }
         } else if (msg_type === 'status') {
             if (content.execution_state === 'busy') {
                 $([IPython.events]).trigger('status_busy.Kernel', {kernel: this});
             } else if (content.execution_state === 'idle') {
                 $([IPython.events]).trigger('status_idle.Kernel', {kernel: this});
             } else if (content.execution_state === 'restarting') {
                 // autorestarting is distinct from restarting,
                 // in that it means the kernel died and the server is restarting it.
                 // status_restarting sets the notification widget,
                 // autorestart shows the more prominent dialog.
                 $([IPython.events]).trigger('status_autorestarting.Kernel', {kernel: this});
                 $([IPython.events]).trigger('status_restarting.Kernel', {kernel: this});
             } else if (content.execution_state === 'dead') {
                 this.stop_channels();
                 $([IPython.events]).trigger('status_dead.Kernel', {kernel: this});
             };
         } else if (msg_type === 'clear_output') {
             var cb = callbacks['clear_output'];
             if (cb !== undefined) {
                 cb(content, metadata);
             }
         };
     };
 
 
     Kernel.prototype._handle_input_request = function (e) {
         var request = $.parseJSON(e.data);
         var header = request.header;
         var content = request.content;
         var metadata = request.metadata;
         var msg_type = header.msg_type;
         if (msg_type !== 'input_request') {
             console.log("Invalid input request!", request);
             return;
         }
         var callbacks = this.get_callbacks_for_msg(request.parent_header.msg_id);
         if (callbacks !== undefined) {
             var cb = callbacks[msg_type];
             if (cb !== undefined) {
                 cb(content, metadata);
             }
         };
     };
 
 
     IPython.Kernel = Kernel;
 
     return IPython;
 
 }(IPython));
 

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

@@ -1,96 +1,95 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Notebook
 //============================================================================
 
 var IPython = (function (IPython) {
     
     var Session = function(notebook_path, Notebook){
         this.kernel = null;
         this.kernel_id = null;
         this.session_id = null;
         this.notebook_path = notebook_path;
         this.notebook = Notebook;
         this._baseProjectUrl = Notebook.baseProjectUrl() 
     };
     
     Session.prototype.start = function(){
         var that = this
         var qs = $.param({notebook_path:this.notebook_path});
         var url = '/api/sessions' + '?' + qs;
         $.post(url, 
             $.proxy(this.start_kernel, that),
             'json'
         );
     };
     
     Session.prototype.notebook_rename = function (notebook_path) {
         this.notebook_path = notebook_path;
         var settings = {
             processData : false,
             cache : false,
             type : "PATCH",
             data: notebook_path,
             dataType : "json",
         };
         var url = this._baseProjectUrl + 'api/sessions/' + this.session_id;
         $.ajax(url, settings);
     }
     
     
     Session.prototype.delete_session = function() {
         var settings = {
             processData : false,
             cache : false,
             type : "DELETE",
             dataType : "json",
         };
         var url = this._baseProjectUrl + 'api/sessions/' + this.session_id;
         $.ajax(url, settings);
     };
     
     // Kernel related things
     /**
      * Start a new kernel and set it on each code cell.
      * 
      * @method start_kernel
      */
     Session.prototype.start_kernel = function (json) {
         this.session_id = json.id;
         this.kernel_content = json.kernel;
         var base_url = $('body').data('baseKernelUrl') + "api/kernels";
         this.kernel = new IPython.Kernel(base_url, this.session_id);
-        // Now that the kernel has been created, tell the CodeCells about it.
         this.kernel._kernel_started(this.kernel_content);
     };
     
     /**
      * 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();        
     };
     
     IPython.Session = Session;
 
 
     return IPython;
 
 }(IPython));