notebookapp.py
565 lines
| 21.7 KiB
| text/x-python
|
PythonLexer
|
r6067 | # coding: utf-8 | ||
|
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 | ||
#----------------------------------------------------------------------------- | ||||
|
r5212 | # stdlib | ||
|
r4548 | import errno | ||
|
r4339 | import logging | ||
import os | ||||
|
r6509 | import re | ||
|
r6508 | import select | ||
|
r4345 | import signal | ||
|
r4548 | import socket | ||
|
r4345 | import sys | ||
|
r5212 | import threading | ||
|
r6509 | import time | ||
|
r5065 | import webbrowser | ||
|
r4339 | |||
|
r5212 | # Third party | ||
|
r4339 | import zmq | ||
# Install the pyzmq ioloop. This has to be done before anything else from | ||||
# tornado is imported. | ||||
from zmq.eventloop import ioloop | ||||
|
r6631 | ioloop.install() | ||
|
r4339 | |||
from tornado import httpserver | ||||
from tornado import web | ||||
|
r5212 | # Our own libraries | ||
|
r4545 | from .kernelmanager import MappingKernelManager | ||
|
r5325 | from .handlers import (LoginHandler, LogoutHandler, | ||
|
r5112 | ProjectDashboardHandler, NewHandler, NamedNotebookHandler, | ||
|
r4545 | MainKernelHandler, KernelHandler, KernelActionHandler, IOPubHandler, | ||
|
r5860 | ShellHandler, NotebookRootHandler, NotebookHandler, NotebookCopyHandler, | ||
|
r6191 | RSTHandler, AuthenticatedFileHandler, PrintNotebookHandler, | ||
MainClusterHandler, ClusterProfileHandler, ClusterActionHandler | ||||
|
r4340 | ) | ||
|
r5762 | from .notebookmanager import NotebookManager | ||
|
r6191 | from .clustermanager import ClusterManager | ||
|
r4339 | |||
|
r5762 | from IPython.config.application import catch_config_error, boolean_flag | ||
|
r4344 | from IPython.core.application import BaseIPythonApplication | ||
|
r4345 | from IPython.core.profiledir import ProfileDir | ||
|
r5620 | from IPython.lib.kernel import swallow_argv | ||
|
r4963 | from IPython.zmq.session import Session, default_secure | ||
|
r4345 | from IPython.zmq.zmqshell import ZMQInteractiveShell | ||
from IPython.zmq.ipkernel import ( | ||||
flags as ipkernel_flags, | ||||
aliases as ipkernel_aliases, | ||||
IPKernelApp | ||||
) | ||||
|
r5344 | from IPython.utils.traitlets import Dict, Unicode, Integer, List, Enum, Bool | ||
|
r6067 | from IPython.utils import py3compat | ||
|
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+)" | ||
|
r6191 | _profile_regex = r"(?P<profile>[a-zA-Z0-9]+)" | ||
_cluster_action_regex = r"(?P<action>start|stop)" | ||||
|
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 | #----------------------------------------------------------------------------- | ||
|
r6004 | # Helper functions | ||
#----------------------------------------------------------------------------- | ||||
def url_path_join(a,b): | ||||
if a.endswith('/') and b.startswith('/'): | ||||
return a[:-1]+b | ||||
else: | ||||
return a+b | ||||
#----------------------------------------------------------------------------- | ||||
|
r4344 | # The Tornado web application | ||
#----------------------------------------------------------------------------- | ||||
|
r4339 | |||
|
r4342 | class NotebookWebApplication(web.Application): | ||
|
r4339 | |||
|
r6191 | def __init__(self, ipython_app, kernel_manager, notebook_manager, | ||
cluster_manager, log, | ||||
|
r6004 | base_project_url, settings_overrides): | ||
|
r4339 | handlers = [ | ||
|
r5112 | (r"/", ProjectDashboardHandler), | ||
|
r4690 | (r"/login", LoginHandler), | ||
|
r5325 | (r"/logout", LogoutHandler), | ||
|
r4488 | (r"/new", NewHandler), | ||
|
r4484 | (r"/%s" % _notebook_id_regex, NamedNotebookHandler), | ||
|
r5860 | (r"/%s/copy" % _notebook_id_regex, NotebookCopyHandler), | ||
|
r5875 | (r"/%s/print" % _notebook_id_regex, PrintNotebookHandler), | ||
|
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), | ||
|
r5823 | (r"/rstservice/render", RSTHandler), | ||
|
r5826 | (r"/files/(.*)", AuthenticatedFileHandler, {'path' : notebook_manager.notebook_dir}), | ||
|
r6191 | (r"/clusters", MainClusterHandler), | ||
(r"/clusters/%s/%s" % (_profile_regex, _cluster_action_regex), ClusterActionHandler), | ||||
(r"/clusters/%s" % _profile_regex, ClusterProfileHandler), | ||||
|
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 | ) | ||
|
r5664 | |||
# allow custom overrides for the tornado web app. | ||||
|
r5665 | settings.update(settings_overrides) | ||
|
r5664 | |||
|
r6067 | # Python < 2.6.5 doesn't accept unicode keys in f(**kwargs), and | ||
# base_project_url will always be unicode, which will in turn | ||||
# make the patterns unicode, and ultimately result in unicode | ||||
# keys in kwargs to handler._execute(**kwargs) in tornado. | ||||
# This enforces that base_project_url be ascii in that situation. | ||||
# | ||||
# Note that the URLs these patterns check against are escaped, | ||||
# and thus guaranteed to be ASCII: 'héllo' is really 'h%C3%A9llo'. | ||||
base_project_url = py3compat.unicode_to_str(base_project_url, 'ascii') | ||||
|
r6004 | # prepend base_project_url onto the patterns that we match | ||
new_handlers = [] | ||||
for handler in handlers: | ||||
pattern = url_path_join(base_project_url, handler[0]) | ||||
new_handler = tuple([pattern]+list(handler[1:])) | ||||
new_handlers.append( new_handler ) | ||||
super(NotebookWebApplication, self).__init__(new_handlers, **settings) | ||||
|
r4339 | |||
|
r4545 | self.kernel_manager = kernel_manager | ||
|
r4494 | self.notebook_manager = notebook_manager | ||
|
r6191 | self.cluster_manager = cluster_manager | ||
|
r4572 | self.ipython_app = ipython_app | ||
|
r5213 | self.read_only = self.ipython_app.read_only | ||
|
r6191 | self.log = log | ||
|
r4339 | |||
|
r4346 | |||
|
r4344 | #----------------------------------------------------------------------------- | ||
# Aliases and Flags | ||||
#----------------------------------------------------------------------------- | ||||
flags = dict(ipkernel_flags) | ||||
|
r5065 | flags['no-browser']=( | ||
|
r5128 | {'NotebookApp' : {'open_browser' : False}}, | ||
|
r5065 | "Don't open the notebook in a browser after startup." | ||
) | ||||
|
r5547 | flags['no-mathjax']=( | ||
{'NotebookApp' : {'enable_mathjax' : False}}, | ||||
"""Disable MathJax | ||||
MathJax is the javascript library IPython uses to render math/LaTeX. It is | ||||
very large, so you may want to disable it if you have a slow internet | ||||
connection, or for offline use of the notebook. | ||||
When disabled, equations etc. will appear as their untransformed TeX source. | ||||
""" | ||||
) | ||||
|
r5191 | flags['read-only'] = ( | ||
{'NotebookApp' : {'read_only' : True}}, | ||||
|
r5200 | """Allow read-only access to notebooks. | ||
When using a password to protect the notebook server, this flag | ||||
allows unauthenticated clients to view the notebook list, and | ||||
individual notebooks, but not edit them, start kernels, or run | ||||
code. | ||||
|
r5210 | If no password is set, the server will be entirely read-only. | ||
|
r5200 | """ | ||
|
r5191 | ) | ||
|
r4344 | |||
|
r5762 | # Add notebook manager flags | ||
flags.update(boolean_flag('script', 'NotebookManager.save_script', | ||||
'Auto-save a .py script everytime the .ipynb notebook is saved', | ||||
'Do not auto-save .py scripts for every notebook')) | ||||
|
r5758 | |||
|
r4344 | # 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 | ||||
|
r5762 | notebook_flags = ['no-browser', 'no-mathjax', 'read-only', 'script', 'no-script'] | ||
|
r4344 | |||
aliases = dict(ipkernel_aliases) | ||||
|
r4519 | aliases.update({ | ||
|
r5104 | 'ip': 'NotebookApp.ip', | ||
'port': 'NotebookApp.port', | ||||
'keyfile': 'NotebookApp.keyfile', | ||||
'certfile': 'NotebookApp.certfile', | ||||
|
r4690 | 'notebook-dir': 'NotebookManager.notebook_dir', | ||
|
r6116 | 'browser': 'NotebookApp.browser', | ||
|
r4519 | }) | ||
|
r4344 | |||
|
r4963 | # remove ipkernel flags that are singletons, and don't make sense in | ||
# multi-kernel evironment: | ||||
aliases.pop('f', None) | ||||
|
r5252 | notebook_aliases = [u'port', u'ip', u'keyfile', u'certfile', | ||
|
r4705 | u'notebook-dir'] | ||
|
r4579 | |||
|
r4344 | #----------------------------------------------------------------------------- | ||
|
r5104 | # NotebookApp | ||
|
r4344 | #----------------------------------------------------------------------------- | ||
|
r5104 | class NotebookApp(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.") | ||||
|
r5847 | # create requested profiles by default, if they don't exist: | ||
auto_create = Bool(True) | ||||
|
r6724 | # file to be opened in the notebook server | ||
file_to_run = Unicode('') | ||||
|
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'' | ||||
|
r5344 | port = Integer(8888, config=True, | ||
|
r4344 | help="The port the notebook server will listen on." | ||
) | ||||
|
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, | ||
|
r5321 | help="""Hashed password to use for web authentication. | ||
|
r5337 | To generate, type in a python/IPython shell: | ||
|
r5321 | |||
|
r5337 | from IPython.lib import passwd; passwd() | ||
|
r5321 | |||
The string should be of the form type:salt:hashed-password. | ||||
""" | ||||
|
r4690 | ) | ||
|
r6116 | |||
|
r5065 | open_browser = Bool(True, config=True, | ||
|
r6115 | help="""Whether to open in a browser after starting. | ||
The specific browser used is platform dependent and | ||||
determined by the python standard library `webbrowser` | ||||
|
r6116 | module, unless it is overridden using the --browser | ||
(NotebookApp.browser) configuration option. | ||||
|
r6115 | """) | ||
|
r6116 | |||
browser = Unicode(u'', config=True, | ||||
|
r6117 | help="""Specify what command to use to invoke a web | ||
browser when opening the notebook. If not specified, the | ||||
default browser will be determined by the `webbrowser` | ||||
standard library module, which allows setting of the | ||||
BROWSER environment variable to override it. | ||||
|
r6116 | """) | ||
|
r5191 | |||
read_only = Bool(False, config=True, | ||||
help="Whether to prevent editing/execution of notebooks." | ||||
) | ||||
|
r5547 | |||
|
r5665 | webapp_settings = Dict(config=True, | ||
help="Supply overrides for the tornado.web.Application that the " | ||||
"IPython notebook uses.") | ||||
|
r5547 | enable_mathjax = Bool(True, config=True, | ||
help="""Whether to enable MathJax for typesetting math/TeX | ||||
MathJax is the javascript library IPython uses to render math/LaTeX. It is | ||||
very large, so you may want to disable it if you have a slow internet | ||||
connection, or for offline use of the notebook. | ||||
When disabled, equations etc. will appear as their untransformed TeX source. | ||||
""" | ||||
) | ||||
|
r5557 | def _enable_mathjax_changed(self, name, old, new): | ||
"""set mathjax url to empty if mathjax is disabled""" | ||||
if not new: | ||||
self.mathjax_url = u'' | ||||
|
r6006 | |||
|
r6004 | base_project_url = Unicode('/', config=True, | ||
help='''The base URL for the notebook server''') | ||||
base_kernel_url = Unicode('/', config=True, | ||||
help='''The base URL for the kernel server''') | ||||
|
r6006 | websocket_host = Unicode("", config=True, | ||
help="""The hostname for the websocket server.""" | ||||
) | ||||
|
r6004 | |||
|
r5557 | mathjax_url = Unicode("", config=True, | ||
help="""The url for MathJax.js.""" | ||||
) | ||||
def _mathjax_url_default(self): | ||||
if not self.enable_mathjax: | ||||
return u'' | ||||
|
r5666 | static_path = self.webapp_settings.get("static_path", os.path.join(os.path.dirname(__file__), "static")) | ||
|
r6002 | static_url_prefix = self.webapp_settings.get("static_url_prefix", | ||
"/static/") | ||||
|
r5557 | if os.path.exists(os.path.join(static_path, 'mathjax', "MathJax.js")): | ||
self.log.info("Using local MathJax") | ||||
|
r6002 | return static_url_prefix+u"mathjax/MathJax.js" | ||
|
r5557 | else: | ||
|
r6729 | if self.certfile: | ||
# HTTPS: load from Rackspace CDN, because SSL certificate requires it | ||||
base = u"https://c328740.ssl.cf1.rackcdn.com" | ||||
|
r6155 | else: | ||
|
r6729 | base = u"http://cdn.mathjax.org" | ||
|
r6155 | |||
|
r6729 | url = base + u"/mathjax/latest/MathJax.js" | ||
self.log.info("Using MathJax from CDN: %s", url) | ||||
return url | ||||
|
r5557 | |||
def _mathjax_url_changed(self, name, old, new): | ||||
if new and not self.enable_mathjax: | ||||
# enable_mathjax=False overrides mathjax_url | ||||
self.mathjax_url = u'' | ||||
else: | ||||
self.log.info("Using MathJax: %s", new) | ||||
|
r4690 | |||
|
r4344 | def parse_command_line(self, argv=None): | ||
|
r5104 | super(NotebookApp, self).parse_command_line(argv) | ||
|
r4344 | if argv is None: | ||
argv = sys.argv[1:] | ||||
|
r5620 | # Scrub frontend-specific flags | ||
self.kernel_argv = swallow_argv(argv, notebook_aliases, notebook_flags) | ||||
|
r4609 | # Kernel should inherit default config file from frontend | ||
|
r4345 | self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name) | ||
|
r4344 | |||
|
r6724 | if self.extra_args: | ||
self.file_to_run = os.path.abspath(self.extra_args[0]) | ||||
self.config.NotebookManager.notebook_dir = os.path.dirname(self.file_to_run) | ||||
|
r4494 | def init_configurables(self): | ||
|
r4963 | # force Session default to be secure | ||
default_secure(self.config) | ||||
|
r4344 | # Create a KernelManager and start a kernel. | ||
|
r4545 | self.kernel_manager = MappingKernelManager( | ||
|
r4960 | config=self.config, log=self.log, kernel_argv=self.kernel_argv, | ||
connection_dir = self.profile_dir.security_dir, | ||||
|
r4494 | ) | ||
self.notebook_manager = NotebookManager(config=self.config, log=self.log) | ||||
|
r4622 | self.notebook_manager.list_notebooks() | ||
|
r6191 | self.cluster_manager = ClusterManager(config=self.config, log=self.log) | ||
|
r6199 | self.cluster_manager.update_profiles() | ||
|
r4344 | |||
|
r4345 | def init_logging(self): | ||
|
r5104 | super(NotebookApp, self).init_logging() | ||
|
r4345 | # 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 | ||||
|
r5799 | |||
def init_webapp(self): | ||||
"""initialize tornado webapp and httpserver""" | ||||
|
r4347 | self.web_app = NotebookWebApplication( | ||
|
r6191 | self, self.kernel_manager, self.notebook_manager, | ||
self.cluster_manager, self.log, | ||||
|
r6004 | self.base_project_url, self.webapp_settings | ||
|
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) | ||
|
r5799 | if ssl_options is None and not self.ip and not (self.read_only and not self.password): | ||
|
r4519 | 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. | ||||
|
r5191 | for port in range(self.port, self.port+5) + [self.port + randint(-2*n, 2*n) for i in range(n-5)]: | ||
|
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 | ||||
|
r5799 | |||
|
r6498 | def init_signal(self): | ||
|
r6509 | # FIXME: remove this check when pyzmq dependency is >= 2.1.11 | ||
# safely extract zmq version info: | ||||
try: | ||||
zmq_v = zmq.pyzmq_version_info() | ||||
except AttributeError: | ||||
zmq_v = [ int(n) for n in re.findall(r'\d+', zmq.__version__) ] | ||||
if 'dev' in zmq.__version__: | ||||
zmq_v.append(999) | ||||
zmq_v = tuple(zmq_v) | ||||
if zmq_v >= (2,1,9): | ||||
# This won't work with 2.1.7 and | ||||
# 2.1.9-10 will log ugly 'Interrupted system call' messages, | ||||
# but it will work | ||||
signal.signal(signal.SIGINT, self._handle_sigint) | ||||
|
r6508 | signal.signal(signal.SIGTERM, self._signal_stop) | ||
|
r6498 | |||
|
r6508 | def _handle_sigint(self, sig, frame): | ||
"""SIGINT handler spawns confirmation dialog""" | ||||
# register more forceful signal handler for ^C^C case | ||||
signal.signal(signal.SIGINT, self._signal_stop) | ||||
# request confirmation dialog in bg thread, to avoid | ||||
# blocking the App | ||||
thread = threading.Thread(target=self._confirm_exit) | ||||
thread.daemon = True | ||||
thread.start() | ||||
def _restore_sigint_handler(self): | ||||
"""callback for restoring original SIGINT handler""" | ||||
signal.signal(signal.SIGINT, self._handle_sigint) | ||||
def _confirm_exit(self): | ||||
"""confirm shutdown on ^C | ||||
A second ^C, or answering 'y' within 5s will cause shutdown, | ||||
otherwise original SIGINT handler will be restored. | ||||
""" | ||||
|
r6509 | # FIXME: remove this delay when pyzmq dependency is >= 2.1.11 | ||
time.sleep(0.1) | ||||
|
r6508 | sys.stdout.write("Shutdown Notebook Server (y/[n])? ") | ||
sys.stdout.flush() | ||||
r,w,x = select.select([sys.stdin], [], [], 5) | ||||
if r: | ||||
line = sys.stdin.readline() | ||||
if line.lower().startswith('y'): | ||||
self.log.critical("Shutdown confirmed") | ||||
ioloop.IOLoop.instance().stop() | ||||
return | ||||
else: | ||||
print "No answer for 5s:", | ||||
print "resuming operation..." | ||||
# no answer, or answer is no: | ||||
# set it back to original SIGINT handler | ||||
# use IOLoop.add_callback because signal.signal must be called | ||||
# from main thread | ||||
ioloop.IOLoop.instance().add_callback(self._restore_sigint_handler) | ||||
def _signal_stop(self, sig, frame): | ||||
|
r6498 | self.log.critical("received signal %s, stopping", sig) | ||
ioloop.IOLoop.instance().stop() | ||||
|
r5799 | @catch_config_error | ||
def initialize(self, argv=None): | ||||
super(NotebookApp, self).initialize(argv) | ||||
self.init_configurables() | ||||
self.init_webapp() | ||||
|
r6498 | self.init_signal() | ||
|
r5799 | |||
def cleanup_kernels(self): | ||||
"""shutdown all kernels | ||||
The kernels will shutdown themselves when this process no longer exists, | ||||
but explicit shutdown allows the KernelManagers to cleanup the connection files. | ||||
""" | ||||
self.log.info('Shutting down kernels') | ||||
km = self.kernel_manager | ||||
|
r5838 | # copy list, since kill_kernel deletes keys | ||
for kid in list(km.kernel_ids): | ||||
km.kill_kernel(kid) | ||||
|
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' | ||
|
r5786 | info = self.log.info | ||
|
r6014 | info("The IPython Notebook is running at: %s://%s:%i%s" % | ||
(proto, ip, self.port,self.base_project_url) ) | ||||
|
r5786 | info("Use Control-C to stop this server and shut down all kernels.") | ||
|
r5065 | if self.open_browser: | ||
ip = self.ip or '127.0.0.1' | ||||
|
r6117 | if self.browser: | ||
|
r6116 | browser = webbrowser.get(self.browser) | ||
|
r6129 | else: | ||
browser = webbrowser.get() | ||||
|
r6724 | |||
if self.file_to_run: | ||||
filename, _ = os.path.splitext(os.path.basename(self.file_to_run)) | ||||
for nb in self.notebook_manager.list_notebooks(): | ||||
if filename == nb['name']: | ||||
url = nb['notebook_id'] | ||||
break | ||||
else: | ||||
url = '' | ||||
else: | ||||
url = '' | ||||
b = lambda : browser.open("%s://%s:%i%s%s" % (proto, ip, | ||||
self.port, self.base_project_url, url), | ||||
new=2) | ||||
|
r5212 | threading.Thread(target=b).start() | ||
|
r5799 | try: | ||
ioloop.IOLoop.instance().start() | ||||
except KeyboardInterrupt: | ||||
info("Interrupted...") | ||||
finally: | ||||
self.cleanup_kernels() | ||||
|
r4344 | |||
#----------------------------------------------------------------------------- | ||||
# Main entry point | ||||
#----------------------------------------------------------------------------- | ||||
|
r4339 | |||
|
r4341 | def launch_new_instance(): | ||
|
r5799 | app = NotebookApp.instance() | ||
|
r4344 | app.initialize() | ||
app.start() | ||||
|
r4339 | |||