manual rebase services/kernels/

IPython/html/services/kernels/handlers.py

@@ -1,182 +1,187 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_kernel_ids()))
+        self.finish(jsonapi.dumps(km.list_kernels()))
 
     @web.authenticated
     def post(self):
         km = self.kernel_manager
         nbm = self.notebook_manager
-        notebook_id = self.get_argument('notebook', default=None)
-        kernel_id = km.start_kernel(notebook_id, cwd=nbm.notebook_dir)
-        data = {'ws_url':self.ws_url,'kernel_id':kernel_id}
+        kernel_id = km.start_kernel(cwd=nbm.notebook_dir)
+        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(data))
+        self.finish(jsonapi.dumps(model))
 
 
 class KernelHandler(IPythonHandler):
 
-    SUPPORTED_METHODS = ('DELETE')
+    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)
-            data = {'ws_url':self.ws_url, 'kernel_id':kernel_id}
+            model = km.kernel_model(kernel_id,self.ws_url)
             self.set_header('Location', '{0}kernels/{1}'.format(self.base_kernel_url, kernel_id))
-            self.write(jsonapi.dumps(data))
+            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"/kernels", MainKernelHandler),
-    (r"/kernels/%s" % _kernel_id_regex, KernelHandler),
-    (r"/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
-    (r"/kernels/%s/iopub" % _kernel_id_regex, IOPubHandler),
-    (r"/kernels/%s/shell" % _kernel_id_regex, ShellHandler),
-    (r"/kernels/%s/stdin" % _kernel_id_regex, StdinHandler)
+    (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,110 +1,96 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)
-    
-    _notebook_mapping = Dict()
+    kernels = []
 
     #-------------------------------------------------------------------------
     # Methods for managing kernels and sessions
     #-------------------------------------------------------------------------
 
-    def kernel_for_notebook(self, notebook_id):
-        """Return the kernel_id for a notebook_id or None."""
-        return self._notebook_mapping.get(notebook_id)
-
-    def set_kernel_for_notebook(self, notebook_id, kernel_id):
-        """Associate a notebook with a kernel."""
-        if notebook_id is not None:
-            self._notebook_mapping[notebook_id] = kernel_id
-
-    def notebook_for_kernel(self, kernel_id):
-        """Return the notebook_id for a kernel_id or None."""
-        for notebook_id, kid in self._notebook_mapping.iteritems():
-            if kernel_id == kid:
-                return notebook_id
-        return None
-
-    def delete_mapping_for_kernel(self, kernel_id):
-        """Remove the kernel/notebook mapping for kernel_id."""
-        notebook_id = self.notebook_for_kernel(kernel_id)
-        if notebook_id is not None:
-            del self._notebook_mapping[notebook_id]
-
     def _handle_kernel_died(self, kernel_id):
         """notice that a kernel died"""
         self.log.warn("Kernel %s died, removing from map.", kernel_id)
-        self.delete_mapping_for_kernel(kernel_id)
         self.remove_kernel(kernel_id)
 
-    def start_kernel(self, notebook_id=None, **kwargs):
-        """Start a kernel for a notebook an return its kernel_id.
+    def start_kernel(self, **kwargs):
+        """Start a kernel for a session an return its kernel_id.
 
         Parameters
         ----------
-        notebook_id : uuid
-            The uuid of the notebook to associate the new kernel with. If this
-            is not None, this kernel will be persistent whenever the notebook
+        session_id : uuid
+            The uuid of the session to associate the new kernel with. If this
+            is not None, this kernel will be persistent whenever the session
             requests a kernel.
         """
-        kernel_id = self.kernel_for_notebook(notebook_id)
+        kernel_id = None
         if kernel_id is None:
             kwargs['extra_arguments'] = self.kernel_argv
             kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs)
-            self.set_kernel_for_notebook(notebook_id, kernel_id)
             self.log.info("Kernel started: %s" % kernel_id)
             self.log.debug("Kernel args: %r" % kwargs)
             # register callback for failed auto-restart
             self.add_restart_callback(kernel_id,
                 lambda : self._handle_kernel_died(kernel_id),
                 'dead',
             )
         else:
             self.log.info("Using existing kernel: %s" % kernel_id)
 
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         """Shutdown a kernel by kernel_id"""
+        i = 0
+        for kernel in self.kernels:
+            if kernel['kernel_id'] == kernel_id:
+                del self.kernels[i]
+            i = i+1
         super(MappingKernelManager, self).shutdown_kernel(kernel_id, now=now)
-        self.delete_mapping_for_kernel(kernel_id)
+
+    def kernel_model(self, kernel_id, ws_url):
+        model = {"kernel_id":kernel_id, "ws_url": ws_url}
+        self.kernels.append(model)
+        return model
+
+    def list_kernels(self):
+        return self.kernels
 
     # override _check_kernel_id to raise 404 instead of KeyError
     def _check_kernel_id(self, kernel_id):
         """Check a that a kernel_id exists and raise 404 if not."""
         if kernel_id not in self:
             raise web.HTTPError(404, u'Kernel does not exist: %s' % kernel_id)
-