def launch_session(name, email, reuse=True):
try:
JBoxd._wait_for_session_backup(name)
VolMgr.refresh_disk_use_status()
JBoxContainer.launch_by_name(name, email, reuse=reuse)
finally:
JBoxd.finish_thread()
def monitor_registrations():
max_rate = JBoxDynConfig.get_registration_hourly_rate(
CloudHost.INSTALL_ID)
rate = JBoxUserV2.count_created(1)
reg_allowed = JBoxDynConfig.get_allow_registration(
CloudHost.INSTALL_ID)
CloudHost.log_debug(
"registration allowed: %r, rate: %d, max allowed: %d", reg_allowed,
rate, max_rate)
if (reg_allowed and
(rate > max_rate * 1.1)) or ((not reg_allowed) and
(rate < max_rate * 0.9)):
reg_allowed = not reg_allowed
CloudHost.log_info("Changing registration allowed to %r",
reg_allowed)
JBoxDynConfig.set_allow_registration(CloudHost.INSTALL_ID,
reg_allowed)
if reg_allowed:
num_pending_activations = JBoxUserV2.count_pending_activations()
if num_pending_activations > 0:
CloudHost.log_info(
"scheduling activations for %d pending activations",
num_pending_activations)
JBoxContainer.async_schedule_activations()
def chk_and_launch_docker(self, sessname, creds, authtok, user_id):
cont = JBoxContainer.get_by_name(sessname)
nhops = int(self.get_argument('h', 0))
self.log_debug("got hop " + repr(nhops) + " for session " + repr(sessname))
self.log_debug("have existing container for " + repr(sessname) + ": " + repr(None != cont))
if cont is not None:
self.log_debug("container running: " + str(cont.is_running()))
if ((None == cont) or (not cont.is_running())) and (not CloudHelper.should_accept_session()):
if None != cont:
cont.backup()
cont.delete()
self.clear_container_cookies()
self.set_header('Connection', 'close')
self.request.connection.no_keep_alive = True
if nhops > self.config('numhopmax', 0):
self.rendertpl("index.tpl", cfg=self.config(), state=self.state(
error="Maximum number of JuliaBox instances active. Please try after sometime.", success=''))
else:
self.redirect('/?h=' + str(nhops + 1))
else:
cont = JBoxContainer.launch_by_name(sessname, user_id, True)
(shellport, uplport, ipnbport) = cont.get_host_ports()
sign = signstr(sessname + str(shellport) + str(uplport) + str(ipnbport), self.config("sesskey"))
self.set_container_cookies({
"sessname": sessname,
"hostshell": shellport,
"hostupload": uplport,
"hostipnb": ipnbport,
"sign": sign
})
self.set_lb_tracker_cookie()
self.rendertpl("ipnbsess.tpl", sessname=sessname, cfg=self.config(), creds=creds, authtok=authtok,
user_id=user_id)
def backup_and_cleanup(dockid):
try:
cont = JBoxContainer(dockid)
cont.stop()
cont.delete(backup=True)
finally:
JBoxd.finish_thread()
def __init__(self):
dckr = docker.Client()
cfg = read_config()
cloud_cfg = cfg['cloud_host']
user_activation_cfg = cfg['user_activation']
LoggerMixin.setup_logger(level=cfg['root_log_level'])
LoggerMixin.DEFAULT_LEVEL = cfg['jbox_log_level']
db.configure_db(cfg)
CloudHost.configure(has_s3=cloud_cfg['s3'],
has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'],
has_autoscale=cloud_cfg['autoscale'],
has_route53=cloud_cfg['route53'],
has_ebs=cloud_cfg['ebs'],
has_ses=cloud_cfg['ses'],
scale_up_at_load=cloud_cfg['scale_up_at_load'],
scale_up_policy=cloud_cfg['scale_up_policy'],
autoscale_group=cloud_cfg['autoscale_group'],
route53_domain=cloud_cfg['route53_domain'],
region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
VolMgr.configure(dckr, cfg)
JBoxContainer.configure(dckr, cfg['docker_image'], cfg['mem_limit'], cfg['cpu_limit'],
cfg['numlocalmax'], cfg['async_job_port'], async_mode=JBoxAsyncJob.MODE_SUB)
self.log_debug("Backup daemon listening on port: " + str(cfg['async_job_port']))
self.queue = JBoxContainer.ASYNC_JOB
JBoxd.MAX_ACTIVATIONS_PER_SEC = user_activation_cfg['max_activations_per_sec']
JBoxd.MAX_AUTO_ACTIVATIONS_PER_RUN = user_activation_cfg['max_activations_per_run']
JBoxd.ACTIVATION_SUBJECT = user_activation_cfg['mail_subject']
JBoxd.ACTIVATION_BODY = user_activation_cfg['mail_body']
JBoxd.ACTIVATION_SENDER = user_activation_cfg['sender']
def launch_session(name, email, reuse=True):
try:
JBoxd._wait_for_session_backup(name)
VolMgr.refresh_disk_use_status()
JBoxContainer.launch_by_name(name, email, reuse=reuse)
finally:
JBoxd.finish_thread()
def __init__(self):
dckr = docker.Client()
cfg = read_config()
backup_location = os.path.expanduser(cfg['backup_location'])
user_home_img = os.path.expanduser(cfg['user_home_image'])
mnt_location = os.path.expanduser(cfg['mnt_location'])
cloud_cfg = cfg['cloud_host']
backup_bucket = cloud_cfg['backup_bucket']
make_sure_path_exists(backup_location)
CloudHelper.configure(has_s3=cloud_cfg['s3'], has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'], region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
JBoxContainer.configure(dckr, cfg['docker_image'], cfg['mem_limit'], cfg['cpu_limit'], cfg['disk_limit'],
[os.path.join(mnt_location, '${DISK_ID}')], mnt_location, backup_location,
user_home_img, cfg['numlocalmax'], cfg["numdisksmax"], backup_bucket=backup_bucket)
# backup user files every 1 hour
# check: configured expiry time must be at least twice greater than this
self.run_interval = int(cfg['delete_stopped_timeout']) / 2
if self.run_interval < 3 * 60:
self.run_interval = 3 * 60
self.delete_stopped_timeout = int(cfg['delete_stopped_timeout'])
self.log_info("Backup interval: " + str(self.run_interval / 60) + " minutes")
self.log_info("Stopped containers would be deleted after " + str(self.delete_stopped_timeout / 60) + " minutes")
def is_ready_to_terminate():
if not JBox.cfg['cloud_host']['scale_down']:
return False
num_containers = JBoxContainer.num_active(
) + JBoxContainer.num_stopped()
return (num_containers == 0) and CloudHost.can_terminate(
is_proposed_cluster_leader())
def do_housekeeping():
server_delete_timeout = JBox.cfg['expire']
JBoxContainer.maintain(max_timeout=server_delete_timeout, inactive_timeout=JBox.cfg['inactivity_timeout'],
protected_names=JBox.cfg['protected_docknames'])
if JBox.cfg['scale_down'] and (JBoxContainer.num_active() == 0) and \
(JBoxContainer.num_stopped() == 0) and CloudHelper.should_terminate():
JBox.log_info("terminating to scale down")
CloudHelper.terminate_instance()
def run(self):
try:
CloudHelper.deregister_instance_dns()
except:
CloudHelper.log_info("No prior dns registration found for the instance")
CloudHelper.register_instance_dns()
JBoxContainer.publish_container_stats()
self.ct.start()
self.ioloop.start()
def get(self):
sessname = str(self.get_cookie("sessname")).replace('"', '')
if self.is_valid_req(self):
JBoxContainer.record_ping("/" + sessname)
self.set_status(status_code=204)
self.finish()
else:
self.log_warn("Invalid ping request for " + sessname)
self.send_error(status_code=403)
def __init__(self):
cfg = JBox.cfg = read_config()
dckr = docker.Client()
cloud_cfg = cfg['cloud_host']
JBoxHandler.configure(cfg)
JBoxDB.configure(cfg)
if 'jbox_users_v2' in cloud_cfg:
JBoxUserV2.NAME = cloud_cfg['jbox_users_v2']
if 'jbox_invites' in cloud_cfg:
JBoxInvite.NAME = cloud_cfg['jbox_invites']
if 'jbox_accounting_v2' in cloud_cfg:
JBoxAccountingV2.NAME = cloud_cfg['jbox_accounting_v2']
CloudHelper.configure(has_s3=cloud_cfg['s3'],
has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'],
has_autoscale=cloud_cfg['autoscale'],
has_route53=cloud_cfg['route53'],
scale_up_at_load=cloud_cfg['scale_up_at_load'],
scale_up_policy=cloud_cfg['scale_up_policy'],
autoscale_group=cloud_cfg['autoscale_group'],
route53_domain=cloud_cfg['route53_domain'],
region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
backup_location = os.path.expanduser(cfg['backup_location'])
user_home_img = os.path.expanduser(cfg['user_home_image'])
mnt_location = os.path.expanduser(cfg['mnt_location'])
backup_bucket = cloud_cfg['backup_bucket']
make_sure_path_exists(backup_location)
JBoxContainer.configure(dckr, cfg['docker_image'],
cfg['mem_limit'], cfg['cpu_limit'], cfg['disk_limit'],
[os.path.join(mnt_location, '${DISK_ID}')],
mnt_location, backup_location, user_home_img,
cfg['numlocalmax'], cfg["numdisksmax"],
backup_bucket=backup_bucket)
self.application = tornado.web.Application([
(r"/", MainHandler),
(r"/hostlaunchipnb/", AuthHandler),
(r"/hostadmin/", AdminHandler),
(r"/ping/", PingHandler),
(r"/cors/", CorsHandler)
])
cookie_secret = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in xrange(32))
self.application.settings["cookie_secret"] = cookie_secret
self.application.settings["google_oauth"] = cfg["google_oauth"]
self.application.listen(cfg["port"])
self.ioloop = tornado.ioloop.IOLoop.instance()
# run container maintainence every 5 minutes
run_interval = 5 * 60 * 1000
self.log_info("Container maintenance every " + str(run_interval / (60 * 1000)) + " minutes")
self.ct = tornado.ioloop.PeriodicCallback(JBox.do_housekeeping, run_interval, self.ioloop)
def get(self):
sessname = str(self.get_cookie("sessname")).replace('"', '')
if self.is_valid_req(self):
JBoxContainer.record_ping("/" + sessname)
self.set_status(status_code=204)
self.finish()
else:
self.log_info("Invalid ping request for " + sessname)
self.send_error(status_code=403)
def run(self):
try:
CloudHelper.deregister_instance_dns()
except:
CloudHelper.log_info(
"No prior dns registration found for the instance")
CloudHelper.register_instance_dns()
JBoxContainer.publish_container_stats()
self.ct.start()
self.ioloop.start()
def run(self):
try:
CloudHost.deregister_instance_dns()
except:
CloudHost.log_info("No prior dns registration found for the instance")
CloudHost.register_instance_dns()
JBoxContainer.publish_container_stats()
JBox.do_update_user_home_image()
JBoxContainer.async_refresh_disks()
self.ct.start()
self.ioloop.start()
def run(self):
try:
CloudHost.deregister_instance_dns()
except:
CloudHost.log_info(
"No prior dns registration found for the instance")
CloudHost.register_instance_dns()
JBoxContainer.publish_container_stats()
JBox.do_update_user_home_image()
JBoxContainer.async_refresh_disks()
self.ct.start()
self.ioloop.start()
def run(self):
if CloudHost.ENABLED['route53']:
try:
CloudHost.deregister_instance_dns()
CloudHost.log_warn("Prior dns registration was found for the instance")
except:
CloudHost.log_debug("No prior dns registration found for the instance")
CloudHost.register_instance_dns()
JBoxContainer.publish_container_stats()
JBox.do_update_user_home_image()
JBoxContainer.async_refresh_disks()
self.ct.start()
self.ioloop.start()
def __init__(self):
dckr = docker.Client()
cfg = JBox.cfg = read_config()
cloud_cfg = cfg['cloud_host']
LoggerMixin.setup_logger(level=cfg['root_log_level'])
LoggerMixin.DEFAULT_LEVEL = cfg['jbox_log_level']
JBoxHandler.configure(cfg)
db.configure_db(cfg)
CloudHost.configure(has_s3=cloud_cfg['s3'],
has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'],
has_autoscale=cloud_cfg['autoscale'],
has_route53=cloud_cfg['route53'],
has_ebs=cloud_cfg['ebs'],
has_ses=cloud_cfg['ses'],
scale_up_at_load=cloud_cfg['scale_up_at_load'],
scale_up_policy=cloud_cfg['scale_up_policy'],
autoscale_group=cloud_cfg['autoscale_group'],
route53_domain=cloud_cfg['route53_domain'],
region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
VolMgr.configure(dckr, cfg)
JBoxAsyncJob.configure(cfg)
JBoxContainer.configure(dckr, cfg['docker_image'], cfg['mem_limit'],
cfg['cpu_limit'], cfg['numlocalmax'],
cfg['async_job_ports'])
self.application = tornado.web.Application([
(r"/", MainHandler), (r"/hostlaunchipnb/", AuthHandler),
(r"/hostadmin/", AdminHandler), (r"/ping/", PingHandler),
(r"/cors/", CorsHandler)
])
cookie_secret = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in xrange(32))
self.application.settings["cookie_secret"] = cookie_secret
self.application.settings["google_oauth"] = cfg["google_oauth"]
self.application.listen(cfg["port"])
self.ioloop = tornado.ioloop.IOLoop.instance()
# run container maintainence every 5 minutes
run_interval = 5 * 60 * 1000
self.log_info("Container maintenance every " +
str(run_interval / (60 * 1000)) + " minutes")
self.ct = tornado.ioloop.PeriodicCallback(JBox.do_housekeeping,
run_interval, self.ioloop)
def try_launch_container(cls, user_id):
sessname = unique_sessname(user_id)
cont = JBoxContainer.get_by_name(sessname)
cls.log_debug("have existing container for %s: %r", sessname, None != cont)
if cont is not None:
cls.log_debug("container running: %r", cont.is_running())
if ((cont is None) or (not cont.is_running())) and (not CloudHost.should_accept_session()):
if cont is not None:
cont.async_backup_and_cleanup()
return False
JBoxContainer.async_launch_by_name(sessname, user_id, True)
return True
def __init__(self):
cfg = JBox.cfg = read_config()
dckr = docker.Client()
cloud_cfg = cfg['cloud_host']
JBoxHandler.configure(cfg)
JBoxDB.configure(cfg)
if 'jbox_users_v2' in cloud_cfg:
JBoxUserV2.NAME = cloud_cfg['jbox_users_v2']
if 'jbox_invites' in cloud_cfg:
JBoxInvite.NAME = cloud_cfg['jbox_invites']
if 'jbox_accounting_v2' in cloud_cfg:
JBoxAccountingV2.NAME = cloud_cfg['jbox_accounting_v2']
CloudHelper.configure(has_s3=cloud_cfg['s3'], has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'], region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
backup_location = os.path.expanduser(cfg['backup_location'])
user_home_img = os.path.expanduser(cfg['user_home_image'])
mnt_location = os.path.expanduser(cfg['mnt_location'])
backup_bucket = cloud_cfg['backup_bucket']
make_sure_path_exists(backup_location)
JBoxContainer.configure(dckr, cfg['docker_image'],
cfg['mem_limit'], cfg['cpu_limit'], cfg['disk_limit'],
[os.path.join(mnt_location, '${DISK_ID}')],
mnt_location, backup_location, user_home_img,
cfg['numlocalmax'], cfg["numdisksmax"],
backup_bucket=backup_bucket)
self.application = tornado.web.Application([
(r"/", MainHandler),
(r"/hostlaunchipnb/", AuthHandler),
(r"/hostadmin/", AdminHandler),
(r"/ping/", PingHandler),
(r"/cors/", CorsHandler)
])
cookie_secret = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in xrange(32))
self.application.settings["cookie_secret"] = cookie_secret
self.application.settings["google_oauth"] = cfg["google_oauth"]
self.application.listen(cfg["port"])
self.ioloop = tornado.ioloop.IOLoop.instance()
# run container maintainence every 5 minutes
run_interval = 5 * 60 * 1000
self.log_info("Container maintenance every " + str(run_interval / (60 * 1000)) + " minutes")
self.ct = tornado.ioloop.PeriodicCallback(JBox.do_housekeeping, run_interval, self.ioloop)
def chk_and_launch_docker(self, sessname, creds, authtok, user_id):
cont = JBoxContainer.get_by_name(sessname)
nhops = int(self.get_argument('h', 0))
self.log_debug("got hop " + repr(nhops) + " for session " +
repr(sessname))
self.log_debug("have existing container for " + repr(sessname) + ": " +
repr(None != cont))
if cont is not None:
self.log_debug("container running: " + str(cont.is_running()))
if ((None == cont) or (not cont.is_running())) and (
not CloudHelper.should_accept_session()):
if None != cont:
cont.backup()
cont.delete()
self.clear_container_cookies()
self.set_header('Connection', 'close')
self.request.connection.no_keep_alive = True
if nhops > self.config('numhopmax', 0):
self.rendertpl(
"index.tpl",
cfg=self.config(),
state=self.state(
error=
"Maximum number of JuliaBox instances active. Please try after sometime.",
success=''))
else:
self.redirect('/?h=' + str(nhops + 1))
else:
cont = JBoxContainer.launch_by_name(sessname, True)
(shellport, uplport, ipnbport) = cont.get_host_ports()
sign = signstr(
sessname + str(shellport) + str(uplport) + str(ipnbport),
self.config("sesskey"))
self.set_container_cookies({
"sessname": sessname,
"hostshell": shellport,
"hostupload": uplport,
"hostipnb": ipnbport,
"sign": sign
})
self.set_lb_tracker_cookie()
self.rendertpl("ipnbsess.tpl",
sessname=sessname,
cfg=self.config(),
creds=creds,
authtok=authtok,
user_id=user_id)
def __init__(self):
dckr = docker.Client()
cfg = JBox.cfg = read_config()
cloud_cfg = cfg['cloud_host']
LoggerMixin.setup_logger(level=cfg['root_log_level'])
LoggerMixin.DEFAULT_LEVEL = cfg['jbox_log_level']
JBoxHandler.configure(cfg)
db.configure_db(cfg)
CloudHost.configure(has_s3=cloud_cfg['s3'],
has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'],
has_autoscale=cloud_cfg['autoscale'],
has_route53=cloud_cfg['route53'],
has_ebs=cloud_cfg['ebs'],
has_ses=cloud_cfg['ses'],
scale_up_at_load=cloud_cfg['scale_up_at_load'],
scale_up_policy=cloud_cfg['scale_up_policy'],
autoscale_group=cloud_cfg['autoscale_group'],
route53_domain=cloud_cfg['route53_domain'],
region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
VolMgr.configure(dckr, cfg)
JBoxAsyncJob.configure(cfg)
JBoxContainer.configure(dckr, cfg['docker_image'], cfg['mem_limit'], cfg['cpu_limit'],
cfg['numlocalmax'], cfg['async_job_ports'])
self.application = tornado.web.Application([
(r"/", MainHandler),
(r"/hostlaunchipnb/", AuthHandler),
(r"/hostadmin/", AdminHandler),
(r"/ping/", PingHandler),
(r"/cors/", CorsHandler),
(r"/hw/", HomeworkHandler)
])
cookie_secret = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in xrange(32))
self.application.settings["cookie_secret"] = cookie_secret
self.application.settings["google_oauth"] = cfg["google_oauth"]
self.application.listen(cfg["port"])
self.ioloop = tornado.ioloop.IOLoop.instance()
# run container maintainence every 5 minutes
run_interval = 5 * 60 * 1000
self.log_info("Container maintenance every " + str(run_interval / (60 * 1000)) + " minutes")
self.ct = tornado.ioloop.PeriodicCallback(JBox.do_housekeeping, run_interval, self.ioloop)
def run(self):
if CloudHost.ENABLED['route53']:
try:
CloudHost.deregister_instance_dns()
CloudHost.log_warn(
"Prior dns registration was found for the instance")
except:
CloudHost.log_debug(
"No prior dns registration found for the instance")
CloudHost.register_instance_dns()
JBoxContainer.publish_container_stats()
JBox.do_update_user_home_image()
JBoxContainer.async_refresh_disks()
self.ct.start()
self.ioloop.start()
def _wait_for_session_backup(sessname):
cont = JBoxContainer.get_by_name(sessname)
if (cont is not None) and JBoxd._is_scheduled(
JBoxAsyncJob.CMD_BACKUP_CLEANUP, (cont.dockid, )):
JBoxd.log_debug("Waiting for backup of session %s", sessname)
return False
return True
def monitor_registrations():
max_rate = JBoxDynConfig.get_registration_hourly_rate(CloudHost.INSTALL_ID)
rate = JBoxUserV2.count_created(1)
reg_allowed = JBoxDynConfig.get_allow_registration(CloudHost.INSTALL_ID)
CloudHost.log_debug("registration allowed: %r, rate: %d, max allowed: %d", reg_allowed, rate, max_rate)
if (reg_allowed and (rate > max_rate*1.1)) or ((not reg_allowed) and (rate < max_rate*0.9)):
reg_allowed = not reg_allowed
CloudHost.log_warn("Changing registration allowed to %r", reg_allowed)
JBoxDynConfig.set_allow_registration(CloudHost.INSTALL_ID, reg_allowed)
if reg_allowed:
num_pending_activations = JBoxUserV2.count_pending_activations()
if num_pending_activations > 0:
CloudHost.log_info("scheduling activations for %d pending activations", num_pending_activations)
JBoxContainer.async_schedule_activations()
def __init__(self):
dckr = docker.Client()
cfg = read_config()
backup_location = os.path.expanduser(cfg['backup_location'])
user_home_img = os.path.expanduser(cfg['user_home_image'])
mnt_location = os.path.expanduser(cfg['mnt_location'])
cloud_cfg = cfg['cloud_host']
backup_bucket = cloud_cfg['backup_bucket']
make_sure_path_exists(backup_location)
CloudHelper.configure(has_s3=cloud_cfg['s3'],
has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'],
has_autoscale=cloud_cfg['autoscale'],
has_route53=cloud_cfg['route53'],
scale_up_at_load=cloud_cfg['scale_up_at_load'],
scale_up_policy=cloud_cfg['scale_up_policy'],
autoscale_group=cloud_cfg['autoscale_group'],
route53_domain=cloud_cfg['route53_domain'],
region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
JBoxContainer.configure(dckr,
cfg['docker_image'],
cfg['mem_limit'],
cfg['cpu_limit'],
cfg['disk_limit'],
[os.path.join(mnt_location, '${DISK_ID}')],
mnt_location,
backup_location,
user_home_img,
cfg['numlocalmax'],
cfg["numdisksmax"],
backup_bucket=backup_bucket)
# backup user files every 1 hour
# check: configured expiry time must be at least twice greater than this
self.run_interval = int(cfg['delete_stopped_timeout']) / 2
if self.run_interval < 3 * 60:
self.run_interval = 3 * 60
self.delete_stopped_timeout = int(cfg['delete_stopped_timeout'])
self.log_info("Backup interval: " + str(self.run_interval / 60) +
" minutes")
self.log_info("Stopped containers would be deleted after " +
str(self.delete_stopped_timeout / 60) + " minutes")
def try_launch_container(cls, user_id):
sessname = unique_sessname(user_id)
cont = JBoxContainer.get_by_name(sessname)
cls.log_debug("have existing container for %s: %r", sessname,
None != cont)
if cont is not None:
cls.log_debug("container running: %r", cont.is_running())
is_leader = is_proposed_cluster_leader()
if ((cont is None) or (not cont.is_running())) and (
not CloudHost.should_accept_session(is_leader)):
if cont is not None:
cont.async_backup_and_cleanup()
return False
JBoxContainer.async_launch_by_name(sessname, user_id, True)
return True
def __init__(self):
dckr = docker.Client()
cfg = read_config()
cloud_cfg = cfg['cloud_host']
user_activation_cfg = cfg['user_activation']
LoggerMixin.setup_logger(level=cfg['root_log_level'])
LoggerMixin.DEFAULT_LEVEL = cfg['jbox_log_level']
db.configure_db(cfg)
CloudHost.configure(has_s3=cloud_cfg['s3'],
has_dynamodb=cloud_cfg['dynamodb'],
has_cloudwatch=cloud_cfg['cloudwatch'],
has_autoscale=cloud_cfg['autoscale'],
has_route53=cloud_cfg['route53'],
has_ebs=cloud_cfg['ebs'],
has_ses=cloud_cfg['ses'],
scale_up_at_load=cloud_cfg['scale_up_at_load'],
scale_up_policy=cloud_cfg['scale_up_policy'],
autoscale_group=cloud_cfg['autoscale_group'],
route53_domain=cloud_cfg['route53_domain'],
region=cloud_cfg['region'],
install_id=cloud_cfg['install_id'])
VolMgr.configure(dckr, cfg)
JBoxAsyncJob.configure(cfg)
JBoxContainer.configure(dckr,
cfg['docker_image'],
cfg['mem_limit'],
cfg['cpu_limit'],
cfg['numlocalmax'],
cfg['async_job_ports'],
async_mode=JBoxAsyncJob.MODE_SUB)
self.log_debug("Backup daemon listening on ports: %s",
repr(cfg['async_job_ports']))
JBoxd.QUEUE = JBoxContainer.ASYNC_JOB
JBoxd.MAX_ACTIVATIONS_PER_SEC = user_activation_cfg[
'max_activations_per_sec']
JBoxd.MAX_AUTO_ACTIVATIONS_PER_RUN = user_activation_cfg[
'max_activations_per_run']
JBoxd.ACTIVATION_SUBJECT = user_activation_cfg['mail_subject']
JBoxd.ACTIVATION_BODY = user_activation_cfg['mail_body']
JBoxd.ACTIVATION_SENDER = user_activation_cfg['sender']
def get(self):
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = self.get_session_cookie()
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.send_error()
return
user_id = jbox_cookie['u']
user = JBoxUserV2(user_id)
is_admin = sessname in self.config("admin_sessnames", [])
manage_containers = is_admin or user.has_role(JBoxUserV2.ROLE_MANAGE_CONTAINERS)
show_report = is_admin or user.has_role(JBoxUserV2.ROLE_ACCESS_STATS)
cont = JBoxContainer.get_by_name(sessname)
if cont is None:
self.send_error()
return
if self.handle_if_logout(cont):
return
if self.handle_if_stats(is_admin or show_report):
return
if self.handle_if_show_cfg(is_admin):
return
if self.handle_if_instance_info(is_admin):
return
if self.handle_switch_julia_img(user):
return
juliaboxver, _upgrade_available = self.get_upgrade_available(cont)
jimg_type = 0
if user.has_resource_profile(JBoxUserV2.RES_PROF_JULIA_PKG_PRECOMP):
jimg_type = JBoxUserV2.RES_PROF_JULIA_PKG_PRECOMP
d = dict(
manage_containers=manage_containers,
show_report=show_report,
sessname=sessname,
user_id=user_id,
created=isodate.datetime_isoformat(cont.time_created()),
started=isodate.datetime_isoformat(cont.time_started()),
allowed_till=isodate.datetime_isoformat((cont.time_started() + timedelta(seconds=self.config('expire')))),
mem=cont.get_memory_allocated(),
cpu=cont.get_cpu_allocated(),
disk=cont.get_disk_allocated(),
expire=self.config('expire'),
juliaboxver=juliaboxver,
jimg_type=jimg_type
)
self.rendertpl("ipnbadmin.tpl", d=d, cfg=self.config())
def do_monitor_loading(self, user_id):
sessname = unique_sessname(user_id)
self.log_debug("Monitoring loading of session [%s] user[%s]...", sessname, user_id)
cont = JBoxContainer.get_by_name(sessname)
if (cont is None) or (not cont.is_running()):
loading_step = int(self.get_cookie("loading", 0))
if loading_step > 30:
self.log_error("Could not start instance. Session [%s] for user [%s] didn't load.", sessname, user_id)
self.clear_container_cookies()
self.rendertpl("index.tpl", cfg=self.config(),
state=self.state(
error='Could not start your instance! Please try again.',
pending_activation=False,
user_id=user_id))
return
else:
loading_step += 1
self.set_cookie("loading", str(loading_step))
self.rendertpl("loading.tpl", user_id=user_id)
else:
if self.config("gauth"):
jbuser = JBoxUserV2(user_id)
creds = jbuser.get_gtok()
if creds is not None:
try:
creds_json = json.loads(base64.b64decode(creds))
creds_json = self.renew_creds(creds_json)
authtok = creds_json['access_token']
except:
self.log_warn("stale stored creds. will renew on next use. user: "******"sesskey"))
self.clear_cookie("loading")
self.set_container_cookies({
"sessname": sessname,
"hostshell": shellport,
"hostupload": uplport,
"hostipnb": ipnbport,
"sign": sign
})
self.set_lb_tracker_cookie()
self.rendertpl("ipnbsess.tpl", sessname=sessname, cfg=self.config(), creds=creds, authtok=authtok,
user_id=user_id)
def do_housekeeping():
terminating = False
server_delete_timeout = JBox.cfg['expire']
JBoxContainer.maintain(max_timeout=server_delete_timeout, inactive_timeout=JBox.cfg['inactivity_timeout'],
protected_names=JBox.cfg['protected_docknames'])
if is_cluster_leader():
CloudHost.log_info("I am the cluster leader")
JBox.monitor_registrations()
if not JBoxDynConfig.is_stat_collected_within(CloudHost.INSTALL_ID, 7):
JBoxContainer.async_collect_stats()
elif JBox.is_ready_to_terminate():
terminating = True
JBox.log_info("terminating to scale down")
try:
CloudHost.deregister_instance_dns()
except:
CloudHost.log_error("Error deregistering instance dns")
CloudHost.terminate_instance()
if not terminating:
JBox.do_update_user_home_image()
def try_launch_container(cls, user_id, max_hop=False):
sessname = unique_sessname(user_id)
cont = JBoxContainer.get_by_name(sessname)
cls.log_debug("have existing container for %s: %r", sessname, None != cont)
if cont is not None:
cls.log_debug("container running: %r", cont.is_running())
if max_hop:
self_load = CloudHost.get_instance_stats(CloudHost.instance_id(), 'Load')
if self_load < 100:
JBoxContainer.async_launch_by_name(sessname, user_id, True)
return True
is_leader = is_proposed_cluster_leader()
if ((cont is None) or (not cont.is_running())) and (not CloudHost.should_accept_session(is_leader)):
if cont is not None:
cont.async_backup_and_cleanup()
return False
JBoxContainer.async_launch_by_name(sessname, user_id, True)
return True
def backup_and_cleanup(dockid):
try:
cont = JBoxContainer(dockid)
cont.stop()
cont.delete(backup=True)
finally:
JBoxd.finish_thread()
def do_housekeeping():
terminating = False
server_delete_timeout = JBox.cfg['expire']
JBoxContainer.maintain(max_timeout=server_delete_timeout,
inactive_timeout=JBox.cfg['inactivity_timeout'],
protected_names=JBox.cfg['protected_docknames'])
if is_cluster_leader():
CloudHost.log_info("I am the cluster leader")
JBox.monitor_registrations()
if not JBoxDynConfig.is_stat_collected_within(
CloudHost.INSTALL_ID, 7):
JBoxContainer.async_collect_stats()
elif JBox.is_ready_to_terminate():
terminating = True
JBox.log_info("terminating to scale down")
try:
CloudHost.deregister_instance_dns()
except:
CloudHost.log_error("Error deregistering instance dns")
CloudHost.terminate_instance()
if not terminating:
JBox.do_update_user_home_image()
def do_monitor_loading_ajax(self, user_id):
sessname = unique_sessname(user_id)
self.log_debug("AJAX monitoring loading of session [%s] user[%s]...",
sessname, user_id)
cont = JBoxContainer.get_by_name(sessname)
if (cont is None) or (not cont.is_running()):
loading_step = int(self.get_cookie("loading", 0))
if loading_step > 30:
self.write({'code': -1})
return
loading_step += 1
self.set_cookie("loading", str(loading_step))
self.write({'code': 0})
else:
self.write({'code': 1})
def do_monitor_loading_ajax(self, user_id):
sessname = unique_sessname(user_id)
self.log_debug("AJAX monitoring loading of session [%s] user[%s]...", sessname, user_id)
cont = JBoxContainer.get_by_name(sessname)
if (cont is None) or (not cont.is_running()):
loading_step = int(self.get_cookie("loading", 0))
if loading_step > 30:
self.log_error("Could not start instance. Session [%s] for user [%s] didn't load.", sessname, user_id)
self.write({'code': -1})
return
loading_step += 1
self.set_cookie("loading", str(loading_step))
self.write({'code': 0})
else:
self.write({'code': 1})
def is_valid_req(cls, req):
sessname = req.get_cookie("sessname")
if None == sessname:
return False
sessname = sessname.replace('"', '')
hostshell = req.get_cookie("hostshell").replace('"', '')
hostupl = req.get_cookie("hostupload").replace('"', '')
hostipnb = req.get_cookie("hostipnb").replace('"', '')
signval = req.get_cookie("sign").replace('"', '')
sign = signstr(sessname + hostshell + hostupl + hostipnb, cls._config["sesskey"])
if sign != signval:
cls.log_info('not valid req. signature not matching')
return False
if not JBoxContainer.is_valid_container("/" + sessname, (hostshell, hostupl, hostipnb)):
cls.log_info('not valid req. container deleted or ports not matching')
return False
return True
def handle_if_instance_info(self, is_allowed):
stats = self.get_argument('instance_info', None)
if stats is None:
return False
if not is_allowed:
AdminHandler.log_error("Show instance info not allowed for user")
response = {'code': -1, 'data': 'You do not have permissions to view these stats'}
else:
try:
if stats == 'load':
result = {}
# get cluster loads
average_load = CloudHost.get_cluster_average_stats('Load')
if None != average_load:
result['Average Load'] = average_load;
machine_loads = CloudHost.get_cluster_stats('Load')
if None != machine_loads:
for n, v in machine_loads.iteritems():
result['Instance ' + n] = v
elif stats == 'sessions':
result = {}
if CloudHost.ENABLED['autoscale']:
instances = CloudHost.get_autoscaled_instances()
else:
instances = ['localhost']
for idx in range(0, len(instances)):
inst = instances[idx]
result[inst] = JBoxContainer.sync_session_status(inst)['data']
else:
raise Exception("unknown command %s" % (stats,))
response = {'code': 0, 'data': result}
except:
AdminHandler.log_error("exception while getting stats")
AdminHandler._get_logger().exception("exception while getting stats")
response = {'code': -1, 'data': 'error getting stats'}
self.write(response)
return True
def post(self):
self.log_debug("Homework handler got POST request")
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = self.get_session_cookie()
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.log_info(
"Homework handler got invalid sessname[%r] or cookie[%r]",
sessname, jbox_cookie)
self.send_error()
return
user_id = jbox_cookie['u']
user = JBoxUserV2(user_id)
is_admin = sessname in self.config(
"admin_sessnames", []) or user.has_role(JBoxUserV2.ROLE_SUPER)
course_owner = is_admin or user.has_role(JBoxUserV2.ROLE_OFFER_COURSES)
cont = JBoxContainer.get_by_name(sessname)
self.log_info("user_id[%r], is_admin[%r], course_owner[%r]", user_id,
is_admin, course_owner)
if cont is None:
self.log_info("user_id[%r] container not found", user_id)
self.send_error()
return
courses_offered = user.get_courses_offered()
if self.handle_if_check(user_id):
return
if self.handle_create_course(user_id):
return
if self.handle_get_metadata(is_admin, courses_offered):
return
if course_owner and self.handle_if_report(user_id, is_admin,
courses_offered):
return
self.log_error("no handlers found")
# only AJAX requests responded to
self.send_error()
def is_valid_req(cls, req):
sessname = req.get_cookie("sessname")
if None == sessname:
return False
sessname = sessname.replace('"', '')
hostshell = req.get_cookie("hostshell").replace('"', '')
hostupl = req.get_cookie("hostupload").replace('"', '')
hostipnb = req.get_cookie("hostipnb").replace('"', '')
signval = req.get_cookie("sign").replace('"', '')
sign = signstr(sessname + hostshell + hostupl + hostipnb,
cls._config["sesskey"])
if sign != signval:
cls.log_info('not valid req. signature not matching')
return False
if not JBoxContainer.is_valid_container(
"/" + sessname, (hostshell, hostupl, hostipnb)):
cls.log_info(
'not valid req. container deleted or ports not matching')
return False
return True
def post(self):
self.log_debug("Homework handler got POST request")
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = self.get_session_cookie()
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.log_info("Homework handler got invalid sessname[%r] or cookie[%r]", sessname, jbox_cookie)
self.send_error()
return
user_id = jbox_cookie['u']
user = JBoxUserV2(user_id)
is_admin = sessname in self.config("admin_sessnames", []) or user.has_role(JBoxUserV2.ROLE_SUPER)
course_owner = is_admin or user.has_role(JBoxUserV2.ROLE_OFFER_COURSES)
cont = JBoxContainer.get_by_name(sessname)
self.log_info("user_id[%r], is_admin[%r], course_owner[%r]", user_id, is_admin, course_owner)
if cont is None:
self.log_info("user_id[%r] container not found", user_id)
self.send_error()
return
courses_offered = user.get_courses_offered()
if self.handle_if_check(user_id):
return
if self.handle_create_course(user_id):
return
if self.handle_get_metadata(is_admin, courses_offered):
return
if course_owner and self.handle_if_report(user_id, is_admin, courses_offered):
return
self.log_error("no handlers found")
# only AJAX requests responded to
self.send_error()
def do_containers(self):
sections = []
loads = []
iac = []
ac = []
sections.append(["Active", ac])
sections.append(["Inactive", iac])
delete_id = self.get_argument("delete_id", '')
stop_id = self.get_argument("stop_id", '')
stop_all = (self.get_argument('stop_all', None) is not None)
if stop_all:
all_containers = JBoxContainer.DCKR.containers(all=False)
for c in all_containers:
cont = JBoxContainer(c['Id'])
cname = cont.get_name()
if None == cname:
self.log_info("Admin: Not stopping unknown " +
cont.debug_str())
elif cname not in self.config("protected_docknames"):
cont.stop()
elif not (stop_id == ''):
cont = JBoxContainer(stop_id)
cont.stop()
elif not (delete_id == ''):
cont = JBoxContainer(delete_id)
cont.delete()
# get them all again (in case we deleted some)
jsonobj = JBoxContainer.DCKR.containers(all=all)
for c in jsonobj:
o = dict()
o["Id"] = c["Id"][0:12]
o["Status"] = c["Status"]
if ("Names" in c) and (c["Names"] is not None):
o["Name"] = c["Names"][0]
else:
o["Name"] = "/None"
if (c["Ports"] is None) or (c["Ports"] == []):
iac.append(o)
else:
ac.append(o)
# get cluster loads
average_load = CloudHelper.get_cluster_average_stats('Load')
if None != average_load:
loads.append({'instance': 'Average', 'load': average_load})
machine_loads = CloudHelper.get_cluster_stats('Load')
if None != machine_loads:
for n, v in machine_loads.iteritems():
loads.append({'instance': n, 'load': v})
return sections, loads
def do_monitor_loading(self, user_id):
sessname = unique_sessname(user_id)
self.log_debug("Monitoring loading of session [%s] user[%s]...",
sessname, user_id)
cont = JBoxContainer.get_by_name(sessname)
if (cont is None) or (not cont.is_running()):
loading_step = int(self.get_cookie("loading", 0))
if loading_step > 30:
self.log_error(
"Could not start instance. Session [%s] for user [%s] didn't load.",
sessname, user_id)
self.clear_container_cookies()
self.rendertpl(
"index.tpl",
cfg=self.config(),
state=self.state(
error=
'Could not start your instance! Please try again.',
pending_activation=False,
user_id=user_id))
return
else:
loading_step += 1
self.set_cookie("loading", str(loading_step))
self.rendertpl("loading.tpl", user_id=user_id)
else:
if self.config("gauth"):
jbuser = JBoxUserV2(user_id)
creds = jbuser.get_gtok()
if creds is not None:
try:
creds_json = json.loads(base64.b64decode(creds))
creds_json = self.renew_creds(creds_json)
authtok = creds_json['access_token']
except:
self.log_warn(
"stale stored creds. will renew on next use. user: "******"sesskey"))
self.clear_cookie("loading")
self.set_container_cookies({
"sessname": sessname,
"hostshell": shellport,
"hostupload": uplport,
"hostipnb": ipnbport,
"sign": sign
})
self.set_lb_tracker_cookie()
self.rendertpl("ipnbsess.tpl",
sessname=sessname,
cfg=self.config(),
creds=creds,
authtok=authtok,
user_id=user_id)
def do_update_user_home_image():
if VolMgr.has_update_for_user_home_image():
if not VolMgr.update_user_home_image(fetch=False):
JBoxContainer.async_update_user_home_image()
def is_ready_to_terminate():
if not JBox.cfg['cloud_host']['scale_down']:
return False
num_containers = JBoxContainer.num_active() + JBoxContainer.num_stopped()
return (num_containers == 0) and CloudHost.can_terminate(is_proposed_cluster_leader())
def get(self):
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = self.get_session_cookie()
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.send_error()
return
user_id = jbox_cookie['u']
user = JBoxUserV2(user_id)
is_admin = sessname in self.config("admin_sessnames", [])
manage_containers = is_admin or user.has_role(
JBoxUserV2.ROLE_MANAGE_CONTAINERS)
show_report = is_admin or user.has_role(JBoxUserV2.ROLE_ACCESS_STATS)
cont = JBoxContainer.get_by_name(sessname)
if cont is None:
self.send_error()
return
if self.handle_if_logout(cont):
return
if self.handle_if_stats(is_admin):
return
if self.handle_if_show_cfg(is_admin):
return
if self.handle_if_instance_info(is_admin):
return
juliaboxver, _upgrade_available = self.get_upgrade_available(cont)
sections = []
report = {}
report_span = 'day'
if manage_containers:
sections = self.do_containers()
if show_report:
today = datetime.now()
if self.get_argument('range', 'day') == 'week':
dates = [today - timedelta(days=i) for i in range(6, -1, -1)]
report_span = 'week'
else:
dates = [today]
report = JBoxAccountingV2.get_stats(dates)
d = dict(manage_containers=manage_containers,
show_report=show_report,
report_span=report_span,
sessname=sessname,
user_id=user_id,
created=isodate.datetime_isoformat(cont.time_created()),
started=isodate.datetime_isoformat(cont.time_started()),
allowed_till=isodate.datetime_isoformat(
(cont.time_started() +
timedelta(seconds=self.config('expire')))),
mem=cont.get_memory_allocated(),
cpu=cont.get_cpu_allocated(),
disk=cont.get_disk_allocated(),
expire=self.config('expire'),
sections=sections,
report=report,
juliaboxver=juliaboxver)
self.rendertpl("ipnbadmin.tpl", d=d, cfg=self.config())
def do_containers(self):
sections = []
iac = []
ac = []
sections.append(["Active", ac])
sections.append(["Inactive", iac])
delete_id = self.get_argument("delete_id", '')
stop_id = self.get_argument("stop_id", '')
stop_all = (self.get_argument('stop_all', None) is not None)
if stop_all:
all_containers = JBoxContainer.DCKR.containers(all=False)
for c in all_containers:
cont = JBoxContainer(c['Id'])
cname = cont.get_name()
if None == cname:
self.log_info("Admin: Not stopping unknown " +
cont.debug_str())
elif cname not in self.config("protected_docknames"):
cont.stop()
elif not (stop_id == ''):
cont = JBoxContainer(stop_id)
cont.stop()
elif not (delete_id == ''):
cont = JBoxContainer(delete_id)
cont.delete()
# get them all again (in case we deleted some)
jsonobj = JBoxContainer.DCKR.containers(all=all)
for c in jsonobj:
o = dict()
o["Id"] = c["Id"][0:12]
o["Status"] = c["Status"]
if ("Names" in c) and (c["Names"] is not None):
o["Name"] = c["Names"][0]
else:
o["Name"] = "/None"
if (c["Ports"] is None) or (c["Ports"] == []):
iac.append(o)
else:
ac.append(o)
return sections
def do_containers(self):
sections = []
loads = []
iac = []
ac = []
sections.append(["Active", ac])
sections.append(["Inactive", iac])
delete_id = self.get_argument("delete_id", '')
stop_id = self.get_argument("stop_id", '')
stop_all = (self.get_argument('stop_all', None) is not None)
if stop_all:
all_containers = JBoxContainer.DCKR.containers(all=False)
for c in all_containers:
cont = JBoxContainer(c['Id'])
cname = cont.get_name()
if None == cname:
self.log_info("Admin: Not stopping unknown " + cont.debug_str())
elif cname not in self.config("protected_docknames"):
cont.stop()
elif not (stop_id == ''):
cont = JBoxContainer(stop_id)
cont.stop()
elif not (delete_id == ''):
cont = JBoxContainer(delete_id)
cont.delete()
# get them all again (in case we deleted some)
jsonobj = JBoxContainer.DCKR.containers(all=all)
for c in jsonobj:
o = dict()
o["Id"] = c["Id"][0:12]
o["Status"] = c["Status"]
if ("Names" in c) and (c["Names"] is not None):
o["Name"] = c["Names"][0]
else:
o["Name"] = "/None"
if (c["Ports"] is None) or (c["Ports"] == []):
iac.append(o)
else:
ac.append(o)
# get cluster loads
average_load = CloudHelper.get_cluster_average_stats('Load')
if None != average_load:
loads.append({'instance': 'Average', 'load': average_load})
machine_loads = CloudHelper.get_cluster_stats('Load')
if None != machine_loads:
for n, v in machine_loads.iteritems():
loads.append({'instance': n, 'load': v})
return sections, loads
def do_containers(self):
sections = []
iac = []
ac = []
sections.append(["Active", ac])
sections.append(["Inactive", iac])
delete_id = self.get_argument("delete_id", '')
stop_id = self.get_argument("stop_id", '')
stop_all = (self.get_argument('stop_all', None) is not None)
if stop_all:
all_containers = JBoxContainer.DCKR.containers(all=False)
for c in all_containers:
cont = JBoxContainer(c['Id'])
cname = cont.get_name()
if None == cname:
self.log_info("Admin: Not stopping unknown " + cont.debug_str())
elif cname not in self.config("protected_docknames"):
cont.stop()
elif not (stop_id == ''):
cont = JBoxContainer(stop_id)
cont.stop()
elif not (delete_id == ''):
cont = JBoxContainer(delete_id)
cont.delete()
# get them all again (in case we deleted some)
jsonobj = JBoxContainer.DCKR.containers(all=all)
for c in jsonobj:
o = dict()
o["Id"] = c["Id"][0:12]
o["Status"] = c["Status"]
if ("Names" in c) and (c["Names"] is not None):
o["Name"] = c["Names"][0]
else:
o["Name"] = "/None"
if (c["Ports"] is None) or (c["Ports"] == []):
iac.append(o)
else:
ac.append(o)
return sections
def do_update_user_home_image():
if VolMgr.has_update_for_user_home_image():
if not VolMgr.update_user_home_image(fetch=False):
JBoxContainer.async_update_user_home_image()
def run(self):
while True:
JBoxContainer.backup_and_cleanup(self.delete_stopped_timeout)
time.sleep(self.run_interval)
def get(self):
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = AuthHandler.get_session_cookie(self)
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.send_error()
return
user_id = jbox_cookie['u']
cont = JBoxContainer.get_by_name(sessname)
if cont is None:
self.send_error()
return
juliaboxver, upgrade_available = self.get_upgrade_available(cont)
if self.do_upgrade(cont, upgrade_available):
response = {'code': 0, 'data': ''}
self.write(response)
return
user = JBoxUserV2(user_id)
show_report = (sessname in self.config("report_sessnames", []) or
user.get_role() == JBoxUserV2.ROLE_REPORT)
admin_user = (sessname in self.config("admin_sessnames", []) or
user.get_role() == JBoxUserV2.ROLE_ADMIN)
show_report = show_report or admin_user
sections = []
loads = []
report = {}
report_span = 'day'
if admin_user:
sections, loads = self.admin_stats()
if show_report:
today = datetime.now()
if self.get_argument('range', 'day') == 'week':
dates = [today - timedelta(days=i) for i in range(6, -1, -1)]
report_span = 'week'
else:
dates = [today]
report = JBoxAccountingV2.get_stats(dates)
d = dict(
admin_user=admin_user,
show_report=show_report,
report_span=report_span,
sessname=sessname,
user_id=user_id,
created=isodate.datetime_isoformat(cont.time_created()),
started=isodate.datetime_isoformat(cont.time_started()),
allowed_till=isodate.datetime_isoformat((cont.time_started() + timedelta(seconds=self.config('expire')))),
mem=cont.get_memory_allocated(),
cpu=cont.get_cpu_allocated(),
disk=cont.get_disk_allocated(),
expire=self.config('expire'),
sections=sections,
loads=loads,
report=report,
juliaboxver=juliaboxver,
upgrade_available=upgrade_available
)
self.rendertpl("ipnbadmin.tpl", d=d, cfg=self.config())
def backup_and_cleanup(dockid):
cont = JBoxContainer(dockid)
cont.stop()
cont.delete(backup=True)
def run(self):
while True:
JBoxContainer.backup_and_cleanup(self.delete_stopped_timeout)
time.sleep(self.run_interval)
def get(self):
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = self.get_session_cookie()
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.send_error()
return
user_id = jbox_cookie['u']
user = JBoxUserV2(user_id)
is_admin = sessname in self.config("admin_sessnames", [])
manage_containers = is_admin or user.has_role(JBoxUserV2.ROLE_MANAGE_CONTAINERS)
show_report = is_admin or user.has_role(JBoxUserV2.ROLE_ACCESS_STATS)
cont = JBoxContainer.get_by_name(sessname)
if cont is None:
self.send_error()
return
if self.handle_if_logout(cont):
return
if self.handle_if_stats(is_admin):
return
if self.handle_if_show_cfg(is_admin):
return
if self.handle_if_instance_info(is_admin):
return
juliaboxver, _upgrade_available = self.get_upgrade_available(cont)
sections = []
report = {}
report_span = 'day'
if manage_containers:
sections = self.do_containers()
if show_report:
today = datetime.now()
if self.get_argument('range', 'day') == 'week':
dates = [today - timedelta(days=i) for i in range(6, -1, -1)]
report_span = 'week'
else:
dates = [today]
report = JBoxAccountingV2.get_stats(dates)
d = dict(
manage_containers=manage_containers,
show_report=show_report,
report_span=report_span,
sessname=sessname,
user_id=user_id,
created=isodate.datetime_isoformat(cont.time_created()),
started=isodate.datetime_isoformat(cont.time_started()),
allowed_till=isodate.datetime_isoformat((cont.time_started() + timedelta(seconds=self.config('expire')))),
mem=cont.get_memory_allocated(),
cpu=cont.get_cpu_allocated(),
disk=cont.get_disk_allocated(),
expire=self.config('expire'),
sections=sections,
report=report,
juliaboxver=juliaboxver
)
self.rendertpl("ipnbadmin.tpl", d=d, cfg=self.config())
def get(self):
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = AuthHandler.get_session_cookie(self)
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.send_error()
return
user_id = jbox_cookie['u']
cont = JBoxContainer.get_by_name(sessname)
if cont is None:
self.send_error()
return
juliaboxver, upgrade_available = self.get_upgrade_available(cont)
if self.do_upgrade(cont, upgrade_available):
response = {'code': 0, 'data': ''}
self.write(response)
return
user = JBoxUserV2(user_id)
is_admin = sessname in self.config("admin_sessnames", [])
manage_containers = is_admin or user.has_role(JBoxUserV2.ROLE_MANAGE_CONTAINERS)
show_report = is_admin or user.has_role(JBoxUserV2.ROLE_ACCESS_STATS)
invites_perm = is_admin or user.has_role(JBoxUserV2.ROLE_MANAGE_INVITES)
sections = []
loads = []
report = {}
report_span = 'day'
invites_info = []
action = self.get_argument("action", None)
#invite_code = self.request.get("invite_code", None)
if action == "invites_report" and invites_perm:
self.write(dict(
code=0,
data=[obj for obj in JBoxInvite.table().scan()]))
return
if manage_containers:
sections, loads = self.do_containers()
if show_report:
today = datetime.now()
if self.get_argument('range', 'day') == 'week':
dates = [today - timedelta(days=i) for i in range(6, -1, -1)]
report_span = 'week'
else:
dates = [today]
report = JBoxAccountingV2.get_stats(dates)
d = dict(
manage_containers=manage_containers,
show_report=show_report,
invites_perm=invites_perm,
report_span=report_span,
sessname=sessname,
user_id=user_id,
created=isodate.datetime_isoformat(cont.time_created()),
started=isodate.datetime_isoformat(cont.time_started()),
allowed_till=isodate.datetime_isoformat((cont.time_started() + timedelta(seconds=self.config('expire')))),
mem=cont.get_memory_allocated(),
cpu=cont.get_cpu_allocated(),
disk=cont.get_disk_allocated(),
expire=self.config('expire'),
sections=sections,
loads=loads,
report=report,
juliaboxver=juliaboxver,
upgrade_available=upgrade_available
)
self.rendertpl("ipnbadmin.tpl", d=d, cfg=self.config())
def get(self):
sessname = unquote(self.get_cookie("sessname"))
jbox_cookie = AuthHandler.get_session_cookie(self)
if (None == sessname) or (len(sessname) == 0) or (None == jbox_cookie):
self.send_error()
return
user_id = jbox_cookie['u']
cont = JBoxContainer.get_by_name(sessname)
if cont is None:
self.send_error()
return
juliaboxver, upgrade_available = self.get_upgrade_available(cont)
if self.do_upgrade(cont, upgrade_available):
response = {'code': 0, 'data': ''}
self.write(response)
return
user = JBoxUserV2(user_id)
is_admin = sessname in self.config("admin_sessnames", [])
manage_containers = is_admin or user.has_role(
JBoxUserV2.ROLE_MANAGE_CONTAINERS)
show_report = is_admin or user.has_role(JBoxUserV2.ROLE_ACCESS_STATS)
invites_perm = is_admin or user.has_role(
JBoxUserV2.ROLE_MANAGE_INVITES)
sections = []
loads = []
report = {}
report_span = 'day'
invites_info = []
action = self.get_argument("action", None)
#invite_code = self.request.get("invite_code", None)
if action == "invites_report" and invites_perm:
self.write(
dict(code=0, data=[obj for obj in JBoxInvite.table().scan()]))
return
if manage_containers:
sections, loads = self.do_containers()
if show_report:
today = datetime.now()
if self.get_argument('range', 'day') == 'week':
dates = [today - timedelta(days=i) for i in range(6, -1, -1)]
report_span = 'week'
else:
dates = [today]
report = JBoxAccountingV2.get_stats(dates)
d = dict(manage_containers=manage_containers,
show_report=show_report,
invites_perm=invites_perm,
report_span=report_span,
sessname=sessname,
user_id=user_id,
created=isodate.datetime_isoformat(cont.time_created()),
started=isodate.datetime_isoformat(cont.time_started()),
allowed_till=isodate.datetime_isoformat(
(cont.time_started() +
timedelta(seconds=self.config('expire')))),
mem=cont.get_memory_allocated(),
cpu=cont.get_cpu_allocated(),
disk=cont.get_disk_allocated(),
expire=self.config('expire'),
sections=sections,
loads=loads,
report=report,
juliaboxver=juliaboxver,
upgrade_available=upgrade_available)
self.rendertpl("ipnbadmin.tpl", d=d, cfg=self.config())
