def show_runs(worker_identifier):
query_parameters = {
"worker": worker_identifier,
"project": helpers.none_if_empty(flask.request.args.get("project", default = None)),
"status": helpers.none_if_empty(flask.request.args.get("status", default = None)),
}
item_total = service_client.get("/worker/{worker_identifier}/run_count".format(**locals()), query_parameters)
pagination = helpers.get_pagination(item_total, { "worker_identifier": worker_identifier, **query_parameters })
query_parameters.update({
"skip": (pagination["page_number"] - 1) * pagination["item_count"],
"limit": pagination["item_count"],
"order_by": [ "update_date descending" ],
})
view_data = {
"worker": service_client.get("/worker/{worker_identifier}".format(**locals())),
"project_collection": service_client.get("/project_collection".format(**locals()), { "limit": 1000, "order_by": [ "identifier ascending" ] }),
"job_collection": service_client.get("/worker/{worker_identifier}/job_collection".format(**locals()), { "limit": 1000, "order_by": [ "identifier ascending" ] }),
"status_collection": helpers.get_run_status_collection(),
"run_collection": service_client.get("/worker/{worker_identifier}/run_collection".format(**locals()), query_parameters),
"pagination": pagination,
}
helpers.add_display_names(view_data["project_collection"], view_data["job_collection"], view_data["run_collection"], [], [ view_data["worker"] ])
return flask.render_template("worker/runs.html", title = "Runs", **view_data)
def show(user_identifier): # pylint: disable = unused-argument
user = service_client.get("/user/{user_identifier}".format(**locals()))
view_data = {
"user": user,
}
if flask.current_app.authorization_provider.authorize_view(
flask.request.user, "user-security"):
user_tokens = service_client.get(
"/user/{user_identifier}/token_collection".format(**locals()),
{"order_by": ["update_date descending"]})
user_tokens.sort(
key=lambda token: token["expiration_date"] is not None)
now = flask.current_app.date_time_provider.serialize(
flask.current_app.date_time_provider.now())
for token in user_tokens:
token["is_active"] = token["expiration_date"] > now if token[
"expiration_date"] is not None else True
view_data["user_tokens"] = user_tokens
return flask.render_template("user/index.html",
title="User " + user["display_name"],
**view_data)
def index():
view_data = {
"website_information": _get_website_information(),
"service_information": None,
"external_service_collection": None,
}
try:
service_client.get("/")
view_data["service_status"] = { "status": "available" }
except requests.HTTPError as exception:
view_data["service_status"] = {
"status": "unavailable",
"status_code": exception.response.status_code,
"status_message": helpers.get_error_message(exception.response.status_code),
}
if view_data["service_status"]["status"] == "available":
try:
view_data["service_information"] = service_client.get("/admin/information")
view_data["external_service_collection"] = _get_status_for_external_services()
except requests.HTTPError:
logger.error("Failed to retrieve additional service information", exc_info = True)
return flask.render_template("admin/index.html", title = "Administration", **view_data)
def reset_password(user_identifier):
if flask.request.method == "GET":
user = service_client.get("/user/{user_identifier}".format(**locals()))
return flask.render_template("user/reset_password.html",
title="Reset User Password",
user=user)
if flask.request.method == "POST":
parameters = {"password": flask.request.form["password"]}
try:
service_client.post(
"/user/{user_identifier}/reset_password".format(**locals()),
data=parameters)
flask.flash(
"Password for user '%s' was set successfully." %
user_identifier, "success")
return flask.redirect(
flask.url_for("user_controller.show",
user_identifier=user_identifier))
except requests.HTTPError as exception:
flask.flash(
"Password for user '%s' could not be set: %s." %
(user_identifier,
helpers.get_error_message(exception.response.status_code)),
"error")
user = service_client.get(
"/user/{user_identifier}".format(**locals()))
return flask.render_template("user/reset_password.html",
title="Reset User Password",
user=user)
return flask.abort(405)
def show(project_identifier,
job_identifier): # pylint: disable = unused-argument
view_data = {
"project":
service_client.get("/project/{project_identifier}".format(**locals())),
"job":
service_client.get(
"/project/{project_identifier}/job/{job_identifier}".format(
**locals())),
"run_collection":
service_client.get(
"/project/{project_identifier}/job/{job_identifier}/runs".format(
**locals()), {
"limit": 10,
"order_by": ["update_date descending"]
}),
"worker_collection":
service_client.get("/worker_collection", {
"limit": 1000,
"order_by": ["identifier ascending"]
}),
}
view_data["job"]["project_display_name"] = view_data["project"][
"display_name"]
helpers.add_display_names([view_data["project"]], [view_data["job"]],
view_data["run_collection"], [],
view_data["worker_collection"])
return flask.render_template("job/index.html",
title="Job " +
view_data["job"]["display_name"],
**view_data)
def show_collection(project_identifier):
item_total = service_client.get(
"/project/{project_identifier}/job_count".format(**locals()))
pagination = helpers.get_pagination(
item_total, {"project_identifier": project_identifier})
query_parameters = {
"skip": (pagination["page_number"] - 1) * pagination["item_count"],
"limit": pagination["item_count"],
"order_by": ["identifier ascending"],
}
view_data = {
"project":
service_client.get("/project/{project_identifier}".format(**locals())),
"job_collection":
service_client.get(
"/project/{project_identifier}/job_collection".format(**locals()),
query_parameters),
"pagination":
pagination,
}
helpers.add_display_names([view_data["project"]],
view_data["job_collection"], [], [], [])
return flask.render_template("job/collection.html",
title="Jobs",
**view_data)
def _get_status_for_external_services():
external_services = service_client.get("/admin/service_collection")
status_collection = []
for service in external_services:
status_collection.append(service_client.get("/admin/service/{service}".format(service = service)))
return status_collection
def show(project_identifier): # pylint: disable = unused-argument
view_data = {
"project":
service_client.get("/project/{project_identifier}".format(**locals())),
"run_collection":
service_client.get(
"/project/{project_identifier}/run_collection".format(**locals()),
{
"limit": 10,
"order_by": ["update_date descending"]
}),
}
if "revision_control" in view_data["project"]["services"]:
view_data["revision_collection"] = []
for branch in view_data["project"]["services"]["revision_control"][
"branches_for_status"]: # pylint: disable = possibly-unused-variable
branch_status = service_client.get(
"/project/{project_identifier}/repository/revision/{branch}/status"
.format(**locals()))
view_data["revision_collection"].append(branch_status)
job_collection = service_client.get(
"/project/{project_identifier}/job_collection".format(**locals()),
{"order_by": ["identifier ascending"]})
worker_collection = service_client.get(
"/worker_collection", {"order_by": ["identifier ascending"]})
helpers.add_display_names([view_data["project"]], job_collection,
view_data["run_collection"], [],
worker_collection)
return flask.render_template("project/index.html",
title="Project " +
view_data["project"]["display_name"],
**view_data)
def show(project_identifier, schedule_identifier): # pylint: disable = unused-argument
view_data = {
"project": service_client.get("/project/{project_identifier}".format(**locals())),
"schedule": service_client.get("/project/{project_identifier}/schedule/{schedule_identifier}".format(**locals())),
}
view_data["schedule"]["project_display_name"] = view_data["project"]["display_name"]
job_route = "/project/{project_identifier}/job/{job_identifier}".format(project_identifier = project_identifier, job_identifier = view_data["schedule"]["job"])
job = service_client.get_or_default(job_route, default_value = {})
view_data["schedule"]["job_display_name"] = job.get("display_name", view_data["schedule"]["job"])
return flask.render_template("schedule/index.html", title = "Schedule " + schedule_identifier, **view_data)
def show(worker_identifier):
view_data = {
"worker": service_client.get("/worker/{worker_identifier}".format(**locals())),
"project_collection": service_client.get("/project_collection".format(**locals()), { "limit": 1000, "order_by": [ "identifier ascending" ] }),
"job_collection": service_client.get("/worker/{worker_identifier}/job_collection".format(**locals()), { "limit": 1000, "order_by": [ "identifier ascending" ] }),
"run_collection": service_client.get("/worker/{worker_identifier}/run_collection".format(**locals()), { "limit": 10, "order_by": [ "update_date descending" ] }),
}
owner = service_client.get("/user/{user_identifier}".format(user_identifier = view_data["worker"]["owner"]))
view_data["worker"]["owner_display_name"] = owner["display_name"]
helpers.add_display_names(view_data["project_collection"], view_data["job_collection"], view_data["run_collection"], [], [ view_data["worker"] ])
return flask.render_template("worker/index.html", title = "Worker " + worker_identifier, **view_data)
def show_log(project_identifier,
run_identifier): # pylint: disable = unused-argument
view_data = {
"project":
service_client.get("/project/{project_identifier}".format(**locals())),
"run":
service_client.get(
"/project/{project_identifier}/run/{run_identifier}".format(
**locals())),
}
return flask.render_template("run/log.html",
title="Run " + run_identifier[:18],
**view_data)
def show_collection():
item_total = service_client.get("/project_count")
pagination = helpers.get_pagination(item_total, {})
query_parameters = {
"skip": (pagination["page_number"] - 1) * pagination["item_count"],
"limit": pagination["item_count"],
"order_by": ["identifier ascending"],
}
project_collection = service_client.get("/project_collection",
query_parameters)
return flask.render_template("project/collection.html",
title="Projects",
project_collection=project_collection,
pagination=pagination)
def show_profile():
user = service_client.get("/me")
user_tokens = service_client.get("/me/token_collection",
{"order_by": ["update_date descending"]})
user_tokens.sort(key=lambda token: token["expiration_date"] is not None)
now = flask.current_app.date_time_provider.serialize(
flask.current_app.date_time_provider.now())
for token in user_tokens:
token["is_active"] = token["expiration_date"] > now if token[
"expiration_date"] is not None else True
return flask.render_template("me/profile.html",
title="Profile",
user=user,
user_tokens=user_tokens)
def login():
if flask.request.method == "GET":
if "token" in flask.session:
return flask.redirect(flask.url_for("website.home"))
return flask.render_template("me/login.html", title="Log In")
if flask.request.method == "POST":
now = flask.current_app.date_time_provider.now()
parameters = {
"user": flask.request.form["user"],
"password": flask.request.form["password"]
}
try:
flask.session["token"] = service_client.post("/me/login",
data=parameters)
flask.session["user"] = service_client.get("/me")
flask.session[
"last_refresh"] = flask.current_app.date_time_provider.serialize(
now)
flask.session.permanent = True
flask.flash("Login succeeded.", "success")
return flask.redirect(flask.url_for("website.home"))
except requests.HTTPError as exception:
if exception.response.status_code == 403:
flask.session.clear()
flask.flash(
"Login failed: %s." %
helpers.get_error_message(exception.response.status_code),
"error")
return flask.render_template("me/login.html", title="Log In")
return flask.abort(405)
def show_collection():
item_total = service_client.get("/worker_count")
pagination = helpers.get_pagination(item_total, {})
query_parameters = {
"skip": (pagination["page_number"] - 1) * pagination["item_count"],
"limit": pagination["item_count"],
"order_by": [ "identifier ascending" ],
}
view_data = {
"worker_collection": service_client.get("/worker_collection", query_parameters),
"pagination": pagination,
}
return flask.render_template("worker/collection.html", title = "Workers", **view_data)
def show(project_identifier,
run_identifier): # pylint: disable = unused-argument
project = service_client.get(
"/project/{project_identifier}".format(**locals()))
run = service_client.get(
"/project/{project_identifier}/run/{run_identifier}".format(
**locals()))
run_results = service_client.get(
"/project/{project_identifier}/run/{run_identifier}/results".format(
**locals()))
run["project_display_name"] = project["display_name"]
job_route = "/project/{project}/job/{job}".format(
project=project_identifier, job=run["job"])
job = service_client.get_or_default(job_route, default_value={})
run["job_display_name"] = job.get("display_name", run["job"])
if run["source"] is not None:
if run["source"]["type"] == "schedule":
schedule_route = "/project/{project}/schedule/{schedule}".format(
project=project_identifier,
schedule=run["source"]["identifier"])
schedule = service_client.get_or_default(schedule_route,
default_value={})
run["source"]["display_name"] = schedule.get(
"display_name", run["source"]["identifier"])
if run["source"]["type"] == "user":
user_route = "/user/{user}".format(
user=run["source"]["identifier"])
user = service_client.get_or_default(user_route, default_value={})
run["source"]["display_name"] = user.get(
"display_name", run["source"]["identifier"])
if run["worker"] is not None:
worker_route = "/worker/{worker}".format(worker=run["worker"])
worker = service_client.get_or_default(worker_route, default_value={})
run["worker_display_name"] = worker.get("display_name", run["worker"])
view_data = {"project": project, "run": run, "run_results": run_results}
return flask.render_template("run/index.html",
title="Run " + run_identifier[:18],
**view_data)
def edit(user_identifier,
local_parameters=None): # pylint: disable = unused-argument
if local_parameters is None:
local_parameters = {}
user = service_client.get("/user/{user_identifier}".format(**locals()))
flask.request.form = user
flask.request.form.update(local_parameters)
flask.request.form["roles"] = "\n".join(flask.request.form["roles"])
return flask.render_template("user/edit.html",
title="Edit User",
user=user)
def show_collection(project_identifier):
query_parameters = {
"job": helpers.none_if_empty(flask.request.args.get("job", default = None)),
}
item_total = service_client.get("/project/{project_identifier}/schedule_count".format(**locals()), query_parameters)
pagination = helpers.get_pagination(item_total, { "project_identifier": project_identifier, **query_parameters })
query_parameters.update({
"skip": (pagination["page_number"] - 1) * pagination["item_count"],
"limit": pagination["item_count"],
"order_by": [ "identifier ascending" ],
})
view_data = {
"project": service_client.get("/project/{project_identifier}".format(**locals())),
"job_collection": service_client.get("/project/{project_identifier}/job_collection".format(**locals()), { "limit": 1000, "order_by": [ "identifier ascending" ] }),
"schedule_collection": service_client.get("/project/{project_identifier}/schedule_collection".format(**locals()), query_parameters),
"pagination": pagination,
}
helpers.add_display_names([ view_data["project"] ], view_data["job_collection"], [], view_data["schedule_collection"], [])
return flask.render_template("schedule/collection.html", title = "Schedules", **view_data)
def create_token(user_identifier):
if flask.request.method == "GET":
user = service_client.get("/user/{user_identifier}".format(**locals()))
return flask.render_template("user/create_token.html",
title="Create User Authentication Token",
user=user)
if flask.request.method == "POST":
parameters = {"description": flask.request.form["description"]}
if flask.request.form["expiration"]:
parameters["expiration"] = flask.request.form["expiration"]
try:
token = service_client.post(
"/user/{user_identifier}/token_create".format(**locals()),
data=parameters)
flask.flash(
"Token '%s' was created successfully." %
token["token_identifier"], "success")
flask.flash("Token secret: '%s'." % token["secret"], "info")
return flask.redirect(
flask.url_for("user_controller.show",
user_identifier=user_identifier))
except requests.HTTPError as exception:
flask.flash(
"Token could not be created: %s." %
helpers.get_error_message(exception.response.status_code),
"error")
user = service_client.get(
"/user/{user_identifier}".format(**locals()))
return flask.render_template(
"user/create_token.html",
title="Create User Authentication Token",
user=user)
return flask.abort(405)
def refresh_session():
now = flask.current_app.date_time_provider.now()
try:
service_client.post(
"/me/refresh_session",
{"token_identifier": flask.session["token"]["token_identifier"]})
flask.session["user"] = service_client.get("/me")
flask.session[
"last_refresh"] = flask.current_app.date_time_provider.serialize(
now)
except requests.HTTPError as exception:
if exception.response.status_code == 403:
flask.session.clear()
return flask.redirect(flask.url_for("me_controller.show_profile"))
def refresh_session():
if "token" in flask.session:
now = flask.current_app.date_time_provider.now()
last_refresh = flask.session.get("last_refresh", None)
if last_refresh is not None:
last_refresh = flask.current_app.date_time_provider.deserialize(
last_refresh)
if last_refresh is None or now > last_refresh + flask.current_app.session_refresh_interval:
try:
service_client.post("/me/refresh_session", {
"token_identifier":
flask.session["token"]["token_identifier"]
})
flask.session["user"] = service_client.get("/me")
flask.session[
"last_refresh"] = flask.current_app.date_time_provider.serialize(
now)
except requests.HTTPError as exception:
if exception.response.status_code == 403:
flask.session.clear()
flask.request.user = flask.session.get("user", None)
def show_status(project_identifier): # pylint: disable = unused-argument
branch = flask.request.args.get("branch", default=None)
status_limit = max(
min(flask.request.args.get("limit", default=20, type=int), 100), 1)
project = service_client.get(
"/project/{project_identifier}".format(**locals()))
branch_collection = project["services"]["revision_control"][
"branches_for_status"]
job_collection = service_client.get(
"/project/{project_identifier}/job_collection".format(**locals()),
{"order_by": ["identifier ascending"]})
context = {"filter_collection": []}
for job in job_collection:
if job["properties"]["include_in_status"]:
context["filter_collection"].append({
"identifier":
job["identifier"],
"display_name":
job["display_name"],
"job":
job["identifier"],
})
if branch is None:
branch = branch_collection[0]
status_parameters = {
"branch": branch,
"revision_limit": 20,
"run_limit": 1000,
}
status = service_client.get(
"/project/{project_identifier}/status".format(**locals()),
status_parameters)
status = [
revision for index, revision in enumerate(status)
if index == 0 or len(revision["runs"]) > 0
][:status_limit]
for revision in status:
revision["runs_by_filter"] = {
f["identifier"]: []
for f in context["filter_collection"]
}
for run in revision["runs"]:
for run_filter in context["filter_collection"]:
if run["job"] == run_filter["job"]:
revision["runs_by_filter"][
run_filter["identifier"]].append(run)
view_data = {
"project": project,
"project_branch": branch,
"project_branch_collection": branch_collection,
"project_context": context,
"project_status": status,
}
return flask.render_template("project/status.html",
title="Project " + project["display_name"],
**view_data)