changes after session manager code review

IPython/html/base/handlers.py

@@ -1,457 +1,476 b''
 """Base Tornado handlers for the notebook.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 
 import datetime
 import email.utils
 import functools
 import hashlib
 import json
 import logging
 import mimetypes
 import os
 import stat
 import sys
 import threading
+import traceback
 
 from tornado import web
 from tornado import websocket
 
 try:
     from tornado.log import app_log
 except ImportError:
     app_log = logging.getLogger()
 
 from IPython.config import Application
 from IPython.external.decorator import decorator
 from IPython.utils.path import filefind
 from IPython.utils.jsonutil import date_default
 
 #-----------------------------------------------------------------------------
 # Monkeypatch for Tornado <= 2.1.1 - Remove when no longer necessary!
 #-----------------------------------------------------------------------------
 
 # Google Chrome, as of release 16, changed its websocket protocol number.  The
 # parts tornado cares about haven't really changed, so it's OK to continue
 # accepting Chrome connections, but as of Tornado 2.1.1 (the currently released
 # version as of Oct 30/2011) the version check fails, see the issue report:
 
 # https://github.com/facebook/tornado/issues/385
 
 # This issue has been fixed in Tornado post 2.1.1:
 
 # https://github.com/facebook/tornado/commit/84d7b458f956727c3b0d6710
 
 # Here we manually apply the same patch as above so that users of IPython can
 # continue to work with an officially released Tornado.  We make the
 # monkeypatch version check as narrow as possible to limit its effects; once
 # Tornado 2.1.1 is no longer found in the wild we'll delete this code.
 
 import tornado
 
 if tornado.version_info <= (2,1,1):
 
     def _execute(self, transforms, *args, **kwargs):
         from tornado.websocket import WebSocketProtocol8, WebSocketProtocol76
         
         self.open_args = args
         self.open_kwargs = kwargs
 
         # The difference between version 8 and 13 is that in 8 the
         # client sends a "Sec-Websocket-Origin" header and in 13 it's
         # simply "Origin".
         if self.request.headers.get("Sec-WebSocket-Version") in ("7", "8", "13"):
             self.ws_connection = WebSocketProtocol8(self)
             self.ws_connection.accept_connection()
             
         elif self.request.headers.get("Sec-WebSocket-Version"):
             self.stream.write(tornado.escape.utf8(
                 "HTTP/1.1 426 Upgrade Required\r\n"
                 "Sec-WebSocket-Version: 8\r\n\r\n"))
             self.stream.close()
             
         else:
             self.ws_connection = WebSocketProtocol76(self)
             self.ws_connection.accept_connection()
 
     websocket.WebSocketHandler._execute = _execute
     del _execute
 
 
 #-----------------------------------------------------------------------------
 # Top-level handlers
 #-----------------------------------------------------------------------------
 
 class RequestHandler(web.RequestHandler):
     """RequestHandler with default variable setting."""
 
     def render(*args, **kwargs):
         kwargs.setdefault('message', '')
         return web.RequestHandler.render(*args, **kwargs)
 
 class AuthenticatedHandler(RequestHandler):
     """A RequestHandler with an authenticated user."""
 
     def clear_login_cookie(self):
         self.clear_cookie(self.cookie_name)
     
     def get_current_user(self):
         user_id = self.get_secure_cookie(self.cookie_name)
         # For now the user_id should not return empty, but it could eventually
         if user_id == '':
             user_id = 'anonymous'
         if user_id is None:
             # prevent extra Invalid cookie sig warnings:
             self.clear_login_cookie()
             if not self.login_available:
                 user_id = 'anonymous'
         return user_id
 
     @property
     def cookie_name(self):
         default_cookie_name = 'username-{host}'.format(
             host=self.request.host,
         ).replace(':', '-')
         return self.settings.get('cookie_name', default_cookie_name)
     
     @property
     def password(self):
         """our password"""
         return self.settings.get('password', '')
     
     @property
     def logged_in(self):
         """Is a user currently logged in?
 
         """
         user = self.get_current_user()
         return (user and not user == 'anonymous')
 
     @property
     def login_available(self):
         """May a user proceed to log in?
 
         This returns True if login capability is available, irrespective of
         whether the user is already logged in or not.
 
         """
         return bool(self.settings.get('password', ''))
 
 
 class IPythonHandler(AuthenticatedHandler):
     """IPython-specific extensions to authenticated handling
     
     Mostly property shortcuts to IPython-specific settings.
     """
     
     @property
     def config(self):
         return self.settings.get('config', None)
     
     @property
     def log(self):
         """use the IPython log by default, falling back on tornado's logger"""
         if Application.initialized():
             return Application.instance().log
         else:
             return app_log
     
     @property
     def use_less(self):
         """Use less instead of css in templates"""
         return self.settings.get('use_less', False)
     
     #---------------------------------------------------------------
     # URLs
     #---------------------------------------------------------------
     
     @property
     def ws_url(self):
         """websocket url matching the current request
 
         By default, this is just `''`, indicating that it should match
         the same host, protocol, port, etc.
         """
         return self.settings.get('websocket_url', '')
     
     @property
     def mathjax_url(self):
         return self.settings.get('mathjax_url', '')
     
     @property
     def base_project_url(self):
         return self.settings.get('base_project_url', '/')
     
     @property
     def base_kernel_url(self):
         return self.settings.get('base_kernel_url', '/')
     
     #---------------------------------------------------------------
     # Manager objects
     #---------------------------------------------------------------
     
     @property
     def kernel_manager(self):
         return self.settings['kernel_manager']
 
     @property
     def notebook_manager(self):
         return self.settings['notebook_manager']
     
     @property
     def cluster_manager(self):
         return self.settings['cluster_manager']
     
     @property
     def session_manager(self):
         return self.settings['session_manager']
     
     @property
     def project_dir(self):
         return self.notebook_manager.notebook_dir
     
     #---------------------------------------------------------------
     # template rendering
     #---------------------------------------------------------------
     
     def get_template(self, name):
         """Return the jinja template object for a given name"""
         return self.settings['jinja2_env'].get_template(name)
     
     def render_template(self, name, **ns):
         ns.update(self.template_namespace)
         template = self.get_template(name)
         return template.render(**ns)
     
     @property
     def template_namespace(self):
         return dict(
             base_project_url=self.base_project_url,
             base_kernel_url=self.base_kernel_url,
             logged_in=self.logged_in,
             login_available=self.login_available,
             use_less=self.use_less,
         )
 
+    def get_json_body(self):
+        """Return the body of the request as JSON data."""
+        if not self.request.body:
+            return None
+        # Do we need to call body.decode('utf-8') here?
+        body = self.request.body.strip().decode(u'utf-8')
+        try:
+            model = json.loads(body)
+        except:
+            raise web.HTTPError(400, u'Invalid JSON in body of request')
+        return model
 
 class AuthenticatedFileHandler(IPythonHandler, web.StaticFileHandler):
     """static files should only be accessible when logged in"""
 
     @web.authenticated
     def get(self, path):
         return web.StaticFileHandler.get(self, path)
 
 
 def json_errors(method):
     """Decorate methods with this to return GitHub style JSON errors.
     
     This should be used on any handler method that can raise HTTPErrors.
     
     This will grab the latest HTTPError exception using sys.exc_info
     and then:
     
     1. Set the HTTP status code based on the HTTPError
     2. Create and return a JSON body with a message field describing
        the error in a human readable form.
     """
     @functools.wraps(method)
     def wrapper(self, *args, **kwargs):
         try:
             result = method(self, *args, **kwargs)
         except:
             t, value, tb = sys.exc_info()
             if isinstance(value, web.HTTPError):
                 status = value.status_code
                 message = value.log_message
             else:
                 status = 400
                 message = u"Unknown server error"
             self.set_status(status)
-            reply = dict(message=message)
+            tb_text = ''.join(traceback.format_exception(t, value, tb))
+            reply = dict(message=message, traceback=tb_text)
             self.finish(json.dumps(reply, default=date_default))
         else:
             return result
     return wrapper
 
 
 
 #-----------------------------------------------------------------------------
 # File handler
 #-----------------------------------------------------------------------------
 
 # to minimize subclass changes:
 HTTPError = web.HTTPError
 
 class FileFindHandler(web.StaticFileHandler):
     """subclass of StaticFileHandler for serving files from a search path"""
     
     _static_paths = {}
     # _lock is needed for tornado < 2.2.0 compat
     _lock = threading.Lock()  # protects _static_hashes
     
     def initialize(self, path, default_filename=None):
         if isinstance(path, basestring):
             path = [path]
         self.roots = tuple(
             os.path.abspath(os.path.expanduser(p)) + os.path.sep for p in path
         )
         self.default_filename = default_filename
     
     @classmethod
     def locate_file(cls, path, roots):
         """locate a file to serve on our static file search path"""
         with cls._lock:
             if path in cls._static_paths:
                 return cls._static_paths[path]
             try:
                 abspath = os.path.abspath(filefind(path, roots))
             except IOError:
                 # empty string should always give exists=False
                 return ''
         
             # os.path.abspath strips a trailing /
             # it needs to be temporarily added back for requests to root/
             if not (abspath + os.path.sep).startswith(roots):
                 raise HTTPError(403, "%s is not in root static directory", path)
         
             cls._static_paths[path] = abspath
             return abspath
     
     def get(self, path, include_body=True):
         path = self.parse_url_path(path)
         
         # begin subclass override
         abspath = self.locate_file(path, self.roots)
         # end subclass override
         
         if os.path.isdir(abspath) and self.default_filename is not None:
             # need to look at the request.path here for when path is empty
             # but there is some prefix to the path that was already
             # trimmed by the routing
             if not self.request.path.endswith("/"):
                 self.redirect(self.request.path + "/")
                 return
             abspath = os.path.join(abspath, self.default_filename)
         if not os.path.exists(abspath):
             raise HTTPError(404)
         if not os.path.isfile(abspath):
             raise HTTPError(403, "%s is not a file", path)
 
         stat_result = os.stat(abspath)
         modified = datetime.datetime.utcfromtimestamp(stat_result[stat.ST_MTIME])
 
         self.set_header("Last-Modified", modified)
 
         mime_type, encoding = mimetypes.guess_type(abspath)
         if mime_type:
             self.set_header("Content-Type", mime_type)
 
         cache_time = self.get_cache_time(path, modified, mime_type)
 
         if cache_time > 0:
             self.set_header("Expires", datetime.datetime.utcnow() + \
                                        datetime.timedelta(seconds=cache_time))
             self.set_header("Cache-Control", "max-age=" + str(cache_time))
         else:
             self.set_header("Cache-Control", "public")
 
         self.set_extra_headers(path)
 
         # Check the If-Modified-Since, and don't send the result if the
         # content has not been modified
         ims_value = self.request.headers.get("If-Modified-Since")
         if ims_value is not None:
             date_tuple = email.utils.parsedate(ims_value)
             if_since = datetime.datetime(*date_tuple[:6])
             if if_since >= modified:
                 self.set_status(304)
                 return
+        
+        if os.path.splitext(path)[1] == '.ipynb':
+            raise HTTPError(404, 'HAHA')
+            name = os.path.splitext(os.path.split(path))[0]
+            self.set_header('Content-Type', 'application/json')
+            self.set_header('Content-Disposition','attachment; filename="%s.ipynb"' % name)
 
         with open(abspath, "rb") as file:
             data = file.read()
             hasher = hashlib.sha1()
             hasher.update(data)
             self.set_header("Etag", '"%s"' % hasher.hexdigest())
             if include_body:
                 self.write(data)
             else:
                 assert self.request.method == "HEAD"
                 self.set_header("Content-Length", len(data))
 
     @classmethod
     def get_version(cls, settings, path):
         """Generate the version string to be used in static URLs.
 
         This method may be overridden in subclasses (but note that it
         is a class method rather than a static method).  The default
         implementation uses a hash of the file's contents.
 
         ``settings`` is the `Application.settings` dictionary and ``path``
         is the relative location of the requested asset on the filesystem.
         The returned value should be a string, or ``None`` if no version
         could be determined.
         """
         # begin subclass override:
         static_paths = settings['static_path']
         if isinstance(static_paths, basestring):
             static_paths = [static_paths]
         roots = tuple(
             os.path.abspath(os.path.expanduser(p)) + os.path.sep for p in static_paths
         )
 
         try:
             abs_path = filefind(path, roots)
         except IOError:
             app_log.error("Could not find static file %r", path)
             return None
         
         # end subclass override
         
         with cls._lock:
             hashes = cls._static_hashes
             if abs_path not in hashes:
                 try:
                     f = open(abs_path, "rb")
                     hashes[abs_path] = hashlib.md5(f.read()).hexdigest()
                     f.close()
                 except Exception:
                     app_log.error("Could not open static file %r", path)
                     hashes[abs_path] = None
             hsh = hashes.get(abs_path)
             if hsh:
                 return hsh[:5]
         return None
 
 
     def parse_url_path(self, url_path):
         """Converts a static URL path into a filesystem path.
 
         ``url_path`` is the path component of the URL with
         ``static_url_prefix`` removed.  The return value should be
         filesystem path relative to ``static_path``.
         """
         if os.path.sep != "/":
             url_path = url_path.replace("/", os.path.sep)
         return url_path
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 default_handlers = []

IPython/html/services/sessions/handlers.py

@@ -1,115 +1,125 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
+import json
 
+from tornado import web
 from IPython.utils.jsonutil import date_default
-from ...base.handlers import IPythonHandler
+from ...base.handlers import IPythonHandler, json_errors
 
 #-----------------------------------------------------------------------------
 # Session web service handlers
 #-----------------------------------------------------------------------------
 
 
 class SessionRootHandler(IPythonHandler):
 
     @web.authenticated
+    @json_errors
     def get(self):
         # Return a list of running sessions
         sm = self.session_manager
-        nbm = self.notebook_manager
-        km = self.kernel_manager
         sessions = sm.list_sessions()
-        self.finish(jsonapi.dumps(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
         nbm = self.notebook_manager
         km = self.kernel_manager
-        notebook_path = self.get_argument('notebook_path', default=None)
-        name, path = nbm.named_notebook_path(notebook_path)
+        model = self.get_json_body()
+        if model is None:
+            raise HTTPError(400, "No JSON data provided")
+        try:
+            name = model['notebook']['name']
+        except KeyError:
+            raise HTTPError(400, "Missing field in JSON data: name")
+        try:
+            path = model['notebook']['path']
+        except KeyError:
+            raise HTTPError(400, "Missing field in JSON data: path")
         # Check to see if session exists
         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)
-            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))
+            model = sm.create_session(name=name, path=path, kernel_id=kernel_id, ws_url=self.ws_url)
+        self.set_header('Location', '{0}/api/sessions/{1}'.format(self.base_project_url, model['id']))
+        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(id=session_id)
-        self.finish(jsonapi.dumps(model))
+        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
         nbm = self.notebook_manager
         km = self.kernel_manager
-        data = self.request.body
-        data = jsonapi.loads(self.request.body)
-        name, path = nbm.named_notebook_path(data['notebook_path'])
-        sm.update_session(session_id, name=name)
+        model = self.get_json_body()
+        if model is None:
+            raise 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(id=session_id)
-        self.finish(jsonapi.dumps(model))
+        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
         nbm = self.notebook_manager
         km = self.kernel_manager
         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/%s" % _session_id_regex, SessionHandler),
-    (r"api/sessions/",  SessionRootHandler),
     (r"api/sessions",  SessionRootHandler)
 ]
 

IPython/html/services/sessions/sessionmanager.py

@@ -1,170 +1,189 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):
     
     # Session database initialized below
     _cursor = None
     _connection = None
     
     @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)""")
+                (id, name, path, kernel_id, ws_url)""")
         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:
             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
+    def create_session(self, name=None, path=None, kernel_id=None, ws_url=None):
+        """Creates a session and returns its model"""
+        session_id = self.get_session_id()
+        return self.save_session(session_id, name=name, path=path, kernel_id=kernel_id, ws_url=ws_url)
+
+    def save_session(self, session_id, name=None, path=None, kernel_id=None, ws_url=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 : str
+        kernel_id : str
             a uuid for the kernel associated with this session
+        ws_url : str
+            the websocket url
+            
+        Returns
+        -------
+        model : dict
+            a dictionary of the session model
         """
         self.cursor.execute("""INSERT INTO session VALUES 
-            (?,?,?,?)""", (session_id, name, path, kernel))
+            (?,?,?,?,?)""", (session_id, name, path, kernel_id, ws_url))
         self.connection.commit()
+        return self.get_session(id=session_id)
 
     def get_session(self, **kwargs):
-        """ Takes a keyword argument and searches for the value in the session
+        """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)
+            (i.e. session_id, name, path, kernel_id, ws_url)
 
         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
+        """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.
         """
-        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)
+        column = kwargs.keys() # uses only the first kwarg that is entered
+        value = kwargs.values()
+        for kwarg in kwargs:
+            try:
+                self.cursor.execute("UPDATE session SET %s=? WHERE id=?" %kwarg, (kwargs[kwarg], 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': ''}}
+                 'notebook': {'name': reply['name'], 'path': reply['path']},
+                 'kernel': {'id': reply['kernel_id'], 'ws_url': reply['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/services/sessions/tests/test_sessionmanager.py

@@ -1,86 +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')
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel_id='5678', ws_url='ws_url')
         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''}}
+        expected = {'id':session_id, 'notebook':{'name':u'test.ipynb', 'path': u'/path/to/'}, 'kernel':{'id':u'5678', 'ws_url':u'ws_url'}}
         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')
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel_id='5678', ws_url='ws_url')
         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')
+        sm.save_session(session_id=session_id1, name='test1.ipynb', path='/path/to/1/', kernel_id='5678', ws_url='ws_url')
+        sm.save_session(session_id=session_id2, name='test2.ipynb', path='/path/to/2/', kernel_id='5678', ws_url='ws_url')
+        sm.save_session(session_id=session_id3, name='test3.ipynb', path='/path/to/3/', kernel_id='5678', ws_url='ws_url')
         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''}}]
+        expected = [{'id':session_id1, 'notebook':{'name':u'test1.ipynb', 
+                    'path': u'/path/to/1/'}, 'kernel':{'id':u'5678', 'ws_url': 'ws_url'}},
+                    {'id':session_id2, 'notebook': {'name':u'test2.ipynb', 
+                    'path': u'/path/to/2/'}, 'kernel':{'id':u'5678', 'ws_url': 'ws_url'}},
+                    {'id':session_id3, 'notebook':{'name':u'test3.ipynb', 
+                    'path': u'/path/to/3/'}, 'kernel':{'id':u'5678', 'ws_url': 'ws_url'}}]
         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.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel_id=None, ws_url='ws_url')
+        sm.update_session(session_id, kernel_id='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''}}
+        expected = {'id':session_id, 'notebook':{'name':u'new_name.ipynb', 'path': u'/path/to/'}, 'kernel':{'id':u'5678', 'ws_url': 'ws_url'}}
         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')
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel_id='5678', ws_url='ws_url')
         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.save_session(session_id=session_id1, name='test1.ipynb', path='/path/to/1/', kernel_id='5678', ws_url='ws_url')
+        sm.save_session(session_id=session_id2, name='test2.ipynb', path='/path/to/2/', kernel_id='5678', ws_url='ws_url')
+        sm.save_session(session_id=session_id3, name='test3.ipynb', path='/path/to/3/', kernel_id='5678', ws_url='ws_url')
         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''}}]
+        expected = [{'id':session_id1, 'notebook':{'name':u'test1.ipynb', 
+                    'path': u'/path/to/1/'}, 'kernel':{'id':u'5678', 'ws_url': 'ws_url'}},
+                    {'id':session_id3, 'notebook':{'name':u'test3.ipynb', 
+                    'path': u'/path/to/3/'}, 'kernel':{'id':u'5678', 'ws_url': 'ws_url'}}]
         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')
+        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel_id='5678', ws_url='ws_url')
         self.assertRaises(TraitError, sm.delete_session, session_id='23424') # Bad keyword
 

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

@@ -1,95 +1,96 b''
 """Test the sessions web service API."""
 
 
 import os
 import sys
 import json
-from zmq.utils import jsonapi
-
 import requests
 
+from IPython.utils.jsonutil import date_default
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase
 
 class SessionAPITest(NotebookTestBase):
     """Test the sessions web service API"""
     
     def notebook_url(self):
         return url_path_join(super(SessionAPITest,self).base_url(), 'api/notebooks')
 
     def session_url(self):
         return super(SessionAPITest,self).base_url() + 'api/sessions'
 
     def mknb(self, name='', path='/'):
         url = self.notebook_url() + path
         return url, requests.post(url)
 
     def delnb(self, name, path='/'):
         url = self.notebook_url() + path + name
         r = requests.delete(url)
         return r.status_code
 
     def test_no_sessions(self):
         """Make sure there are no sessions running at the start"""
         url = self.session_url()
         r = requests.get(url)
         self.assertEqual(r.json(), [])
 
     def test_session_root_handler(self):
         # POST a session
         url, nb = self.mknb()
         notebook = nb.json()
-        param = {'notebook_path': notebook['path'] + notebook['name']}
-        r = requests.post(self.session_url(), params=param)
+        model = {'notebook': {'name':notebook['name'], 'path': notebook['path']}}
+        r = requests.post(self.session_url(), data=json.dumps(model, default=date_default))
         data = r.json()
         assert isinstance(data, dict)
-        self.assertIn('name', data)
-        self.assertEqual(data['name'], notebook['name'])
+        self.assertIn('name', data['notebook'])
+        self.assertEqual(data['notebook']['name'], notebook['name'])
 
         # GET sessions
         r = requests.get(self.session_url())
         assert isinstance(r.json(), list)
         assert isinstance(r.json()[0], dict)
         self.assertEqual(r.json()[0]['id'], data['id'])
 
         # Clean up
         self.delnb('Untitled0.ipynb')
         sess_url = self.session_url() +'/'+data['id']
         r = requests.delete(sess_url)
         self.assertEqual(r.status_code, 204)
 
     def test_session_handler(self):
         # Create a session
         url, nb = self.mknb()
         notebook = nb.json()
-        param = {'notebook_path': notebook['path'] + notebook['name']}
-        r = requests.post(self.session_url(), params=param)
+        model = {'notebook': {'name':notebook['name'], 'path': notebook['path']}}
+        r = requests.post(self.session_url(), data=json.dumps(model, default=date_default))
         session = r.json()
 
         # GET a session
         sess_url = self.session_url() + '/' + session['id']
         r = requests.get(sess_url)
         assert isinstance(r.json(), dict)
         self.assertEqual(r.json(), session)
 
         # PATCH a session
-        data = {'notebook_path': 'test.ipynb'}
-        r = requests.patch(sess_url, data=jsonapi.dumps(data))
+        model = {'notebook': {'name':'test.ipynb', 'path': '/'}}
+        r = requests.patch(sess_url, data=json.dumps(model, default=date_default))
+        
         # Patching the notebook webservice too (just for consistency)
         requests.patch(self.notebook_url() + '/Untitled0.ipynb', 
-            data=jsonapi.dumps({'name':'test.ipynb'}))
+            data=json.dumps({'name':'test.ipynb'}))
+        print r.json()
         assert isinstance(r.json(), dict)
-        self.assertIn('name', r.json())
+        self.assertIn('name', r.json()['notebook'])
         self.assertIn('id', r.json())
-        self.assertEqual(r.json()['name'], 'test.ipynb')
+        self.assertEqual(r.json()['notebook']['name'], 'test.ipynb')
         self.assertEqual(r.json()['id'], session['id'])
 
         # DELETE a session
         r = requests.delete(sess_url)
         self.assertEqual(r.status_code, 204)
         r = requests.get(self.session_url())
         self.assertEqual(r.json(), [])
         
         # Clean up
         r = self.delnb('test.ipynb')
         self.assertEqual(r, 204)
  No newline at end of file

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

@@ -1,95 +1,101 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){
+    var Session = function(notebook_name, notebook_path, Notebook){
         this.kernel = null;
         this.kernel_id = null;
         this.session_id = null;
+        this.notebook_name = notebook_name;
         this.notebook_path = notebook_path;
         this.notebook = Notebook;
         this._baseProjectUrl = Notebook.baseProjectUrl() 
     };
     
-    Session.prototype.start = function(){
+    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'
-        );
+        var notebook = {'notebook':{'name': this.notebook_name, 'path': this.notebook_path}}
+        var settings = {
+            processData : false,
+            cache : false,
+            type : "POST",
+            data: JSON.stringify(notebook),
+            dataType : "json",
+        };
+        var url = this._baseProjectUrl + 'api/sessions';
+        $.ajax(url, settings);
     };
     
-    Session.prototype.notebook_rename = function (notebook_path) {
-        this.notebook_path = notebook_path;
-        var name = {'notebook_path': notebook_path}
+    Session.prototype.notebook_rename = function (name, path) {
+        this.notebook_name = name;
+        this.notebook_path = path;
+        var notebook = {'notebook':{'name':name, 'path': path}};
         var settings = {
             processData : false,
             cache : false,
             type : "PATCH",
-            data: JSON.stringify(name),
+            data: JSON.stringify(notebook),
             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);
         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));