lepus-saga 0.3.0

data/web/assets/favicon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Lepus"><title>Lepus</title><style>.i{stroke:#1a2233}.f{fill:#1a2233}@media (prefers-color-scheme:dark){.i{stroke:#e3e9f3}.f{fill:#e3e9f3}}</style><path class="i" d="M12 6 V40 A16 16 0 0 0 28 56 H42 A10 10 0 0 0 42 36 H28 V18" fill="none" stroke-width="8" stroke-linecap="round" stroke-linejoin="round"/><circle cx="40" cy="46" r="5" fill="#f2a30f"/></svg>

data/web/assets/fonts/overpass/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2021 The Overpass Project Authors (https://github.com/RedHatOfficial/Overpass) Overpass-Italic[wght].ttf: Copyright 2021 The Overpass Project Authors (https://github.com/RedHatOfficial/Overpass)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

data/web/assets/js/api.js

@@ -0,0 +1,50 @@
+export class ApiError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+
+function url(path, params = {}) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === undefined || value === "") continue;
+    query.set(key, Array.isArray(value) ? value.join(",") : value);
+  }
+  const search = query.toString();
+  return `api/${path}${search ? `?${search}` : ""}`;
+}
+
+async function request(path, options = {}) {
+  let response;
+  try {
+    response = await fetch(path, { credentials: "same-origin", headers: { Accept: "application/json" }, ...options });
+  } catch {
+    throw new ApiError(0, "The console could not reach the server");
+  }
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new ApiError(response.status, data.error || `Request failed (${response.status})`);
+  return data;
+}
+
+function post(path, body = {}) {
+  return request(url(path), {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json", "X-Lepus-Saga": "1" },
+    body: JSON.stringify(body)
+  });
+}
+
+export const api = {
+  me: () => request(url("me")),
+  sagas: (params) => request(url("sagas", params)),
+  executions: (params) => request(url("executions", params)),
+  execution: (id) => request(url(`executions/${encodeURIComponent(id)}`)),
+  moving: (params) => request(url("moving", params)),
+  series: (params) => request(url("series", params)),
+  failures: (params) => request(url("insights/failures", params)),
+  latency: (params) => request(url("insights/latency", params)),
+  stalled: (params) => request(url("stalled", params)),
+  retry: (id) => post(`executions/${encodeURIComponent(id)}/retry`),
+  compensate: (id, reason) => post(`executions/${encodeURIComponent(id)}/compensate`, { reason })
+};

data/web/assets/js/dom.js

@@ -0,0 +1,84 @@
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+function apply(el, attrs) {
+  for (const [key, value] of Object.entries(attrs || {})) {
+    if (value === null || value === undefined || value === false) continue;
+    if (key === "text") el.textContent = value;
+    else if (key.startsWith("on") && typeof value === "function") el.addEventListener(key.slice(2), value);
+    else el.setAttribute(key, value === true ? "" : String(value));
+  }
+}
+
+function append(el, children) {
+  for (const child of children.flat(Infinity)) {
+    if (child === null || child === undefined || child === false) continue;
+    el.append(child instanceof Node ? child : document.createTextNode(String(child)));
+  }
+  return el;
+}
+
+export function h(tag, attrs, ...children) {
+  const el = document.createElement(tag);
+  apply(el, attrs);
+  return append(el, children);
+}
+
+export function s(tag, attrs, ...children) {
+  const el = document.createElementNS(SVG_NS, tag);
+  apply(el, attrs);
+  return append(el, children);
+}
+
+export function clear(el) {
+  while (el.firstChild) el.firstChild.remove();
+  return el;
+}
+
+const FOCUSABLE = "a[href], button, input, select, summary, [tabindex]";
+const focusKey = (el) => el.getAttribute("href") || `${el.tagName}|${el.textContent}`;
+
+// Replaces el's children for a poll without disturbing assistive technology:
+// unchanged content is left alone, and focus inside el moves to the matching
+// control of the new content (the same link target, or tag and text).
+export function refill(el, ...children) {
+  const next = append(document.createDocumentFragment(), children);
+  const same = next.childNodes.length === el.childNodes.length &&
+    [...next.childNodes].every((node, index) => node.isEqualNode(el.childNodes[index]));
+  if (same) return el;
+  const active = document.activeElement;
+  const key = active && active !== el && el.contains(active) ? focusKey(active) : null;
+  clear(el).append(next);
+  if (key) [...el.querySelectorAll(FOCUSABLE)].find((node) => focusKey(node) === key)?.focus({ preventScroll: true });
+  return el;
+}
+
+let toastTimer;
+export function toast(message, { error = false } = {}) {
+  const el = document.getElementById("toast");
+  el.textContent = message;
+  el.classList.toggle("is-error", error);
+  el.classList.add("is-shown");
+  clearTimeout(toastTimer);
+  toastTimer = setTimeout(() => el.classList.remove("is-shown"), 3600);
+}
+
+export const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)");
+
+export function copyButton(value, label) {
+  return h("button", {
+    type: "button",
+    class: "copy",
+    "aria-label": `Copy ${label}`,
+    title: `Copy ${label}`,
+    onclick: async () => {
+      try {
+        await navigator.clipboard.writeText(value);
+        toast(`Copied ${label}`);
+      } catch {
+        toast("The browser blocked the clipboard", { error: true });
+      }
+    }
+  }, s("svg", { viewBox: "0 0 16 16", width: 14, height: 14, "aria-hidden": "true" },
+    s("rect", { x: 5.5, y: 5.5, width: 8, height: 8, rx: 1.5 }),
+    s("path", { d: "M10.5 3.5v-.5a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h.5" })));
+}

data/web/assets/js/format.js

@@ -0,0 +1,79 @@
+const numbers = new Intl.NumberFormat();
+const timeOfDay = new Intl.DateTimeFormat(undefined, { hour: "2-digit", minute: "2-digit" });
+const dayTime = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit", second: "2-digit" });
+
+const STATUS = {
+  running: "Running",
+  compensating: "Compensating",
+  completed: "Completed",
+  compensated: "Compensated",
+  failed: "Failed",
+  compensation_failed: "Compensation failed"
+};
+
+export const statusLabel = (status) => STATUS[status] || status;
+export const count = (value) => numbers.format(value || 0);
+export const plural = (n, one, many = `${one}s`) => `${count(n)} ${n === 1 ? one : many}`;
+export const toTime = (value) => (value ? Date.parse(value) : null);
+export const hourMinute = (value) => timeOfDay.format(new Date(value));
+export const stamp = (value) => (value ? dayTime.format(new Date(value)) : "");
+
+export function duration(ms) {
+  if (ms === null || ms === undefined || Number.isNaN(ms)) return "";
+  if (ms < 1000) return `${Math.round(ms)} ms`;
+  const seconds = ms / 1000;
+  if (seconds < 10) return `${seconds.toFixed(1)} s`;
+  if (seconds < 60) return `${Math.round(seconds)} s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    const rest = Math.round(seconds - minutes * 60);
+    return rest ? `${minutes} min ${rest} s` : `${minutes} min`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) {
+    const rest = minutes - hours * 60;
+    return rest ? `${hours} h ${rest} min` : `${hours} h`;
+  }
+  return `${Math.round(hours / 24)} days`;
+}
+
+export function ago(value, now = Date.now()) {
+  const time = typeof value === "number" ? value : toTime(value);
+  if (!time) return "";
+  const ms = Math.max(0, now - time);
+  if (ms < 45_000) return "just now";
+  if (ms >= 86_400_000) return `${waited(ms)} ago`;
+  return `${duration(Math.round(ms / 60_000) * 60_000)} ago`;
+}
+
+export function offset(ms) {
+  if (ms < 1000) return "+0 s";
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60) return `+${seconds} s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `+${minutes}:${String(seconds % 60).padStart(2, "0")}`;
+  const hours = Math.floor(minutes / 60);
+  return `+${hours} h ${minutes % 60}m`;
+}
+
+export function waited(ms) {
+  const minutes = Math.floor(ms / 60_000);
+  if (minutes < 60) return `${minutes} min`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} h ${minutes % 60} min`;
+  return `${Math.floor(hours / 24)} d ${hours % 24} h`;
+}
+
+const dayOfMonth = new Intl.DateTimeFormat(undefined, { month: "short", day: "numeric" });
+
+export const dayMonth = (value) => dayOfMonth.format(new Date(value));
+
+export function compact(value) {
+  const n = value || 0;
+  if (n < 1000) return String(n);
+  const [scaled, unit] = n < 1_000_000 ? [n / 1000, "k"] : [n / 1_000_000, "M"];
+  const digits = scaled < 10 ? 1 : 0;
+  const rounded = Number(scaled.toFixed(digits));
+  if (rounded >= 1000 && unit === "k") return compact(1_000_000);
+  return `${rounded}${unit}`;
+}

data/web/assets/js/live.js

@@ -0,0 +1,74 @@
+const KEY = "lepus-saga:poll";
+const listeners = new Set();
+
+// Polling state shared by every view: `seconds` is 0 when paused. The map
+// reads `now()` so tokens freeze while paused instead of creeping on.
+export const live = { seconds: 5, choices: [0, 2, 5, 15, 60], fallback: 5, frozenAt: null };
+
+export const isLive = () => live.seconds > 0;
+export const pollMs = () => (live.seconds || live.fallback) * 1000;
+export const now = () => (isLive() ? Date.now() : live.frozenAt ?? Date.now());
+
+export function setupPolling(me) {
+  const choices = (me.poll_intervals || []).filter((n) => Number.isFinite(n) && n >= 0);
+  if (choices.length) live.choices = [...new Set(choices)].sort((a, b) => a - b);
+  if (!live.choices.includes(0)) live.choices.unshift(0);
+  live.fallback = live.choices.includes(me.poll_interval) && me.poll_interval > 0 ? me.poll_interval : live.choices.find((n) => n > 0) || 5;
+  let stored = null;
+  try { stored = localStorage.getItem(KEY); } catch {}
+  const wanted = stored === null ? live.fallback : Number(stored);
+  setPoll(live.choices.includes(wanted) ? wanted : live.fallback, { store: false });
+}
+
+export function setPoll(seconds, { store = true } = {}) {
+  const was = live.seconds;
+  live.seconds = seconds;
+  if (seconds === 0 && was !== 0) live.frozenAt = Date.now();
+  if (seconds > 0) live.frozenAt = null;
+  if (store) {
+    try { localStorage.setItem(KEY, String(seconds)); } catch {}
+  }
+  for (const listener of listeners) listener(live);
+}
+
+export function onLive(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+// Runs fn now (even while paused, so a view always has data) and then every
+// `interval()` ms, measured from the start of each run, while polling is on
+// and the tab is visible. Turning polling back on or changing the interval
+// runs it again right away, or as soon as a run in progress finishes.
+export function every(interval, fn) {
+  const ms = typeof interval === "function" ? interval : () => interval;
+  let timer = null;
+  let stopped = false;
+  let busy = false;
+  let again = false;
+  const tick = async (force = false) => {
+    clearTimeout(timer);
+    timer = null;
+    if (stopped) return;
+    if (busy) { again = true; return; }
+    busy = true;
+    again = false;
+    const started = Date.now();
+    if (force || (isLive() && !document.hidden)) {
+      try { await fn(); } catch (error) { console.warn(error); }
+    }
+    busy = false;
+    if (stopped || !isLive()) return;
+    timer = setTimeout(tick, again ? 0 : Math.max(0, ms() - (Date.now() - started)));
+  };
+  const resume = () => { if (!stopped && isLive() && !document.hidden) tick(); };
+  const offLive = onLive(resume);
+  document.addEventListener("visibilitychange", resume);
+  tick(true);
+  return () => {
+    stopped = true;
+    clearTimeout(timer);
+    offLive();
+    document.removeEventListener("visibilitychange", resume);
+  };
+}

data/web/assets/js/main.js

@@ -0,0 +1,143 @@
+import { api } from "./api.js";
+import { clear, h } from "./dom.js";
+import { live, onLive, setPoll, setupPolling } from "./live.js";
+import { overview } from "./views/overview.js";
+import { executions } from "./views/executions.js";
+import { execution } from "./views/execution.js";
+
+const THEME_KEY = "lepus-saga:theme";
+const view = document.getElementById("view");
+let current = null;
+let me = { actions: {}, read_only: true, poll_interval: 5 };
+
+function route() {
+  const hash = location.hash.replace(/^#/, "") || "/";
+  const [path, search = ""] = hash.split("?");
+  const params = new URLSearchParams(search);
+  const detail = path.match(/^\/executions\/([^/]+)$/);
+  if (detail) return { name: "executions", render: execution, args: { id: decodeURIComponent(detail[1]) } };
+  if (path === "/executions") return { name: "executions", render: executions, args: { params } };
+  return { name: "map", render: overview, args: { params } };
+}
+
+function navigate() {
+  if (current && current.destroy) current.destroy();
+  const { name, render, args } = route();
+  for (const link of document.querySelectorAll("[data-nav]")) {
+    if (link.dataset.nav === name) link.setAttribute("aria-current", "page");
+    else link.removeAttribute("aria-current");
+  }
+  clear(view);
+  current = render(view, { ...args, me });
+  window.scrollTo(0, 0);
+}
+
+function applyTheme(choice) {
+  if (choice === "light" || choice === "dark") document.documentElement.setAttribute("data-theme", choice);
+  else document.documentElement.removeAttribute("data-theme");
+  for (const button of document.querySelectorAll("[data-theme-choice]")) {
+    button.setAttribute("aria-pressed", String(button.dataset.themeChoice === choice));
+  }
+}
+
+function setupTheme() {
+  let choice = "auto";
+  try { choice = localStorage.getItem(THEME_KEY) || "auto"; } catch {}
+  applyTheme(choice);
+  for (const button of document.querySelectorAll("[data-theme-choice]")) {
+    button.addEventListener("click", () => {
+      const next = button.dataset.themeChoice;
+      try {
+        if (next === "auto") localStorage.removeItem(THEME_KEY);
+        else localStorage.setItem(THEME_KEY, next);
+      } catch {}
+      applyTheme(next);
+    });
+  }
+}
+
+const rateText = (seconds) => (seconds ? `${seconds} s` : "Paused");
+
+function setupLive() {
+  const wrap = document.getElementById("poll");
+  const button = document.getElementById("live");
+  const menu = document.getElementById("poll-menu");
+  const options = document.getElementById("poll-options");
+  const text = button.querySelector(".live-text");
+  const rate = button.querySelector(".live-rate");
+
+  // Arrow keys move through the radios one by one; only the rate the
+  // keyboard settles on (or the menu closes on) is applied.
+  let pending = null;
+  let commitTimer = null;
+  const commit = () => {
+    clearTimeout(commitTimer);
+    if (pending !== null && pending !== live.seconds) setPoll(pending);
+    pending = null;
+  };
+
+  clear(options);
+  const order = [0, ...live.choices.filter((n) => n > 0)];
+  const radios = order.map((seconds) => {
+    const input = h("input", { type: "radio", name: "poll", value: String(seconds) });
+    input.addEventListener("change", () => {
+      pending = seconds;
+      clearTimeout(commitTimer);
+      commitTimer = setTimeout(commit, 700);
+    });
+    options.append(h("label", { class: "poll-option" }, input,
+      h("span", {}, seconds ? `Every ${seconds} s` : "Paused"),
+      seconds === live.fallback ? h("span", { class: "poll-default" }, "default") : null));
+    return input;
+  });
+
+  const show = () => {
+    const on = live.seconds > 0;
+    wrap.classList.toggle("is-paused", !on);
+    text.textContent = on ? "Live" : "Paused";
+    rate.textContent = on ? rateText(live.seconds) : "";
+    button.setAttribute("aria-label", on ? `Live ${rateText(live.seconds)}, refresh interval` : "Paused, refresh interval");
+    button.title = on ? `Updating every ${live.seconds} seconds` : "Updates paused";
+    radios.forEach((input, index) => { input.checked = order[index] === live.seconds; });
+  };
+
+  const open = (state) => {
+    menu.hidden = !state;
+    button.setAttribute("aria-expanded", String(state));
+    if (state) (radios.find((input) => input.checked) || radios[0]).focus();
+  };
+  const close = (refocus) => {
+    commit();
+    if (menu.hidden) return;
+    open(false);
+    if (refocus) button.focus();
+  };
+
+  button.addEventListener("click", () => open(menu.hidden));
+  menu.addEventListener("keydown", (event) => {
+    if (event.key === "Escape" || event.key === "Enter") { event.preventDefault(); close(true); }
+  });
+  menu.addEventListener("click", (event) => { if (event.target.matches("input") && event.detail > 0) close(true); });
+  document.addEventListener("keydown", (event) => { if (event.key === "Escape") close(wrap.contains(document.activeElement)); });
+  document.addEventListener("pointerdown", (event) => { if (!wrap.contains(event.target)) close(false); });
+  wrap.addEventListener("focusout", (event) => { if (event.relatedTarget && !wrap.contains(event.relatedTarget)) close(false); });
+  onLive(show);
+  show();
+}
+
+async function start() {
+  setupTheme();
+  try {
+    me = await api.me();
+    document.getElementById("brand-title").textContent = me.title;
+    setupPolling(me);
+    setupLive();
+  } catch (error) {
+    clear(view).append(h("p", { class: "error" }, error.message));
+    return;
+  }
+  window.addEventListener("hashchange", navigate);
+  navigate();
+}
+
+start();