Basic server for htmlnotebook working.

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,98 +1,102 b''
 import signal
 import sys
-import uuid
 
 from IPython.zmq.ipkernel import launch_kernel
 from session import SessionManager
 
 
+class DuplicateKernelError(Exception):
+    pass
+
+
 class KernelManager(object):
 
     ip = '127.0.0.1'
 
     def __init__(self, context):
         self.context = context
         self._kernels = {}
 
     @property
     def kernel_ids(self):
         return self._kernels.keys()
 
     def __len__(self):
         return len(self.kernel_ids)
 
     def __contains__(self, kernel_id):
         if kernel_id in self.kernel_ids:
             return True
         else:
             return False
 
-    def start_kernel(self):
-        kid = str(uuid.uuid4())
+    def start_kernel(self, kernel_id):
+        if kernel_id in self._kernels:
+            raise DuplicateKernelError("Kernel already exists: %s" % kernel_id)
         (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel()
         d = dict(
             process = process,
             stdin_port = stdin_port,
             iopub_port = iopub_port,
             shell_port = shell_port,
             hb_port = hb_port,
-            session_manager = SessionManager(self, kid, self.context)
+            session_manager = SessionManager(self, kernel_id, self.context)
         )
-        self._kernels[kid] = d
-        return kid
+        self._kernels[kernel_id] = d
+        return kernel_id
 
     def kill_kernel(self, kernel_id):
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             # Attempt to kill the kernel.
             try:
                 kernel_process.kill()
             except OSError, e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if not (sys.platform == 'win32' and e.winerror == 5):
                     raise
             del self._kernels[kernel_id]
 
     def interrupt_kernel(self, kernel_id):
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             if sys.platform == 'win32':
                 from parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(kernel_process.win32_interrupt_event)
             else:
                 kernel_process.send_signal(signal.SIGINT)
 
     def signal_kernel(self, kernel_id, signum):
         """ Sends a signal to the kernel. Note that since only SIGTERM is
         supported on Windows, this function is only useful on Unix systems.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             kernel_process.send_signal(signum)
 
     def get_kernel_process(self, kernel_id):
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['process']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_kernel_ports(self, kernel_id):
         d = self._kernels.get(kernel_id)
         if d is not None:
             dcopy = d.copy()
             dcopy.pop('process')
             return dcopy
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_session_manager(self, kernel_id):
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['session_manager']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
 
 

IPython/frontend/html/notebook/notebook.py

@@ -1,124 +1,133 b''
 import json
 import logging
 import os
-import uuid
 
 import zmq
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
-from zmq.eventloop.zmqstream import ZMQStream
 from zmq.eventloop import ioloop
 import tornado.ioloop
 tornado.ioloop = ioloop
 
 from tornado import httpserver
 from tornado import options
 from tornado import web
 from tornado import websocket
 
 from kernelmanager import KernelManager
 
 options.define("port", default=8888, help="run on the given port", type=int)
 
-_kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
-_session_id_regex = r"(?P<session_id>\w+)"
+_session_id_regex = r"(?P<session_id>\w+-\w+-\w+-\w+-\w+)"
+_kernel_id_regex = r"(?P<kernel_id>\w+)"
 
 
 class MainHandler(web.RequestHandler):
     def get(self):
         self.render('notebook.html')
 
 
-class KernelHandler(web.RequestHandler):
+class BaseKernelHandler(object):
+
+    def get_kernel(self):
+        return self.application.kernel_manager
+
+    def get_session(self, kernel_id):
+        km = self.get_kernel()
+        sm = km.get_session_manager(kernel_id)
+        return sm
+
+
+class KernelHandler(web.RequestHandler, BaseKernelHandler):
 
     def get(self):
-        self.write(json.dumps(self.application.kernel_manager.kernel_ids))
+        self.write(json.dumps(self.get_kernel().kernel_ids))
+
+    def post(self, *args, **kwargs):
+        kernel_id = kwargs['kernel_id']
+        self.get_kernel().start_kernel(kernel_id)
+        logging.info("Starting kernel: %s" % kernel_id)
+        self.write(json.dumps(kernel_id))
 
-    def post(self):
-        kid = self.application.kernel_manager.start_kernel()
-        logging.info("Starting kernel: %s" % kid)
-        self.write(json.dumps(kid))
 
+class SessionHandler(web.RequestHandler, BaseKernelHandler):
 
-class SessionHandler(web.RequestHandler):
+    def get(self, *args, **kwargs):
+        kernel_id = kwargs['kernel_id']
+        self.write(json.dumps(self.get_session(kernel_id).session_ids))
 
     def post(self, *args, **kwargs):
         kernel_id = kwargs['kernel_id']
-        session_id = kwargs['session_id']
+        sm = self.get_session(kernel_id)
+        session_id = sm.start_session()
         logging.info("Starting session: %s, %s" % (kernel_id,session_id))
-        km = self.application.kernel_manager
-        sm = km.get_session_manager(kernel_id)
-        sm.start_session(session_id)
-        self.finish()
+        self.write(json.dumps(session_id))
 
 
-class ZMQStreamHandler(websocket.WebSocketHandler):
+class ZMQStreamHandler(websocket.WebSocketHandler, BaseKernelHandler):
 
     stream_name = ''
 
     def open(self, *args, **kwargs):
         kernel_id = kwargs['kernel_id']
         session_id = kwargs['session_id']
         logging.info("Connection open: %s, %s" % (kernel_id,session_id))
-        sm = self.application.kernel_manager.get_session_manager(kernel_id)
+        sm = self.get_session(kernel_id)
         method_name = "get_%s_stream" % self.stream_name
         method = getattr(sm, method_name)
         self.zmq_stream = method(session_id)
         self.zmq_stream.on_recv(self._on_zmq_reply)
-        self.session_manager = sm
-        self.session_id = session_id
 
     def on_message(self, msg):
         logging.info("Message received: %r" % msg)
-        self.zmq_stream.send(msg)
+        self.zmq_stream.send_unicode(msg)
 
     def on_close(self):
-        logging.info("Connection closed: %s, %s" % (kernel_id,session_id))
         self.zmq_stream.close()
 
     def _on_zmq_reply(self, msg):
         logging.info("Message reply: %r" % msg)
         self.write_message(msg)
 
 
 class IOPubStreamHandler(ZMQStreamHandler):
 
     stream_name = 'iopub'
 
 
 class ShellStreamHandler(ZMQStreamHandler):
 
     stream_name = 'shell'
 
 
 class NotebookApplication(web.Application):
 
     def __init__(self):
         handlers = [
             (r"/", MainHandler),
-            (r"/kernels", KernelHandler),
-            (r"/kernels/%s/sessions/%s" % (_kernel_id_regex,_session_id_regex), SessionHandler),
+            (r"/kernels/%s" % (_kernel_id_regex,), KernelHandler),
+            (r"/kernels/%s/sessions" % (_kernel_id_regex,), SessionHandler),
             (r"/kernels/%s/sessions/%s/iopub" % (_kernel_id_regex,_session_id_regex), IOPubStreamHandler),
             (r"/kernels/%s/sessions/%s/shell" % (_kernel_id_regex,_session_id_regex), ShellStreamHandler),
         ]
         settings = dict(
             template_path=os.path.join(os.path.dirname(__file__), "templates"),
             static_path=os.path.join(os.path.dirname(__file__), "static"),
         )
         web.Application.__init__(self, handlers, **settings)
         self.context = zmq.Context()
         self.kernel_manager = KernelManager(self.context)
 
 
 def main():
     options.parse_command_line()
     application = NotebookApplication()
     http_server = httpserver.HTTPServer(application)
     http_server.listen(options.options.port)
     ioloop.IOLoop.instance().start()
 
 
 if __name__ == "__main__":
     main()
 

IPython/frontend/html/notebook/session.py

@@ -1,56 +1,72 b''
 import logging
+import uuid
 
 import zmq
 from zmq.eventloop.zmqstream import ZMQStream
 
 
 class SessionManager(object):
 
     def __init__(self, kernel_manager, kernel_id, context):
         self.context = context
         self.kernel_manager = kernel_manager
         self.kernel_id = kernel_id
         self._sessions = {}
 
     def __del__(self):
         self.stop_all()
 
-    def start_session(self, session_id):
+    @property
+    def session_ids(self):
+        return self._session.keys()
+
+    def __len__(self):
+        return len(self.session_ids)
+
+    def __contains__(self, session_id):
+        if session_id in self.session_ids:
+            return True
+        else:
+            return False
+
+    def start_session(self):
+        session_id = str(uuid.uuid4())
         ports = self.kernel_manager.get_kernel_ports(self.kernel_id)
         iopub_stream = self.create_connected_stream(ports['iopub_port'], zmq.SUB)
         shell_stream = self.create_connected_stream(ports['shell_port'], zmq.XREQ)
         self._sessions[session_id] = dict(
             iopub_stream = iopub_stream,
             shell_stream = shell_stream
         )
+        return session_id
 
     def stop_session(self, session_id):
         session_dict = self._sessions.get(session_id)
         if session_dict is not None:
             for name, stream in session_dict.items():
                 stream.close()
             del self._sessions[session_id]
 
     def stop_all(self):
         for session_id in self._sessions.keys():
             self.stop_session(session_id)
 
     def create_connected_stream(self, port, socket_type):
         sock = self.context.socket(socket_type)
         addr = "tcp://%s:%i" % (self.kernel_manager.ip, port)
         logging.info("Connecting to: %s" % addr)
         sock.connect(addr)
         return ZMQStream(sock)
 
     def get_stream(self, session_id, stream_name):
         session_dict = self._sessions.get(session_id)
         if session_dict is not None:
             return session_dict[stream_name]
         else:
             raise KeyError("Session with id not found: %s" % session_id)
 
     def get_iopub_stream(self, session_id):
         return self.get_stream(session_id, 'iopub_stream')
 
     def get_shell_stream(self, session_id):
         return self.get_stream(session_id, 'shell_stream')