def __init__(self, baseurl=""):
# This matches a kernel id (uuid4 format) from a url
_kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
self.config = misc.Config()
baseurl = baseurl.rstrip('/')
handlers_list = [
(r"/", handlers.RootHandler),
(r"/embedded_sagecell.js", tornado.web.RedirectHandler, {
"url": baseurl + "/static/embedded_sagecell.js"
}),
(r"/help.html", handlers.HelpHandler),
(r"/kernel", handlers.KernelHandler),
(r"/kernel/%s" % _kernel_id_regex, handlers.KernelHandler),
(r"/kernel/%s/channels" % _kernel_id_regex,
handlers.WebChannelsHandler),
(r"/kernel/%s/files/(?P<file_path>.*)" % _kernel_id_regex,
handlers.FileHandler, {
"path": tmp_dir
}),
(r"/permalink", permalink.PermalinkHandler),
(r"/service", handlers.ServiceHandler),
(r"/tos.html", handlers.TOSHandler),
] + handlers.KernelRouter.urls
handlers_list = [[baseurl + i[0]] + list(i[1:]) for i in handlers_list]
settings = dict(template_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)), "templates"),
static_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"static"),
static_url_prefix=baseurl + "/static/",
static_handler_class=handlers.StaticHandler)
initial_comps = self.config.get_config("computers")
default_comp = self.config.get_default_config("_default_config")
max_kernel_timeout = self.config.get_config("max_kernel_timeout")
self.km = TrustedMultiKernelManager(
computers=initial_comps,
default_computer_config=default_comp,
max_kernel_timeout=max_kernel_timeout,
tmp_dir=tmp_dir)
db = __import__('db_' + self.config.get_config('db'))
self.db = db.DB(self.config.get_config('db_config')['uri'])
self.ioloop = zmq.eventloop.IOLoop.instance()
# to check for blocking when debugging, uncomment the following
# and set the argument to the blocking timeout in seconds
self.ioloop.set_blocking_log_threshold(.5)
self.completer = handlers.Completer(self.km)
super(SageCellServer, self).__init__(handlers_list, **settings)
def _initContent(self, initMode=LoadDefault):
self.config = misc.Config(self.config_path)
self.config.config_parser.optionxform = str
self.backup = misc.Config(self.backup_path)
self.backup.config_parser = self.config.config_parser
if initMode == Config.LoadDefault:
self.config.default_config = self._getConfigDefaults()
self.config.load_default()
self.config.write()
elif initMode == Config.LoadConfig:
self.config.load()
self.backup.write()
elif initMode == Config.LoadBackup:
self.backup.load()
self.config.write()
volume = self.fetchFloat("Player", "volume")
self.save("Player", "volume", min(1.0, volume))
# add new keys here
subtitleDelayStep = self.fetch("Subtitle", "delayStep")
if not subtitleDelayStep:
self.save("Subtitle", "delayStep", \
getDefault("Subtitle", "delayStep"))
def __init__(self):
handlers_list = [
(r"/", permalink.PermalinkHandler),
(r"/permalink", permalink.PermalinkHandler),
]
self.config = misc.Config()
db = __import__('db_'+self.config.get_config('permalink_server')['db'])
self.db = db.DB(self.config.get_config('permalink_server')['db_config']['uri'])
#self.ioloop = ioloop.IOLoop.instance()
# to check for blocking when debugging, uncomment the following
# and set the argument to the blocking timeout in seconds
#self.ioloop.set_blocking_log_threshold(.5)
super(PermalinkServer, self).__init__(handlers_list)
def __init__(self):
handlers_list = [
(r"/", handlers.RootHandler),
(r"/kernel", handlers.KernelHandler),
(r"/embedded_sagecell.js", tornado.web.RedirectHandler, {
"url": "/static/embedded_sagecell.js"
}),
(r"/sagecell.html", handlers.SageCellHandler),
(r"/kernel/%s" % _kernel_id_regex, handlers.KernelHandler),
(r"/kernel/%s/iopub" % _kernel_id_regex, handlers.IOPubWebHandler),
(r"/kernel/%s/shell" % _kernel_id_regex, handlers.ShellWebHandler),
(r"/kernel/%s/files/(?P<file_path>.*)" % _kernel_id_regex,
handlers.FileHandler, {
"path": "/tmp/sagecell/"
}),
(r"/permalink", permalink.PermalinkHandler),
(r"/service", handlers.ServiceHandler),
] + handlers.KernelRouter.urls
settings = dict(template_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)), "templates"),
static_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"static"),
static_handler_class=handlers.StaticHandler)
self.config = misc.Config()
initial_comps = self.config.get_config("computers")
default_comp = self.config.get_default_config("_default_config")
kernel_timeout = self.config.get_config("max_kernel_timeout")
self.km = TMKM(computers=initial_comps,
default_computer_config=default_comp,
kernel_timeout=kernel_timeout)
db = __import__('db_' + self.config.get_config('db'))
self.db = db.DB(self.config.get_config('db_config')['uri'])
self.ioloop = ioloop.IOLoop.instance()
# to check for blocking when debugging, uncomment the following
# and set the argument to the blocking timeout in seconds
self.ioloop.set_blocking_log_threshold(.5)
super(SageCellServer, self).__init__(handlers_list, **settings)
def __init__(self):
handlers_list = [
(r"/", handlers.RootHandler),
(r"/kernel", handlers.KernelHandler),
(r"/embedded_sagecell.js", tornado.web.RedirectHandler, {
"url": "/static/embedded_sagecell.js"
}),
(r"/sagecell.html", handlers.SageCellHandler),
(r"/kernel/%s/iopub" % _kernel_id_regex, handlers.IOPubWebHandler),
(r"/kernel/%s/shell" % _kernel_id_regex, handlers.ShellWebHandler),
(r"/kernel/%s/files/(?P<file_path>.*)" % _kernel_id_regex,
handlers.FileHandler, {
"path": "/tmp/sagecell/"
}),
(r"/permalink", handlers.PermalinkHandler),
(r"/service", handlers.ServiceHandler),
] + handlers.KernelRouter.urls
settings = dict(template_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)), "templates"),
static_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"static"),
static_handler_class=handlers.StaticHandler)
self.config = misc.Config()
initial_comps = self.config.get_config("computers")
default_comp = self.config.get_default_config("_default_config")
kernel_timeout = self.config.get_config("max_kernel_timeout")
self.km = TMKM(computers=initial_comps,
default_computer_config=default_comp,
kernel_timeout=kernel_timeout)
self.db = DB(misc.get_db_file(self.config))
self.ioloop = ioloop.IOLoop.instance()
super(SageCellServer, self).__init__(handlers_list, **settings)
""" Create heartbeat 0MQ stream between given kernel and the server.
"""
comp_id = self._kernels[kernel_id]["comp_id"]
cfg = self._comps[comp_id]
connection = self._kernels[kernel_id]["connection"]
hb_stream = self._create_connected_stream(connection["ip"], connection["hb_port"], zmq.REQ)
return hb_stream
def kernel_info(self, kernel_id):
return self._kernels[kernel_id]
if __name__ == "__main__":
import misc
config = misc.Config()
initial_comps = config.get_config("computers")
default_config = config.get_default_config("_default_config")
t = TrustedMultiKernelManager(computers = initial_comps, default_computer_config = default_config)
for i in xrange(5):
t.new_session()
vals = t._comps.values()
for i in xrange(len(vals)):
print "\nComputer #%d has kernels ::: "%i, vals[i]["kernels"].keys()
print "\nList of all kernel ids ::: " + str(t.get_kernel_ids())
y = t.get_kernel_ids()
