Build custom container images / build (map[base_image:php:8-fpm-alpine build_args:PHP_VERSION=8
context:php8-pgsql fingerprint_command:{ apk info -v | LC_ALL=C sort; find /usr/local/lib/php/extensions /usr/local/etc/php/conf.d -type f -exec sha256sum {} + | LC_ALL=C sort; }
name:ph… (push) Successful in 40s
Build custom container images / build (map[base_image:postgres:18 build_args:PG_VERSION=18
POSTGIS_VERSION=3
VCHORD_VERSION=0.5.3
context:postgres fingerprint_command:{ dpkg-query -W -f='${binary:Package}=${Version}\n' | LC_ALL=C sort; find /usr/lib/postgresql -type f -exec sha256su… (push) Successful in 49s
Build custom container images / build (map[base_image:python:3 build_args:PYTHON_VERSION=3
context:python-tools fingerprint_command:{ dpkg-query -W -f='${binary:Package}=${Version}\n' | LC_ALL=C sort; pip freeze | LC_ALL=C sort; }
name:python-tools oci_labels:org.opencontainers.ima… (push) Successful in 1m37s
Build custom container images / build (map[base_image:python:3.12-slim build_args:PYTHON_VERSION=3.12-slim
context:linkki-tiedotus fingerprint_command:{ dpkg-query -W -f='${binary:Package}=${Version}\n' | LC_ALL=C sort; pip freeze | LC_ALL=C sort; }
name:linkki-tiedotus oci_labels:… (push) Successful in 36s
Build custom container images / build (map[base_image:python:3.12-slim build_args:PYTHON_VERSION=3.12-slim
context:timepoll fingerprint_command:{ dpkg-query -W -f='${binary:Package}=${Version}\n' | LC_ALL=C sort; pip freeze | LC_ALL=C sort; }
name:timepoll oci_labels:org.opencontai… (push) Successful in 42s
351 lines
12 KiB
JavaScript
351 lines
12 KiB
JavaScript
const output = document.querySelector("#run-output");
|
|
|
|
if (output) {
|
|
let offset = Number(output.dataset.outputOffset || 0);
|
|
let detailsFinalized = !["queued", "running"].includes(
|
|
document.querySelector("#run-status")?.dataset.runStatus,
|
|
);
|
|
const refresh = async () => {
|
|
let delay = 2000;
|
|
try {
|
|
const url = new URL(output.dataset.outputUrl, window.location.href);
|
|
url.searchParams.set("offset", String(offset));
|
|
const response = await fetch(url, { cache: "no-store" });
|
|
if (!response.ok) {
|
|
return;
|
|
}
|
|
const state = await response.json();
|
|
if (state.reset) {
|
|
output.replaceChildren();
|
|
}
|
|
if (state.output) {
|
|
output.append(document.createTextNode(state.output));
|
|
}
|
|
offset = state.offset;
|
|
const status = document.querySelector("#run-status");
|
|
if (status) {
|
|
status.textContent = state.display_status;
|
|
status.dataset.runStatus = state.status;
|
|
const progress = document.querySelector("#run-progress");
|
|
if (progress && progress.textContent !== (state.progress || "—")) {
|
|
progress.textContent = state.progress || "—";
|
|
}
|
|
if (state.has_more) {
|
|
delay = 0;
|
|
} else if (state.status !== "queued" && state.status !== "running") {
|
|
if (!detailsFinalized) {
|
|
const pageResponse = await fetch(window.location.href, { cache: "no-store" });
|
|
if (!pageResponse.ok) {
|
|
return;
|
|
}
|
|
const page = new DOMParser().parseFromString(await pageResponse.text(), "text/html");
|
|
const nextDetails = page.querySelector("#run-status")?.closest("dl");
|
|
if (!nextDetails) {
|
|
return;
|
|
}
|
|
const actions = 'form[action$="/cancel"], form[action$="/execute"]';
|
|
document.querySelectorAll(actions).forEach((form) => form.remove());
|
|
status.closest("dl").replaceWith(nextDetails);
|
|
nextDetails.after(...page.querySelectorAll(actions));
|
|
initializeTaskForms(page);
|
|
detailsFinalized = true;
|
|
}
|
|
const artifacts = document.querySelector("#run-artifacts");
|
|
if (artifacts) {
|
|
await refreshArtifacts(artifacts);
|
|
}
|
|
delay = null;
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.warn("Could not refresh run details:", error);
|
|
} finally {
|
|
if (delay !== null) {
|
|
window.setTimeout(refresh, delay);
|
|
}
|
|
}
|
|
};
|
|
refresh();
|
|
}
|
|
|
|
const refreshArtifacts = async (container) => {
|
|
const response = await fetch(container.dataset.artifactsUrl, { cache: "no-store" });
|
|
if (!response.ok) {
|
|
return [];
|
|
}
|
|
const artifacts = (await response.json()).artifacts;
|
|
const list = container.querySelector("ul");
|
|
list.replaceChildren();
|
|
for (const artifact of artifacts) {
|
|
const item = document.createElement("li");
|
|
const link = document.createElement("a");
|
|
if (artifact.view_url) {
|
|
link.href = artifact.view_url;
|
|
link.target = "_blank";
|
|
link.rel = "noopener";
|
|
link.textContent = `Open ${artifact.name}`;
|
|
} else {
|
|
link.href = artifact.url;
|
|
link.textContent = `Download ${artifact.name}`;
|
|
}
|
|
item.append(link);
|
|
list.append(item);
|
|
}
|
|
container.hidden = artifacts.length === 0;
|
|
return artifacts;
|
|
};
|
|
|
|
for (const container of document.querySelectorAll("#run-artifacts")) {
|
|
if (!output) {
|
|
refreshArtifacts(container);
|
|
}
|
|
}
|
|
|
|
for (const choice of document.querySelectorAll("button[data-execution-choice]")) {
|
|
choice.addEventListener("click", () => {
|
|
const control = choice.closest(".split-button");
|
|
const value = control?.querySelector("input[data-execution-value]");
|
|
const label = control?.querySelector(".button-label");
|
|
if (!control || !value || !label) {
|
|
return;
|
|
}
|
|
value.value = choice.dataset.value || "";
|
|
label.textContent = choice.dataset.label || "Run";
|
|
control.querySelectorAll("button[data-execution-choice]").forEach((option) => {
|
|
option.setAttribute("aria-pressed", String(option === choice));
|
|
});
|
|
const menu = control.querySelector("details");
|
|
if (menu) {
|
|
menu.open = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
const activeStatus = (status) => status === "queued" || status === "running";
|
|
const taskControllers = new Map();
|
|
let tasksStateUrl;
|
|
let taskStateVersion = 0;
|
|
let refreshingTasks = false;
|
|
let taskRefreshTimer;
|
|
|
|
const downloadArtifacts = async (run) => {
|
|
const response = await fetch(run.artifacts_url, { cache: "no-store" });
|
|
if (!response.ok) {
|
|
throw new Error("Could not read task downloads. Open the run details to download them.");
|
|
}
|
|
const artifact = (await response.json()).artifacts.find((item) => !item.view_url);
|
|
if (artifact) {
|
|
const link = document.createElement("a");
|
|
link.href = artifact.url;
|
|
link.download = "";
|
|
document.body.append(link);
|
|
link.click();
|
|
link.remove();
|
|
}
|
|
};
|
|
|
|
function taskController(form, initialState) {
|
|
const result = form.querySelector(".task-result");
|
|
const message = result.querySelector(".task-message");
|
|
const progress = result.querySelector(".task-progress");
|
|
let state = initialState;
|
|
let observedRun = state.active_run;
|
|
let submitting = false;
|
|
let lastResult;
|
|
let previousMessage;
|
|
|
|
const render = (text, kind = "", run = null, progressText = "", suffix = "", label = "View details") => {
|
|
const signature = JSON.stringify([text, kind, run?.detail_url, suffix, label]);
|
|
if (signature !== previousMessage) {
|
|
message.replaceChildren(text);
|
|
if (run) {
|
|
const link = document.createElement("a");
|
|
link.href = run.detail_url;
|
|
link.textContent = label;
|
|
message.append(" ", link, suffix);
|
|
}
|
|
previousMessage = signature;
|
|
}
|
|
if (progress.textContent !== progressText) {
|
|
progress.textContent = progressText;
|
|
}
|
|
result.className = `task-result ${kind}`;
|
|
result.hidden = !text;
|
|
};
|
|
|
|
const showState = () => {
|
|
const active = state.active_run;
|
|
const blocker = state.blocked_by;
|
|
const disabled = submitting || Boolean(active || blocker);
|
|
form.querySelector(".task-controls").disabled = disabled;
|
|
form.classList.toggle("is-waiting", submitting || Boolean(active));
|
|
form.setAttribute("aria-busy", String(submitting || Boolean(active)));
|
|
form.querySelectorAll("details.split-menu").forEach((menu) => {
|
|
menu.inert = disabled;
|
|
if (disabled) {
|
|
menu.open = false;
|
|
}
|
|
});
|
|
if (submitting) {
|
|
render("Starting...", "running");
|
|
} else if (active) {
|
|
const status = active.display_status;
|
|
render(`${status[0].toUpperCase()}${status.slice(1)}.`, "running", active,
|
|
state.progress, "", `Run #${active.run_id}`);
|
|
} else if (blocker) {
|
|
render("Blocked by", "blocked", blocker, "", ` (${blocker.display_status}).`, `run #${blocker.run_id}`);
|
|
} else if (lastResult) {
|
|
render(lastResult.text, lastResult.kind, lastResult.run);
|
|
} else {
|
|
render("");
|
|
}
|
|
};
|
|
|
|
const apply = async (nextState, version) => {
|
|
if (submitting || version !== taskStateVersion) {
|
|
return;
|
|
}
|
|
state = nextState;
|
|
if (state.active_run) {
|
|
observedRun = state.active_run;
|
|
} else if (observedRun) {
|
|
const run = observedRun;
|
|
const response = await fetch(run.state_url, { cache: "no-store" });
|
|
if (!response.ok) {
|
|
throw new Error("Could not read task status.");
|
|
}
|
|
const completed = await response.json();
|
|
if (submitting || version !== taskStateVersion) {
|
|
return;
|
|
}
|
|
if (activeStatus(completed.status)) {
|
|
state = { ...state, active_run: completed, progress: completed.progress };
|
|
} else {
|
|
observedRun = null;
|
|
lastResult = {
|
|
text: completed.status === "succeeded" ? "Completed successfully." : `Finished with status: ${completed.status}.`,
|
|
kind: completed.status === "succeeded" ? "succeeded" : "failed",
|
|
run,
|
|
};
|
|
if (completed.status === "succeeded" && form.dataset.downloadArtifacts !== undefined) {
|
|
try {
|
|
await downloadArtifacts(run);
|
|
} catch (error) {
|
|
lastResult = { text: error.message, kind: "failed", run };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
showState();
|
|
};
|
|
|
|
form.addEventListener("submit", async (event) => {
|
|
event.preventDefault();
|
|
if (submitting || state.active_run || state.blocked_by || !form.reportValidity()) {
|
|
return;
|
|
}
|
|
// Disabled fields are omitted from FormData, so collect values first.
|
|
const formData = new FormData(form);
|
|
submitting = true;
|
|
lastResult = null;
|
|
taskStateVersion += 1;
|
|
showState();
|
|
try {
|
|
const response = await fetch(form.action, {
|
|
method: "POST",
|
|
body: formData,
|
|
headers: { Accept: "application/json" },
|
|
});
|
|
const data = await response.json();
|
|
taskStateVersion += 1;
|
|
if (response.status === 409 && data.blocked_by) {
|
|
state = { active_run: null, blocked_by: data.blocked_by, progress: "" };
|
|
} else if (!response.ok) {
|
|
throw new Error(data.errors ? Object.values(data.errors).join(" ") : data.error || "Could not start task.");
|
|
} else {
|
|
observedRun = data;
|
|
state = { active_run: data, blocked_by: null, progress: "" };
|
|
if (form.dataset.waitForResult === undefined) {
|
|
window.location.assign(data.detail_url);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
lastResult = { text: error instanceof Error ? error.message : "Could not run task.", kind: "failed" };
|
|
} finally {
|
|
submitting = false;
|
|
showState();
|
|
refreshTaskStates();
|
|
}
|
|
});
|
|
showState();
|
|
return { apply };
|
|
}
|
|
|
|
async function refreshTaskStates() {
|
|
if (refreshingTasks || !tasksStateUrl) {
|
|
return;
|
|
}
|
|
refreshingTasks = true;
|
|
window.clearTimeout(taskRefreshTimer);
|
|
const version = taskStateVersion;
|
|
const errorMessage = document.querySelector("#task-status-error");
|
|
try {
|
|
const response = await fetch(tasksStateUrl, { cache: "no-store" });
|
|
if (!response.ok) {
|
|
throw new Error("Could not read live task status.");
|
|
}
|
|
const states = await response.json();
|
|
for (const [form, controller] of taskControllers) {
|
|
if (!form.isConnected) {
|
|
taskControllers.delete(form);
|
|
continue;
|
|
}
|
|
const state = form.dataset.taskId ? states.tasks[form.dataset.taskId] : states.groups[form.dataset.groupId];
|
|
if (state) {
|
|
await controller.apply(state, version);
|
|
}
|
|
}
|
|
if (errorMessage) {
|
|
errorMessage.hidden = true;
|
|
}
|
|
} catch (error) {
|
|
console.warn("Could not refresh task status:", error);
|
|
if (errorMessage) {
|
|
errorMessage.textContent = "Live status unavailable. Retrying...";
|
|
errorMessage.hidden = false;
|
|
}
|
|
} finally {
|
|
refreshingTasks = false;
|
|
if (taskControllers.size) {
|
|
taskRefreshTimer = window.setTimeout(refreshTaskStates, 1000);
|
|
}
|
|
}
|
|
}
|
|
|
|
function initializeTaskForms(source = document) {
|
|
const data = source.querySelector("#task-states");
|
|
if (!data) {
|
|
return;
|
|
}
|
|
tasksStateUrl = data.dataset.stateUrl;
|
|
const states = JSON.parse(data.textContent);
|
|
for (const form of document.querySelectorAll("form[data-task-id], form[data-group-id]")) {
|
|
if (!taskControllers.has(form)) {
|
|
const state = form.dataset.taskId ? states.tasks[form.dataset.taskId] : states.groups[form.dataset.groupId];
|
|
taskControllers.set(form, taskController(form, state));
|
|
}
|
|
}
|
|
if (taskControllers.size) {
|
|
if (!document.querySelector("#task-status-error")) {
|
|
const errorMessage = document.createElement("p");
|
|
errorMessage.id = "task-status-error";
|
|
errorMessage.setAttribute("role", "status");
|
|
errorMessage.hidden = true;
|
|
document.querySelector("main").prepend(errorMessage);
|
|
}
|
|
refreshTaskStates();
|
|
}
|
|
}
|
|
|
|
initializeTaskForms();
|