add tests for session api

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

@@ -0,0 +1,95 b''
+"""Test the sessions web service API."""
+
+
+import os
+import sys
+import json
+from zmq.utils import jsonapi
+
+import requests
+
+from IPython.html.tests.launchnotebook import NotebookTestBase
+
+
+class SessionAPITest(NotebookTestBase):
+    """Test the sessions web service API"""
+    
+    def notebook_url(self):
+        return 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)
+        data = r.json()
+        assert isinstance(data, dict)
+        assert data.has_key('name')
+        self.assertEqual(data['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)
+        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))
+        # Patching the notebook webservice too (just for consistency)
+        requests.patch(self.notebook_url() + '/Untitled0.ipynb', 
+            data=jsonapi.dumps({'name':'test.ipynb'}))
+        assert isinstance(r.json(), dict)
+        assert r.json().has_key('name')
+        assert r.json().has_key('id')
+        self.assertEqual(r.json()['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())
+        assert r.json() == []
+        
+        # Clean up
+        r = self.delnb('test.ipynb')
+        assert r == 204
  No newline at end of file

IPython/html/services/kernels/handlers.py

@@ -1,187 +1,186 b''
 """Tornado handlers for the notebook.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import logging
 from tornado import web
 
 from zmq.utils import jsonapi
 
 from IPython.utils.jsonutil import date_default
 
 from ...base.handlers import IPythonHandler
 from ...base.zmqhandlers import AuthenticatedZMQStreamHandler
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(IPythonHandler):
 
     @web.authenticated
     def get(self):
         km = self.kernel_manager
         self.finish(jsonapi.dumps(km.list_kernels()))
 
     @web.authenticated
     def post(self):
         km = self.kernel_manager
-        nbm = self.notebook_manager
-        kernel_id = km.start_kernel(cwd=nbm.notebook_dir)
+        kernel_id = km.start_kernel()
         model = km.kernel_model(kernel_id, self.ws_url)
         self.set_header('Location', '{0}kernels/{1}'.format(self.base_kernel_url, kernel_id))
         self.finish(jsonapi.dumps(model))
 
 
 class KernelHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('DELETE', 'GET')
 
     @web.authenticated
     def get(self, kernel_id):
         km = self.kernel_manager
         model = km.kernel_model(kernel_id, self.ws_url)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def delete(self, kernel_id):
         km = self.kernel_manager
         km.shutdown_kernel(kernel_id)
         self.set_status(204)
         self.finish()
 
 
 class KernelActionHandler(IPythonHandler):
 
     @web.authenticated
     def post(self, kernel_id, action):
         km = self.kernel_manager
         if action == 'interrupt':
             km.interrupt_kernel(kernel_id)
             self.set_status(204)
         if action == 'restart':
             km.restart_kernel(kernel_id)
             model = km.kernel_model(kernel_id, self.ws_url)
             self.set_header('Location', '{0}api/kernels/{1}'.format(self.base_kernel_url, kernel_id))
             self.write(jsonapi.dumps(model))
         self.finish()
 
 
 class ZMQChannelHandler(AuthenticatedZMQStreamHandler):
     
     def create_stream(self):
         km = self.kernel_manager
         meth = getattr(km, 'connect_%s' % self.channel)
         self.zmq_stream = meth(self.kernel_id, identity=self.session.bsession)
     
     def initialize(self, *args, **kwargs):
         self.zmq_stream = None
     
     def on_first_message(self, msg):
         try:
             super(ZMQChannelHandler, self).on_first_message(msg)
         except web.HTTPError:
             self.close()
             return
         try:
             self.create_stream()
         except web.HTTPError:
             # WebSockets don't response to traditional error codes so we
             # close the connection.
             if not self.stream.closed():
                 self.stream.close()
             self.close()
         else:
             self.zmq_stream.on_recv(self._on_zmq_reply)
 
     def on_message(self, msg):
         msg = jsonapi.loads(msg)
         self.session.send(self.zmq_stream, msg)
 
     def on_close(self):
         # This method can be called twice, once by self.kernel_died and once
         # from the WebSocket close event. If the WebSocket connection is
         # closed before the ZMQ streams are setup, they could be None.
         if self.zmq_stream is not None and not self.zmq_stream.closed():
             self.zmq_stream.on_recv(None)
             self.zmq_stream.close()
 
 
 class IOPubHandler(ZMQChannelHandler):
     channel = 'iopub'
     
     def create_stream(self):
         super(IOPubHandler, self).create_stream()
         km = self.kernel_manager
         km.add_restart_callback(self.kernel_id, self.on_kernel_restarted)
         km.add_restart_callback(self.kernel_id, self.on_restart_failed, 'dead')
     
     def on_close(self):
         km = self.kernel_manager
         if self.kernel_id in km:
             km.remove_restart_callback(
                 self.kernel_id, self.on_kernel_restarted,
             )
             km.remove_restart_callback(
                 self.kernel_id, self.on_restart_failed, 'dead',
             )
         super(IOPubHandler, self).on_close()
     
     def _send_status_message(self, status):
         msg = self.session.msg("status",
             {'execution_state': status}
         )
         self.write_message(jsonapi.dumps(msg, default=date_default))
 
     def on_kernel_restarted(self):
         logging.warn("kernel %s restarted", self.kernel_id)
         self._send_status_message('restarting')
 
     def on_restart_failed(self):
         logging.error("kernel %s restarted failed!", self.kernel_id)
         self._send_status_message('dead')
     
     def on_message(self, msg):
         """IOPub messages make no sense"""
         pass
 
 
 class ShellHandler(ZMQChannelHandler):
     channel = 'shell'
 
 
 class StdinHandler(ZMQChannelHandler):
     channel = 'stdin'
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_action_regex = r"(?P<action>restart|interrupt)"
 
 default_handlers = [
     (r"/api/kernels", MainKernelHandler),
     (r"/api/kernels/%s" % _kernel_id_regex, KernelHandler),
     (r"/api/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
     (r"/api/kernels/%s/iopub" % _kernel_id_regex, IOPubHandler),
     (r"/api/kernels/%s/shell" % _kernel_id_regex, ShellHandler),
     (r"/api/kernels/%s/stdin" % _kernel_id_regex, StdinHandler)
 ]

IPython/html/services/kernels/tests/test_kernels_api.py

@@ -1,23 +1,36 b''
 """Test the kernels service API."""
 
 
 import os
 import sys
 import json
 
 import requests
 
 from IPython.html.tests.launchnotebook import NotebookTestBase
 
 
 class KernelAPITest(NotebookTestBase):
     """Test the kernels web service API"""
 
     def base_url(self):
         return super(KernelAPITest,self).base_url() + 'api/kernels'
 
     def test_no_kernels(self):
         """Make sure there are no kernels running at the start"""
         url = self.base_url()
         r = requests.get(url)
         assert r.json() == []
+
+    def test_main_kernel_handler(self):
+        # POST request
+        r = requests.post(self.base_url())
+        data = r.json()
+        assert isinstance(data, dict)
+
+        # GET request
+        r = requests.get(self.base_url())
+        assert isinstance(r.json(), list)
+        self.assertEqual(r.json()[0], data['id'])
+
+        
  No newline at end of file

IPython/html/services/notebooks/filenbmanager.py

@@ -1,347 +1,347 b''
 """A notebook manager that uses the local file system for storage.
 
 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 io
 import os
 import glob
 import shutil
 
 from unicodedata import normalize
 
 from tornado import web
 
 from .nbmanager import NotebookManager
 from IPython.nbformat import current
 from IPython.utils.traitlets import Unicode, Dict, Bool, TraitError
 from IPython.utils import tz
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class FileNotebookManager(NotebookManager):
     
     save_script = Bool(False, config=True,
         help="""Automatically create a Python script when saving the notebook.
         
         For easier use of import, %run and %load across notebooks, a
         <notebook-name>.py script will be created next to any
         <notebook-name>.ipynb on each save.  This can also be set with the
         short `--script` flag.
         """
     )
     
     checkpoint_dir = Unicode(config=True,
         help="""The location in which to keep notebook checkpoints
         
         By default, it is notebook-dir/.ipynb_checkpoints
         """
     )
     def _checkpoint_dir_default(self):
         return os.path.join(self.notebook_dir, '.ipynb_checkpoints')
     
     def _checkpoint_dir_changed(self, name, old, new):
         """do a bit of validation of the checkpoint dir"""
         if not os.path.isabs(new):
             # If we receive a non-absolute path, make it absolute.
             abs_new = os.path.abspath(new)
             self.checkpoint_dir = abs_new
             return
         if os.path.exists(new) and not os.path.isdir(new):
             raise TraitError("checkpoint dir %r is not a directory" % new)
         if not os.path.exists(new):
             self.log.info("Creating checkpoint dir %s", new)
             try:
                 os.mkdir(new)
             except:
                 raise TraitError("Couldn't create checkpoint dir %r" % new)
     
     filename_ext = Unicode(u'.ipynb')
 
     
     def get_notebook_names(self, path):
         """List all notebook names in the notebook dir."""
         names = glob.glob(self.get_os_path('*'+self.filename_ext, path))
         names = [os.path.basename(name)
                  for name in names]
         return names
         
     def list_notebooks(self, path):
         """List all notebooks in the notebook dir."""
         notebook_names = self.get_notebook_names(path)
         notebooks = []
         for name in notebook_names:
             model = self.notebook_model(name, path, content=False)
             notebooks.append(model)
         return notebooks
 
     def change_notebook(self, data, notebook_name, notebook_path='/'):
         """Changes notebook"""
         changes = data.keys()
         for change in changes:
             full_path = self.get_os_path(notebook_name, notebook_path)
             if change == "name":
                 new_path = self.get_os_path(data['name'], notebook_path)
-                try:
+                if not os.path.isfile(new_path):
                     os.rename(full_path,
                         self.get_os_path(data['name'], notebook_path))
                     notebook_name = data['name']
-                except OSError as e:
+                else:
                     raise web.HTTPError(409, u'Notebook name already exists.')
             if change == "path":
                 new_path = self.get_os_path(data['name'], data['path'])
                 stutil.move(full_path, new_path)
                 notebook_path = data['path']
             if change == "content":
                 self.save_notebook(data, notebook_name, notebook_path)
         model = self.notebook_model(notebook_name, notebook_path)
         return model
 
     def notebook_exists(self, name, path):
         """Returns a True if the notebook exists. Else, returns False.
         
         Parameters
         ----------
         name : string
             The name of the notebook you are checking.
         path : string
             The relative path to the notebook (with '/' as separator)
         
         Returns
         -------
         bool
         """
         path = self.get_os_path(name, path)
         return os.path.isfile(path)
 
     def read_notebook_object_from_path(self, path):
         """read a notebook object from a path"""
         info = os.stat(path)
         last_modified = tz.utcfromtimestamp(info.st_mtime)
         with open(path,'r') as f:
             s = f.read()
             try:
                 # v1 and v2 and json in the .ipynb files.
                 nb = current.reads(s, u'json')
             except ValueError as e:
                 msg = u"Unreadable Notebook: %s" % e
                 raise web.HTTPError(400, msg, reason=msg)
         return last_modified, nb
     
     def read_notebook_object(self, notebook_name, notebook_path='/'):
         """Get the Notebook representation of a notebook by notebook_name."""
         path = self.get_os_path(notebook_name, notebook_path)
         if not os.path.isfile(path):
             raise web.HTTPError(404, u'Notebook does not exist: %s' % notebook_name)
         last_modified, nb = self.read_notebook_object_from_path(path)
         # Always use the filename as the notebook name.
         # Eventually we will get rid of the notebook name in the metadata
         # but for now, that name is just an empty string. Until the notebooks
         # web service knows about names in URLs we still pass the name
         # back to the web app using the metadata though.
         nb.metadata.name = os.path.splitext(os.path.basename(path))[0]
         return last_modified, nb
     
     def write_notebook_object(self, nb, notebook_name=None, notebook_path='/', new_name= None):
         """Save an existing notebook object by notebook_name."""
         if new_name == None:
             try:
                 new_name = normalize('NFC', nb.metadata.name)
             except AttributeError:
                 raise web.HTTPError(400, u'Missing notebook name')
 
         new_path = notebook_path
         old_name = notebook_name
         old_checkpoints = self.list_checkpoints(old_name)
         
         path = self.get_os_path(new_name, new_path)
         
         # Right before we save the notebook, we write an empty string as the
         # notebook name in the metadata. This is to prepare for removing
         # this attribute entirely post 1.0. The web app still uses the metadata
         # name for now.
         nb.metadata.name = u''
 
         try:
             self.log.debug("Autosaving notebook %s", path)
             with open(path,'w') as f:
                 current.write(nb, f, u'json')
         except Exception as e:
             raise web.HTTPError(400, u'Unexpected error while autosaving notebook: %s' % e)
 
         # save .py script as well
         if self.save_script:
             pypath = os.path.splitext(path)[0] + '.py'
             self.log.debug("Writing script %s", pypath)
             try:
                 with io.open(pypath,'w', encoding='utf-8') as f:
                     current.write(nb, f, u'py')
             except Exception as e:
                 raise web.HTTPError(400, u'Unexpected error while saving notebook as script: %s' % e)
         
         if old_name != None:
             # remove old files if the name changed
             if old_name != new_name:            
                 # remove renamed original, if it exists
                 old_path = self.get_os_path(old_name, notebook_path)
                 if os.path.isfile(old_path):
                     self.log.debug("unlinking notebook %s", old_path)
                     os.unlink(old_path)
             
                 # cleanup old script, if it exists
                 if self.save_script:
                     old_pypath = os.path.splitext(old_path)[0] + '.py'
                     if os.path.isfile(old_pypath):
                         self.log.debug("unlinking script %s", old_pypath)
                         os.unlink(old_pypath)
                 
                 # rename checkpoints to follow file
                 for cp in old_checkpoints:
                     checkpoint_id = cp['checkpoint_id']
                     old_cp_path = self.get_checkpoint_path_by_name(old_name, checkpoint_id)
                     new_cp_path = self.get_checkpoint_path_by_name(new_name, checkpoint_id)
                     if os.path.isfile(old_cp_path):
                         self.log.debug("renaming checkpoint %s -> %s", old_cp_path, new_cp_path)
                         os.rename(old_cp_path, new_cp_path)
             
         return new_name
             
     def delete_notebook(self, notebook_name, notebook_path):
         """Delete notebook by notebook_name."""
         nb_path = self.get_os_path(notebook_name, notebook_path)
         if not os.path.isfile(nb_path):
             raise web.HTTPError(404, u'Notebook does not exist: %s' % notebook_name)
         
         # clear checkpoints
         for checkpoint in self.list_checkpoints(notebook_name):
             checkpoint_id = checkpoint['checkpoint_id']
             path = self.get_checkpoint_path(notebook_name, checkpoint_id)
             self.log.debug(path)
             if os.path.isfile(path):
                 self.log.debug("unlinking checkpoint %s", path)
                 os.unlink(path)
         
         self.log.debug("unlinking notebook %s", nb_path)
         os.unlink(nb_path)
 
     def increment_filename(self, basename, notebook_path='/'):
         """Return a non-used filename of the form basename<int>.
         
         This searches through the filenames (basename0, basename1, ...)
         until is find one that is not already being used. It is used to
         create Untitled and Copy names that are unique.
         """
         i = 0
         while True:
             name = u'%s%i.ipynb' % (basename,i)
             path = self.get_os_path(name, notebook_path)
             if not os.path.isfile(path):
                 break
             else:
                 i = i+1
         return name
     
     # Checkpoint-related utilities
     
     def get_checkpoint_path_by_name(self, name, checkpoint_id, notebook_path='/'):
         """Return a full path to a notebook checkpoint, given its name and checkpoint id."""
         filename = u"{name}-{checkpoint_id}{ext}".format(
             name=name,
             checkpoint_id=checkpoint_id,
             ext=self.filename_ext,
         )
         if notebook_path ==None:
             path = os.path.join(self.checkpoint_dir, filename)
         else:
             path = os.path.join(notebook_path, self.checkpoint_dir, filename)
         return path
     
     def get_checkpoint_path(self, notebook_name, checkpoint_id, notebook_path='/'):
         """find the path to a checkpoint"""
         name = notebook_name
         return self.get_checkpoint_path_by_name(name, checkpoint_id, notebook_path)
     
     def get_checkpoint_info(self, notebook_name, checkpoint_id, notebook_path='/'):
         """construct the info dict for a given checkpoint"""
         path = self.get_checkpoint_path(notebook_name, checkpoint_id, notebook_path)
         stats = os.stat(path)
         last_modified = tz.utcfromtimestamp(stats.st_mtime)
         info = dict(
             checkpoint_id = checkpoint_id,
             last_modified = last_modified,
         )
         
         return info
         
     # public checkpoint API
     
     def create_checkpoint(self, notebook_name, notebook_path='/'):
         """Create a checkpoint from the current state of a notebook"""
         nb_path = self.get_os_path(notebook_name, notebook_path)
         # only the one checkpoint ID:
         checkpoint_id = u"checkpoint"
         cp_path = self.get_checkpoint_path(notebook_name, checkpoint_id, notebook_path)
         self.log.debug("creating checkpoint for notebook %s", notebook_name)
         if not os.path.exists(self.checkpoint_dir):
             os.mkdir(self.checkpoint_dir)
         shutil.copy2(nb_path, cp_path)
         
         # return the checkpoint info
         return self.get_checkpoint_info(notebook_name, checkpoint_id, notebook_path)
     
     def list_checkpoints(self, notebook_name, notebook_path='/'):
         """list the checkpoints for a given notebook
         
         This notebook manager currently only supports one checkpoint per notebook.
         """
         checkpoint_id = "checkpoint"
         path = self.get_checkpoint_path(notebook_name, checkpoint_id, notebook_path)
         if not os.path.exists(path):
             return []
         else:
             return [self.get_checkpoint_info(notebook_name, checkpoint_id, notebook_path)]
         
     
     def restore_checkpoint(self, notebook_name, checkpoint_id, notebook_path='/'):
         """restore a notebook to a checkpointed state"""
         self.log.info("restoring Notebook %s from checkpoint %s", notebook_name, checkpoint_id)
         nb_path = self.get_os_path(notebook_name, notebook_path)
         cp_path = self.get_checkpoint_path(notebook_name, checkpoint_id, notebook_path)
         if not os.path.isfile(cp_path):
             self.log.debug("checkpoint file does not exist: %s", cp_path)
             raise web.HTTPError(404,
                 u'Notebook checkpoint does not exist: %s-%s' % (notebook_name, checkpoint_id)
             )
         # ensure notebook is readable (never restore from an unreadable notebook)
         last_modified, nb = self.read_notebook_object_from_path(cp_path)
         shutil.copy2(cp_path, nb_path)
         self.log.debug("copying %s -> %s", cp_path, nb_path)
     
     def delete_checkpoint(self, notebook_name, checkpoint_id, notebook_path='/'):
         """delete a notebook's checkpoint"""
         path = self.get_checkpoint_path(notebook_name, checkpoint_id, notebook_path)
         if not os.path.isfile(path):
             raise web.HTTPError(404,
                 u'Notebook checkpoint does not exist: %s-%s' % (notebook_name, checkpoint_id)
             )
         self.log.debug("unlinking %s", path)
         os.unlink(path)
     
     def info_string(self):
         return "Serving notebooks from local directory: %s" % self.notebook_dir

IPython/html/services/notebooks/handlers.py

@@ -1,216 +1,217 b''
 """Tornado handlers for the notebooks web service.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from tornado import web
 
 from zmq.utils import jsonapi
 
 from IPython.utils.jsonutil import date_default
 
 from ...base.handlers import IPythonHandler
 
 #-----------------------------------------------------------------------------
 # Notebook web service handlers
 #-----------------------------------------------------------------------------
 
 
 class NotebookRootHandler(IPythonHandler):
 
     @web.authenticated
     def get(self):
         """get returns a list of notebooks from the location
         where the server was started."""
         nbm = self.notebook_manager
         notebooks = nbm.list_notebooks("/")
         self.finish(jsonapi.dumps(notebooks))
 
     @web.authenticated
     def post(self):
         """post creates a notebooks in the directory where the
         server was started"""
         nbm = self.notebook_manager
+        self.log.info(nbm.notebook_dir)
         body = self.request.body.strip()
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         if body:
             fname = nbm.save_new_notebook(body, notebook_path='/', name=name, format=format)
         else:
             fname = nbm.new_notebook(notebook_path='/')
         self.set_header('Location', nbm.notebook_dir + fname)
         model = nbm.notebook_model(fname)
         self.set_header('Location', '{0}api/notebooks/{1}'.format(self.base_project_url, fname))
         self.finish(jsonapi.dumps(model))
 
 class NotebookHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'PUT', 'PATCH', 'POST','DELETE')
 
     @web.authenticated
     def get(self, notebook_path):
         """get checks if a notebook is not named, an returns a list of notebooks
         in the notebook path given. If a name is given, return 
         the notebook representation"""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         
         # Check to see if a notebook name was given
         if name is None:
             # List notebooks in 'notebook_path'
             notebooks = nbm.list_notebooks(path)
             self.finish(jsonapi.dumps(notebooks))
         else:
             # get and return notebook representation
             format = self.get_argument('format', default='json')
             download = self.get_argument('download', default='False')
             model = nbm.notebook_model(name, path)
             last_mod, representation, name = nbm.get_notebook(name, path, format)
             self.set_header('Last-Modified', last_mod)
             
             if download == 'True':
                 if format == u'json':
                     self.set_header('Content-Type', 'application/json')
                     self.set_header('Content-Disposition','attachment; filename="%s.ipynb"' % name)
                     self.finish(representation)
                 elif format == u'py':
                     self.set_header('Content-Type', 'application/x-python')
                     self.set_header('Content-Disposition','attachment; filename="%s.py"' % name)
                     self.finish(representation)
             else:
                 self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def patch(self, notebook_path):
         """patch is currently used strictly for notebook renaming.
         Changes the notebook name to the name given in data."""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         data = jsonapi.loads(self.request.body)
         model = nbm.change_notebook(data, name, path)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def post(self,notebook_path):
         """Create a new notebook in the location given by 'notebook_path'."""
         nbm = self.notebook_manager
         fname, path = nbm.named_notebook_path(notebook_path)
         body = self.request.body.strip()
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         if body:
             fname = nbm.save_new_notebook(body, notebook_path=path, name=name, format=format)
         else:
             fname = nbm.new_notebook(notebook_path=path)
         self.set_header('Location', nbm.notebook_dir + path + fname)
         model = nbm.notebook_model(fname, path)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def put(self, notebook_path):
         """saves the notebook in the location given by 'notebook_path'."""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         format = self.get_argument('format', default='json')
         nbm.save_notebook(self.request.body, notebook_path=path, name=name, format=format)
         model = nbm.notebook_model(name, path)
         self.set_status(204)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def delete(self, notebook_path):
         """delete rmoves the notebook in the given notebook path"""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         nbm.delete_notebook(name, path)
         self.set_status(204)
         self.finish()
 
 
 class NotebookCheckpointsHandler(IPythonHandler):
     
     SUPPORTED_METHODS = ('GET', 'POST')
     
     @web.authenticated
     def get(self, notebook_path):
         """get lists checkpoints for a notebook"""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         checkpoints = nbm.list_checkpoints(name, path)
         data = jsonapi.dumps(checkpoints, default=date_default)
         self.finish(data)
     
     @web.authenticated
     def post(self, notebook_path):
         """post creates a new checkpoint"""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         checkpoint = nbm.create_checkpoint(name, path)
         data = jsonapi.dumps(checkpoint, default=date_default)
         if path == None:
             self.set_header('Location', '{0}notebooks/{1}/checkpoints/{2}'.format(
                 self.base_project_url, name, checkpoint['checkpoint_id']
                 ))
         else:
             self.set_header('Location', '{0}notebooks/{1}/{2}/checkpoints/{3}'.format(
                 self.base_project_url, path, name, checkpoint['checkpoint_id']
                 ))
         self.finish(data)
 
 
 class ModifyNotebookCheckpointsHandler(IPythonHandler):
     
     SUPPORTED_METHODS = ('POST', 'DELETE')
     
     @web.authenticated
     def post(self, notebook_path, checkpoint_id):
         """post restores a notebook from a checkpoint"""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         nbm.restore_checkpoint(name, checkpoint_id, path)
         self.set_status(204)
         self.finish()
     
     @web.authenticated
     def delete(self, notebook_path, checkpoint_id):
         """delete clears a checkpoint for a given notebook"""
         nbm = self.notebook_manager
         name, path = nbm.named_notebook_path(notebook_path)
         nbm.delete_checkpoint(name, checkpoint_id, path)
         self.set_status(204)
         self.finish()
         
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 _notebook_path_regex = r"(?P<notebook_path>.+)"
 _checkpoint_id_regex = r"(?P<checkpoint_id>[\w-]+)"
 
 default_handlers = [
     (r"api/notebooks/%s/checkpoints" % _notebook_path_regex, NotebookCheckpointsHandler),
     (r"api/notebooks/%s/checkpoints/%s" % (_notebook_path_regex, _checkpoint_id_regex),
         ModifyNotebookCheckpointsHandler),
     (r"api/notebooks/%s/" % _notebook_path_regex, NotebookHandler), 
     (r"api/notebooks/%s" % _notebook_path_regex, NotebookHandler),
     (r"api/notebooks/", NotebookRootHandler),
     (r"api/notebooks", NotebookRootHandler),
 ]
 
 
 
 

IPython/html/services/notebooks/tests/test_notebooks_api.py

@@ -1,118 +1,116 b''
-"""Test the all of the services API."""
+"""Test the notebooks webservice API."""
 
 
 import os
 import sys
 import json
-import urllib
 from zmq.utils import jsonapi
 
 import requests
 
 from IPython.html.tests.launchnotebook import NotebookTestBase
 
 class APITest(NotebookTestBase):
     """Test the kernels web service API"""
 
-    def base_url(self):
-        return super(APITest,self).base_url()
-
-    def notebooks_url(self):
-        return self.base_url() + 'api/notebooks'
+    def notebook_url(self):
+        return super(APITest,self).base_url() + 'api/notebooks'
 
     def mknb(self, name='', path='/'):
-        url = self.notebooks_url() + path
+        url = self.notebook_url() + path
         return url, requests.post(url)
 
     def delnb(self, name, path='/'):
-        url = self.notebooks_url() + path + name
+        url = self.notebook_url() + path + name
         r = requests.delete(url)
         return r.status_code
 
-    def test_no_notebooks(self):
-        url = self.notebooks_url()
-        r = requests.get(url)
-        self.assertEqual(r.json(), [])
-
     def test_notebook_root_handler(self):
         # POST a notebook and test the dict thats returned.
-        url, nb = self.mknb()
+        #url, nb = self.mknb()
+        url = self.notebook_url()
+        nb = requests.post(url)
         data = nb.json()
         assert isinstance(data, dict)
         assert data.has_key("name")
         assert data.has_key("path")
         self.assertEqual(data['name'], u'Untitled0.ipynb')
         self.assertEqual(data['path'], u'/')
 
         # GET list of notebooks in directory.
         r = requests.get(url)
         assert isinstance(r.json(), list)
         assert isinstance(r.json()[0], dict)
+        
+        self.delnb('Untitled0.ipynb')
 
     def test_notebook_handler(self):
         # GET with a notebook name.
         url, nb = self.mknb()
         data = nb.json()
-        url = self.notebooks_url() + '/Untitled0.ipynb'
+        url = self.notebook_url() + '/Untitled0.ipynb'
         r = requests.get(url)
         assert isinstance(data, dict)
         self.assertEqual(r.json(), data)
 
         # PATCH (rename) request.
         new_name = {'name':'test.ipynb'}
         r = requests.patch(url, data=jsonapi.dumps(new_name))
         data = r.json()
         assert isinstance(data, dict)
 
         # make sure the patch worked.
-        new_url = self.notebooks_url() + '/test.ipynb'
+        new_url = self.notebook_url() + '/test.ipynb'
         r = requests.get(new_url)
         assert isinstance(r.json(), dict)
         self.assertEqual(r.json(), data)
 
         # GET bad (old) notebook name.
         r = requests.get(url)
         self.assertEqual(r.status_code, 404)
 
         # POST notebooks to folders one and two levels down.
         os.makedirs(os.path.join(self.notebook_dir.name, 'foo'))
         os.makedirs(os.path.join(self.notebook_dir.name, 'foo','bar'))
+        assert os.path.isdir(os.path.join(self.notebook_dir.name, 'foo'))
         url, nb = self.mknb(path='/foo/')
         url2, nb2 = self.mknb(path='/foo/bar/')
         data = nb.json()
         data2 = nb2.json()
         assert isinstance(data, dict)
         assert isinstance(data2, dict)
         assert data.has_key("name")
         assert data.has_key("path")
         self.assertEqual(data['name'], u'Untitled0.ipynb')
         self.assertEqual(data['path'], u'/foo/')
         assert data2.has_key("name")
         assert data2.has_key("path")
         self.assertEqual(data2['name'], u'Untitled0.ipynb')
         self.assertEqual(data2['path'], u'/foo/bar/')
 
         # GET request on notebooks one and two levels down.
         r = requests.get(url+'Untitled0.ipynb')
         r2 = requests.get(url2+'Untitled0.ipynb')
         assert isinstance(r.json(), dict)
         self.assertEqual(r.json(), data)
         assert isinstance(r2.json(), dict)
         self.assertEqual(r2.json(), data2)
 
         # PATCH notebooks that are one and two levels down.
         new_name = {'name': 'testfoo.ipynb'}
         r = requests.patch(url+'Untitled0.ipynb', data=jsonapi.dumps(new_name))
         r = requests.get(url+'testfoo.ipynb')
         data = r.json()
         assert isinstance(data, dict)
         assert data.has_key('name')
         self.assertEqual(data['name'], 'testfoo.ipynb')
         r = requests.get(url+'Untitled0.ipynb')
         self.assertEqual(r.status_code, 404)
         
         # DELETE notebooks
-        r = self.delnb('testfoo.ipynb', '/foo/')
-        r2 = self.delnb('Untitled0.ipynb', '/foo/bar/') 
-        self.assertEqual(r, 204)
-        self.assertEqual(r2, 204)
  No newline at end of file
+        r0 = self.delnb('test.ipynb')
+        r1 = self.delnb('testfoo.ipynb', '/foo/')
+        r2 = self.delnb('Untitled0.ipynb', '/foo/bar/')
+        self.assertEqual(r0, 204)
+        self.assertEqual(r1, 204)
+        self.assertEqual(r2, 204)

IPython/html/services/sessions/handlers.py

@@ -1,112 +1,114 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):
         # 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))
 
     @web.authenticated
     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)
         # 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))
 
 class SessionHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'PATCH', 'DELETE')
 
     @web.authenticated
     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))
 
     @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
-        name, path = nbm.named_notebook_path(notebook_path)
+        data = jsonapi.loads(self.request.body)
+        name, path = nbm.named_notebook_path(data['notebook_path'])
         sm.update_session(session_id, name=name)
         model = sm.get_session(id=session_id)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     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/static/services/sessions/js/session.js

@@ -1,95 +1,96 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;
+        name = {'notebook_path': notebook_path}
         var settings = {
             processData : false,
             cache : false,
             type : "PATCH",
-            data: notebook_path,
+            data: JSON.stringify(name),
             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));

IPython/html/tests/launchnotebook.py

@@ -1,41 +1,41 b''
 """Base class for notebook tests."""
 
 import sys
 import time
 from subprocess import Popen, PIPE
 from unittest import TestCase
 
 from IPython.utils.tempdir import TemporaryDirectory
 
 
 class NotebookTestBase(TestCase):
     """A base class for tests that need a running notebook.
     
     This creates an empty profile in a temp ipython_dir
     and then starts the notebook server with a separate temp notebook_dir.
     """
 
-    port = 12342
+    port = 1234
 
     def setUp(self):
         self.ipython_dir = TemporaryDirectory()
         self.notebook_dir = TemporaryDirectory()
         notebook_args = [
             sys.executable, '-c',
             'from IPython.html.notebookapp import launch_new_instance; launch_new_instance()',
             '--port=%d' % self.port,
             '--no-browser',
             '--ipython-dir=%s' % self.ipython_dir.name,
             '--notebook-dir=%s' % self.notebook_dir.name
-        ]
-        #self.notebook = Popen(notebook_args)
+        ]        
         self.notebook = Popen(notebook_args, stdout=PIPE, stderr=PIPE)
         time.sleep(3.0)
 
     def tearDown(self):
         self.notebook.terminate()
         self.ipython_dir.cleanup()
         self.notebook_dir.cleanup()
+        time.sleep(3.0)
 
     def base_url(self):
         return 'http://localhost:%i/' % self.port