allow kernel_name to be undefined in requests

fallback to KM.default_kernel_name in that case

IPython/html/services/sessions/handlers.py

@@ -1,112 +1,113 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
 
 
 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:
-            raise web.HTTPError(400, "Missing field in JSON data: kernel.name")
+            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:
             model = sm.create_session(name=name, path=path, kernel_name=kernel_name)
         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/services/sessions/sessionmanager.py

@@ -1,227 +1,211 b''
-"""A base class session manager.
+"""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
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import uuid
 import sqlite3
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.py3compat import unicode_type
 from IPython.utils.traitlets import Instance
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 
 class SessionManager(LoggingConfigurable):
 
     kernel_manager = Instance('IPython.html.services.kernels.kernelmanager.MappingKernelManager')
     contents_manager = Instance('IPython.html.services.contents.manager.ContentsManager', args=())
     
     # Session database initialized below
     _cursor = None
     _connection = None
     _columns = {'session_id', 'name', 'path', 'kernel_id'}
     
     @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 
                 (session_id, name, path, kernel_id)""")
         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 a 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:
             return True
 
     def new_session_id(self):
         "Create a uuid for a new session"
         return unicode_type(uuid.uuid4())
 
-    def create_session(self, name=None, path=None, kernel_name='python'):
+    def create_session(self, name=None, path=None, kernel_name=None):
         """Creates a session and returns its model"""
         session_id = self.new_session_id()
         # allow nbm to specify kernels cwd
         kernel_path = self.contents_manager.get_kernel_path(name=name, path=path)
         kernel_id = self.kernel_manager.start_kernel(path=kernel_path,
                                                      kernel_name=kernel_name)
         return self.save_session(session_id, name=name, path=path,
                                  kernel_id=kernel_id)
 
     def save_session(self, session_id, name=None, path=None, kernel_id=None):
         """Saves the items for the session with the given session_id
         
         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.
         
         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_id : str
             a uuid for the kernel associated with this session
         
         Returns
         -------
         model : dict
             a dictionary of the session model
         """
         self.cursor.execute("INSERT INTO session VALUES (?,?,?,?)",
             (session_id, name, path, kernel_id)
         )
         return self.get_session(session_id=session_id)
 
     def get_session(self, **kwargs):
         """Returns the model for a particular session.
         
         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_id)
 
         Returns
         -------
         model : dict
             returns a dictionary that includes all the information from the 
             session described by the kwarg.
         """
         if not kwargs:
             raise TypeError("must specify a column to query")
 
         conditions = []
         for column in kwargs.keys():
             if column not in self._columns:
                 raise TypeError("No such column: %r", column)
             conditions.append("%s=?" % column)
 
         query = "SELECT * FROM session WHERE %s" % (' AND '.join(conditions))
 
         self.cursor.execute(query, list(kwargs.values()))
         try:
             row = self.cursor.fetchone()
         except KeyError:
             # The kernel is missing, so the session just got deleted.
             row = None
 
         if row is None:
             q = []
             for key, value in kwargs.items():
                 q.append("%s=%r" % (key, value))
 
             raise web.HTTPError(404, u'Session not found: %s' % (', '.join(q)))
 
         return self.row_to_model(row)
 
     def update_session(self, session_id, **kwargs):
         """Updates the values in the session database.
         
         Changes the values of the session with the given session_id
         with the values from the keyword arguments. 
         
         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.
         """
         self.get_session(session_id=session_id)
 
         if not kwargs:
             # no changes
             return
 
         sets = []
         for column in kwargs.keys():
             if column not in self._columns:
                 raise TypeError("No such column: %r" % column)
             sets.append("%s=?" % column)
         query = "UPDATE session SET %s WHERE session_id=?" % (', '.join(sets))
         self.cursor.execute(query, list(kwargs.values()) + [session_id])
 
     def row_to_model(self, row):
         """Takes sqlite database session row and turns it into a dictionary"""
         if row['kernel_id'] not in self.kernel_manager:
             # The kernel was killed or died without deleting the session.
             # We can't use delete_session here because that tries to find
             # and shut down the kernel.
             self.cursor.execute("DELETE FROM session WHERE session_id=?", 
                                 (row['session_id'],))
             raise KeyError
 
         model = {
             'id': row['session_id'],
             'notebook': {
                 'name': row['name'],
                 'path': row['path']
             },
             'kernel': self.kernel_manager.kernel_model(row['kernel_id'])
         }
         return model
 
     def list_sessions(self):
         """Returns a list of dictionaries containing all the information from
         the session database"""
         c = self.cursor.execute("SELECT * FROM session")
         result = []
         # We need to use fetchall() here, because row_to_model can delete rows,
         # which messes up the cursor if we're iterating over rows.
         for row in c.fetchall():
             try:
                 result.append(self.row_to_model(row))
             except KeyError:
                 pass
         return result
 
     def delete_session(self, session_id):
         """Deletes the row in the session database with given session_id"""
         # Check that session exists before deleting
         session = self.get_session(session_id=session_id)
         self.kernel_manager.shutdown_kernel(session['kernel']['id'])
         self.cursor.execute("DELETE FROM session WHERE session_id=?", (session_id,))