def route_create_ensemble_workflow(ensemble):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, ensemble)
name = request.form.get("name", None)
if name is None:
raise EMError("Specify ensemble workflow 'name'")
priority = request.form.get("priority", 0)
basedir = request.form.get("basedir")
if basedir is None:
raise EMError(
"Specify 'basedir' where plan command should be executed")
plan_command = request.form.get("plan_command")
if plan_command is None:
raise EMError(
"Specify 'plan_command' that should be executed to plan workflow")
dao.create_ensemble_workflow(e.id, name, basedir, priority, plan_command)
g.session.commit()
return api.json_created(
url_for("route_get_ensemble_workflow",
ensemble=ensemble,
workflow=name))
def route_analyze_ensemble_workflow(ensemble, workflow):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, ensemble)
w = dao.get_ensemble_workflow(e.id, workflow)
report = "".join(analyze(w))
resp = make_response(report, 200)
resp.headers["Content-Type"] = "text/plain"
return resp
def loop_forever(self):
while True:
u = user.get_user_by_uid(os.getuid())
session = connection.connect(
u.get_master_db_url(), connect_args={"check_same_thread": False}
)
try:
dao = Ensembles(session)
self.loop_once(dao)
finally:
session.close()
time.sleep(self.interval)
def route_create_ensemble():
name = request.form.get("name", None)
if name is None:
raise EMError("Specify ensemble name")
max_running = request.form.get("max_running", 1)
max_planning = request.form.get("max_planning", 1)
dao = Ensembles(g.session)
dao.create_ensemble(g.user.username, name, max_running, max_planning)
g.session.commit()
return api.json_created(
url_for("route_get_ensemble", name=name, _external=True))
def route_update_ensemble_workflow(ensemble, workflow):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, ensemble)
w = dao.get_ensemble_workflow(e.id, workflow)
priority = request.form.get("priority", None)
if priority is not None:
w.set_priority(priority)
state = request.form.get("state", None)
if state is not None:
w.change_state(state)
w.set_updated()
g.session.commit()
return api.json_response(w.get_detail_object())
def route_delete_trigger(ensemble, trigger):
# verify that ensemble exists for user
e_dao = Ensembles(g.session)
# raises EMError code 404 if does not exist
ensemble_id = e_dao.get_ensemble(g.user.username, ensemble).id
# update trigger state to be STOPPED so that the TriggerManager can
# handle it appropriately
t_dao = Triggers(g.session)
# make sure get_trigger raises 404 if nothing found
trigger_id = t_dao.get_trigger(ensemble_id, trigger).id
t_dao.update_state(ensemble_id, trigger_id)
# TODO: what to return here
# return HTTP code that represents that it was successful and that nothing
# is to returned
# status code 204, nothing else to return
return "hello world from delete_trigger!"
def route_create_trigger(ensemble, trigger):
# verify that ensemble exists for user
e_dao = Ensembles(g.session)
# raises EMError code 404 if does not exist
ensemble_id = e_dao.get_ensemble(g.user.username, ensemble).id
# create trigger entry in db
t_dao = Triggers(g.session)
trigger_type = request.form.get("type")
kwargs = {
"ensemble_id": ensemble_id,
"trigger": trigger,
"trigger_type": trigger_type,
"workflow_script": request.form.get("workflow_script"),
"workflow_args": json.loads(request.form.get("workflow_args")),
}
if trigger_type == TriggerType.CRON.value:
# add cron trigger specific parameters
kwargs["interval"] = request.form.get("interval")
kwargs["timeout"] = request.form.get("timeout")
elif trigger_type == TriggerType.FILE_PATTERN.value:
# add file pattern specific parameters
kwargs["interval"] = request.form.get("interval")
kwargs["timeout"] = request.form.get("timeout")
kwargs["file_patterns"] = json.loads(request.form.get("file_patterns"))
else:
raise NotImplementedError(
"encountered unsupported trigger type: {}".format(trigger_type))
t_dao.insert_trigger(**kwargs)
# TODO: what to return here
# return ID that was created, in this case trigger name is sufficient
# probably code 201
# use Flask response object and a json object representing an id of the entity
return "hello world from create_trigger!"
def run(self):
"""Trigger manager main loop."""
self.log.info("trigger manager starting")
while True:
# TODO: user will always be the same.., keep this in the loop or move it out
u = user.get_user_by_uid(os.getuid())
session = connection.connect(
u.get_master_db_url(),
connect_args={"check_same_thread": False})
try:
self.trigger_dao = Triggers(session)
self.ensemble_dao = Ensembles(session)
triggers = self.trigger_dao.list_triggers()
self.log.info("processing {} triggers".format(len(triggers)))
for t in triggers:
t_name = TriggerManager.get_tname(t)
if t.state == "READY":
self.start_trigger(t)
elif t.state == "RUNNING" and t_name not in self.running:
# restart
self.log.debug(
"{} not in memory, restarting it".format(t_name))
self.start_trigger(t)
elif t.state == "RUNNING" and not self.running[
t_name].is_alive():
# exited
self.log.debug(
"{} exited, removing references to it".format(
t_name))
self.stop_trigger(t)
elif t.state == "STOPPED":
self.stop_trigger(t)
finally:
session.close()
time.sleep(self.polling_rate)
def route_update_ensemble(name):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, name)
max_running = request.form.get("max_running", None)
if max_running is not None:
e.set_max_running(max_running)
max_planning = request.form.get("max_planning", None)
if max_planning is not None:
e.set_max_planning(max_planning)
state = request.form.get("state", None)
if state is not None:
if state != e.state:
# TODO Do the necessary state transition
e.set_state(state)
e.set_updated()
g.session.commit()
return api.json_response(e.get_object())
def route_get_ensemble(name):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, name)
result = e.get_object()
return api.json_response(result)
def route_list_ensembles():
dao = Ensembles(g.session)
ensembles = dao.list_ensembles(g.user.username)
result = [e.get_object() for e in ensembles]
return api.json_response(result)
def route_get_ensemble_workflow(ensemble, workflow):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, ensemble)
w = dao.get_ensemble_workflow(e.id, workflow)
result = w.get_detail_object()
return api.json_response(result)
def route_list_ensemble_workflows(name):
dao = Ensembles(g.session)
e = dao.get_ensemble(g.user.username, name)
result = [w.get_object() for w in dao.list_ensemble_workflows(e.id)]
return api.json_response(result)