adding to test_kernels_api.py

- Check all HTTP status code responses for requests
- Test invalid kernel IDs
- Check 'location' key in POST request to kernels

IPython/html/services/kernels/handlers.py

@@ -1,191 +1,193 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, json_errors
 from ...base.zmqhandlers import AuthenticatedZMQStreamHandler
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(IPythonHandler):
 
     @web.authenticated
     @json_errors
     def get(self):
         km = self.kernel_manager
         self.finish(jsonapi.dumps(km.list_kernels(self.ws_url)))
 
     @web.authenticated
     @json_errors
     def post(self):
         km = self.kernel_manager
         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.set_header('Location', '{0}api/kernels/{1}'.format(self.base_kernel_url, kernel_id))
+        self.set_status(201)
         self.finish(jsonapi.dumps(model))
 
 
 class KernelHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('DELETE', 'GET')
 
     @web.authenticated
     @json_errors
     def get(self, kernel_id):
         km = self.kernel_manager
+        km._check_kernel_id(kernel_id)
         model = km.kernel_model(kernel_id, self.ws_url)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     @json_errors
     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
     @json_errors
     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/kernelmanager.py

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

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

@@ -1,54 +1,100 b''
 """Test the kernels service API."""
 
 
 import os
 import sys
 import json
 
 import requests
 
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase
 
 
 class KernelAPITest(NotebookTestBase):
     """Test the kernels web service API"""
 
     def base_url(self):
         return url_path_join(super(KernelAPITest,self).base_url(), 'api/kernels')
 
     def mkkernel(self):
         r = requests.post(self.base_url())
         return r.json()
 
     def test__no_kernels(self):
         """Make sure there are no kernels running at the start"""
         url = self.base_url()
         r = requests.get(url)
         self.assertEqual(r.json(), [])
 
     def test_main_kernel_handler(self):
         # POST request
         r = requests.post(self.base_url())
         data = r.json()
+        status = r.status_code
+        header = r.headers
+        self.assertIn('location', header)
+        self.assertEquals(header['location'], '/api/kernels/' + data['id'])
+        self.assertEquals(status, 201)
         assert isinstance(data, dict)
 
         # GET request
         r = requests.get(self.base_url())
+        status = r.status_code
+        self.assertEquals(status, 200)
         assert isinstance(r.json(), list)
         self.assertEqual(r.json()[0]['id'], data['id'])
+        
+        # create another kernel and check that they both are added to the 
+        # list of kernels from a GET request
+        data2 = self.mkkernel()
+        assert isinstance(data2, dict)
+        r = requests.get(self.base_url())
+        kernels = r.json()
+        status = r.status_code
+        self.assertEquals(status, 200)
+        assert isinstance(kernels, list)
+        self.assertEquals(len(kernels), 2)
 
     def test_kernel_handler(self):
-        # GET kernel with id
+        # GET kernel with given id
         data = self.mkkernel()
         url = self.base_url() +'/' + data['id']
         r = requests.get(url)
-        assert isinstance(r.json(), dict)
-        self.assertIn('id', r.json())
-        self.assertEqual(r.json()['id'], data['id'])
+        data1 = r.json()
+        status = r.status_code
+        self.assertEquals(status, 200)
+        assert isinstance(data1, dict)
+        self.assertIn('id', data1)
+        self.assertIn('ws_url', data1)
+        self.assertEqual(data1['id'], data['id'])
+        
+        # Request a bad kernel id and check that a JSON
+        # message is returned!
+        bad_id = '111-111-111-111-111'
+        bad_url = self.base_url() + '/' + bad_id
+        r = requests.get(bad_url)
+        status = r.status_code
+        message = r.json()
+        self.assertEquals(status, 404)
+        assert isinstance(message, dict)
+        self.assertIn('message', message)
+        self.assertEquals(message['message'], 'Kernel does not exist: ' + bad_id)
         
         # DELETE kernel with id
         r = requests.delete(url)
         self.assertEqual(r.status_code, 204)
         r = requests.get(self.base_url())
         self.assertEqual(r.json(), [])
+        
+        # Request to delete a non-existent kernel id
+        bad_id = '111-111-111-111-111'
+        bad_url = self.base_url() + '/' + bad_id
+        r = requests.delete(bad_url)
+        status = r.status_code
+        message = r.json()
+        self.assertEquals(status, 404)
+        assert isinstance(message, dict)
+        self.assertIn('message', message)
+        self.assertEquals(message['message'], 'Kernel does not exist: ' + bad_id)
+        
  No newline at end of file

IPython/html/services/sessions/handlers.py

@@ -1,125 +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
 #-----------------------------------------------------------------------------
 
 import json
 
 from tornado import web
 from IPython.utils.jsonutil import date_default
 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
         sessions = sm.list_sessions()
         self.finish(json.dumps(sessions, default=date_default))
 
     @web.authenticated
     @json_errors
     def post(self):
         # Creates a new session 
         #(unless a session already exists for the named nb)
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         model = self.get_json_body()
         if model is None:
-            raise HTTPError(400, "No JSON data provided")
+            raise web.HTTPError(400, "No JSON data provided")
         try:
             name = model['notebook']['name']
         except KeyError:
-            raise HTTPError(400, "Missing field in JSON data: name")
+            raise web.HTTPError(400, "Missing field in JSON data: name")
         try:
             path = model['notebook']['path']
         except KeyError:
-            raise HTTPError(400, "Missing field in JSON data: path")
+            raise web.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)
         else:
             kernel_id = km.start_kernel(cwd=nbm.notebook_dir)
             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(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
         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(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",  SessionRootHandler)
 ]