notebookapp.py
288 lines
| 10.5 KiB
| text/x-python
|
PythonLexer
|
r4609 | """A tornado based IPython notebook server. | ||
Authors: | ||||
* Brian Granger | ||||
""" | ||||
|
r4344 | |||
#----------------------------------------------------------------------------- | ||||
|
r4609 | # Copyright (C) 2008-2011 The IPython Development Team | ||
|
r4348 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
|
r4609 | # the file COPYING, distributed as part of this software. | ||
|
r4348 | #----------------------------------------------------------------------------- | ||
#----------------------------------------------------------------------------- | ||||
|
r4344 | # Imports | ||
#----------------------------------------------------------------------------- | ||||
|
r4548 | import errno | ||
|
r4339 | import logging | ||
import os | ||||
|
r4345 | import signal | ||
|
r4548 | import socket | ||
|
r4345 | import sys | ||
|
r4339 | |||
import zmq | ||||
# Install the pyzmq ioloop. This has to be done before anything else from | ||||
# tornado is imported. | ||||
from zmq.eventloop import ioloop | ||||
import tornado.ioloop | ||||
|
r4829 | tornado.ioloop.IOLoop = ioloop.IOLoop | ||
|
r4339 | |||
from tornado import httpserver | ||||
from tornado import web | ||||
|
r4545 | from .kernelmanager import MappingKernelManager | ||
|
r4690 | from .handlers import (LoginHandler, | ||
|
r4488 | NBBrowserHandler, NewHandler, NamedNotebookHandler, | ||
|
r4545 | MainKernelHandler, KernelHandler, KernelActionHandler, IOPubHandler, | ||
ShellHandler, NotebookRootHandler, NotebookHandler, RSTHandler | ||||
|
r4340 | ) | ||
|
r4484 | from .notebookmanager import NotebookManager | ||
|
r4339 | |||
|
r4344 | from IPython.core.application import BaseIPythonApplication | ||
|
r4345 | from IPython.core.profiledir import ProfileDir | ||
|
r4344 | from IPython.zmq.session import Session | ||
|
r4345 | from IPython.zmq.zmqshell import ZMQInteractiveShell | ||
from IPython.zmq.ipkernel import ( | ||||
flags as ipkernel_flags, | ||||
aliases as ipkernel_aliases, | ||||
IPKernelApp | ||||
) | ||||
|
r4545 | from IPython.utils.traitlets import Dict, Unicode, Int, List, Enum | ||
|
r4344 | |||
#----------------------------------------------------------------------------- | ||||
# Module globals | ||||
#----------------------------------------------------------------------------- | ||||
|
r4339 | |||
_kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)" | ||||
_kernel_action_regex = r"(?P<action>restart|interrupt)" | ||||
|
r4484 | _notebook_id_regex = r"(?P<notebook_id>\w+-\w+-\w+-\w+-\w+)" | ||
|
r4339 | |||
|
r4345 | LOCALHOST = '127.0.0.1' | ||
|
r4519 | _examples = """ | ||
ipython notebook # start the notebook | ||||
ipython notebook --profile=sympy # use the sympy profile | ||||
ipython notebook --pylab=inline # pylab in inline plotting mode | ||||
ipython notebook --certfile=mycert.pem # use SSL/TLS certificate | ||||
ipython notebook --port=5555 --ip=* # Listen on port 5555, all interfaces | ||||
""" | ||||
|
r4344 | #----------------------------------------------------------------------------- | ||
# The Tornado web application | ||||
#----------------------------------------------------------------------------- | ||||
|
r4339 | |||
|
r4342 | class NotebookWebApplication(web.Application): | ||
|
r4339 | |||
|
r4572 | def __init__(self, ipython_app, kernel_manager, notebook_manager, log): | ||
|
r4339 | handlers = [ | ||
|
r4488 | (r"/", NBBrowserHandler), | ||
|
r4690 | (r"/login", LoginHandler), | ||
|
r4488 | (r"/new", NewHandler), | ||
|
r4484 | (r"/%s" % _notebook_id_regex, NamedNotebookHandler), | ||
|
r4494 | (r"/kernels", MainKernelHandler), | ||
(r"/kernels/%s" % _kernel_id_regex, KernelHandler), | ||||
|
r4339 | (r"/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler), | ||
|
r4545 | (r"/kernels/%s/iopub" % _kernel_id_regex, IOPubHandler), | ||
(r"/kernels/%s/shell" % _kernel_id_regex, ShellHandler), | ||||
|
r4339 | (r"/notebooks", NotebookRootHandler), | ||
|
r4507 | (r"/notebooks/%s" % _notebook_id_regex, NotebookHandler), | ||
(r"/rstservice/render", RSTHandler) | ||||
|
r4339 | ] | ||
settings = dict( | ||||
template_path=os.path.join(os.path.dirname(__file__), "templates"), | ||||
static_path=os.path.join(os.path.dirname(__file__), "static"), | ||||
|
r4705 | cookie_secret=os.urandom(1024), | ||
|
r4690 | login_url="/login", | ||
|
r4339 | ) | ||
web.Application.__init__(self, handlers, **settings) | ||||
|
r4545 | self.kernel_manager = kernel_manager | ||
|
r4344 | self.log = log | ||
|
r4494 | self.notebook_manager = notebook_manager | ||
|
r4572 | self.ipython_app = ipython_app | ||
|
r4339 | |||
|
r4346 | |||
|
r4344 | #----------------------------------------------------------------------------- | ||
# Aliases and Flags | ||||
#----------------------------------------------------------------------------- | ||||
flags = dict(ipkernel_flags) | ||||
# the flags that are specific to the frontend | ||||
# these must be scrubbed before being passed to the kernel, | ||||
# or it will raise an error on unrecognized flags | ||||
notebook_flags = [] | ||||
aliases = dict(ipkernel_aliases) | ||||
|
r4519 | aliases.update({ | ||
'ip': 'IPythonNotebookApp.ip', | ||||
'port': 'IPythonNotebookApp.port', | ||||
'keyfile': 'IPythonNotebookApp.keyfile', | ||||
'certfile': 'IPythonNotebookApp.certfile', | ||||
|
r4572 | 'ws-hostname': 'IPythonNotebookApp.ws_hostname', | ||
|
r4690 | 'notebook-dir': 'NotebookManager.notebook_dir', | ||
|
r4519 | }) | ||
|
r4344 | |||
|
r4579 | notebook_aliases = [u'port', u'ip', u'keyfile', u'certfile', u'ws-hostname', | ||
|
r4705 | u'notebook-dir'] | ||
|
r4579 | |||
|
r4344 | #----------------------------------------------------------------------------- | ||
# IPythonNotebookApp | ||||
#----------------------------------------------------------------------------- | ||||
class IPythonNotebookApp(BaseIPythonApplication): | ||||
|
r4519 | |||
|
r4344 | name = 'ipython-notebook' | ||
default_config_file_name='ipython_notebook_config.py' | ||||
description = """ | ||||
The IPython HTML Notebook. | ||||
This launches a Tornado based HTML Notebook Server that serves up an | ||||
HTML5/Javascript Notebook client. | ||||
""" | ||||
|
r4519 | examples = _examples | ||
|
r4344 | |||
classes = [IPKernelApp, ZMQInteractiveShell, ProfileDir, Session, | ||||
|
r4545 | MappingKernelManager, NotebookManager] | ||
|
r4344 | flags = Dict(flags) | ||
aliases = Dict(aliases) | ||||
kernel_argv = List(Unicode) | ||||
|
r4345 | log_level = Enum((0,10,20,30,40,50,'DEBUG','INFO','WARN','ERROR','CRITICAL'), | ||
default_value=logging.INFO, | ||||
config=True, | ||||
help="Set the log level by value or name.") | ||||
|
r4519 | # Network related information. | ||
|
r4344 | ip = Unicode(LOCALHOST, config=True, | ||
help="The IP address the notebook server will listen on." | ||||
) | ||||
|
r4519 | def _ip_changed(self, name, old, new): | ||
if new == u'*': self.ip = u'' | ||||
|
r4344 | port = Int(8888, config=True, | ||
help="The port the notebook server will listen on." | ||||
) | ||||
|
r4572 | ws_hostname = Unicode(LOCALHOST, config=True, | ||
help="""The FQDN or IP for WebSocket connections. The default will work | ||||
fine when the server is listening on localhost, but this needs to | ||||
be set if the ip option is used. It will be used as the hostname part | ||||
of the WebSocket url: ws://hostname/path.""" | ||||
) | ||||
|
r4519 | certfile = Unicode(u'', config=True, | ||
help="""The full path to an SSL/TLS certificate file.""" | ||||
) | ||||
keyfile = Unicode(u'', config=True, | ||||
help="""The full path to a private key file for usage with SSL/TLS.""" | ||||
) | ||||
|
r4344 | |||
|
r4705 | password = Unicode(u'', config=True, | ||
help="""Password to use for web authentication""" | ||||
|
r4690 | ) | ||
|
r4572 | def get_ws_url(self): | ||
"""Return the WebSocket URL for this server.""" | ||||
if self.certfile: | ||||
prefix = u'wss://' | ||||
else: | ||||
prefix = u'ws://' | ||||
return prefix + self.ws_hostname + u':' + unicode(self.port) | ||||
|
r4344 | def parse_command_line(self, argv=None): | ||
super(IPythonNotebookApp, self).parse_command_line(argv) | ||||
if argv is None: | ||||
argv = sys.argv[1:] | ||||
self.kernel_argv = list(argv) # copy | ||||
|
r4609 | # Kernel should inherit default config file from frontend | ||
|
r4345 | self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name) | ||
|
r4609 | # Scrub frontend-specific flags | ||
|
r4344 | for a in argv: | ||
|
r4345 | if a.startswith('-') and a.lstrip('-') in notebook_flags: | ||
|
r4344 | self.kernel_argv.remove(a) | ||
|
r4579 | for a in argv: | ||
if a.startswith('-'): | ||||
alias = a.lstrip('-').split('=')[0] | ||||
if alias in notebook_aliases: | ||||
self.kernel_argv.remove(a) | ||||
|
r4344 | |||
|
r4494 | def init_configurables(self): | ||
|
r4344 | # Don't let Qt or ZMQ swallow KeyboardInterupts. | ||
signal.signal(signal.SIGINT, signal.SIG_DFL) | ||||
# Create a KernelManager and start a kernel. | ||||
|
r4545 | self.kernel_manager = MappingKernelManager( | ||
config=self.config, log=self.log, kernel_argv=self.kernel_argv | ||||
|
r4494 | ) | ||
self.notebook_manager = NotebookManager(config=self.config, log=self.log) | ||||
|
r4622 | self.notebook_manager.list_notebooks() | ||
|
r4344 | |||
|
r4345 | def init_logging(self): | ||
super(IPythonNotebookApp, self).init_logging() | ||||
# This prevents double log messages because tornado use a root logger that | ||||
# self.log is a child of. The logging module dipatches log messages to a log | ||||
# and all of its ancenstors until propagate is set to False. | ||||
self.log.propagate = False | ||||
|
r4344 | def initialize(self, argv=None): | ||
super(IPythonNotebookApp, self).initialize(argv) | ||||
|
r4494 | self.init_configurables() | ||
|
r4347 | self.web_app = NotebookWebApplication( | ||
|
r4572 | self, self.kernel_manager, self.notebook_manager, self.log | ||
|
r4347 | ) | ||
|
r4519 | if self.certfile: | ||
ssl_options = dict(certfile=self.certfile) | ||||
if self.keyfile: | ||||
ssl_options['keyfile'] = self.keyfile | ||||
else: | ||||
ssl_options = None | ||||
|
r4705 | self.web_app.password = self.password | ||
|
r4519 | self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options) | ||
if ssl_options is None and not self.ip: | ||||
self.log.critical('WARNING: the notebook server is listening on all IP addresses ' | ||||
'but not using any encryption or authentication. This is highly ' | ||||
'insecure and not recommended.') | ||||
|
r4609 | |||
# Try random ports centered around the default. | ||||
from random import randint | ||||
n = 50 # Max number of attempts, keep reasonably large. | ||||
for port in [self.port] + [self.port + randint(-2*n, 2*n) for i in range(n)]: | ||||
|
r4548 | try: | ||
self.http_server.listen(port, self.ip) | ||||
except socket.error, e: | ||||
if e.errno != errno.EADDRINUSE: | ||||
raise | ||||
|
r4609 | self.log.info('The port %i is already in use, trying another random port.' % port) | ||
|
r4548 | else: | ||
self.port = port | ||||
break | ||||
|
r4344 | |||
def start(self): | ||||
|
r4519 | ip = self.ip if self.ip else '[all ip addresses on your system]' | ||
|
r4682 | proto = 'https' if self.certfile else 'http' | ||
|
r4680 | self.log.info("The IPython Notebook is running at: %s://%s:%i" % (proto, | ||
ip, | ||||
self.port)) | ||||
|
r4344 | ioloop.IOLoop.instance().start() | ||
#----------------------------------------------------------------------------- | ||||
# Main entry point | ||||
#----------------------------------------------------------------------------- | ||||
|
r4339 | |||
|
r4341 | def launch_new_instance(): | ||
|
r4344 | app = IPythonNotebookApp() | ||
app.initialize() | ||||
app.start() | ||||
|
r4339 | |||