@yarkivaev/scada 2.3.63 → 2.3.64

package/README.md

@@ -71,7 +71,7 @@ PostgreSQL ← STOMP alerts (via plantServer)
 plantApi → REST + SSE → frontend / @yarkivaev/scada/client
 ```
 
-`GET /api/v1/topology` returns `{ plant, nodes, links }` from `plant.topology()` or a shop/machine/sensor walk. `GET /infra` serves a generic SVG of that graph. Optional node `inspect: { host, port }` is reached same-origin at `/infra/inspect/:id` (CDP `Host` is loopback).
+`GET /api/v1/topology` returns `{ plant, nodes, links }` from `plant.topology()` or a shop/machine/sensor walk, then paints `status` from live `sensor.current()` freshness (`ok` / `degraded` / `down`). Nodes without a matching sensor stay `unknown`. `GET /infra` serves a generic SVG of that graph. Optional node `inspect: { host, port }` is reached same-origin at `/infra/inspect/:id` (CDP `Host` is loopback).
 
 **Supervisor-sink** (write path):
 
@@ -91,7 +91,7 @@ Main entry (`import { … } from '@yarkivaev/scada'`):
 |--------|---------|
 | `plant`, `shop`, `machine` | Domain hierarchy |
 | `timeline`, `alerts`, `alert`, `acknowledgedAlert` | Timeline and alerting |
-| `plantApi`, `plantServer`, `siteServer`, `topologyFromPlant` | HTTP composition and topology graph |
+| `plantApi`, `plantServer`, `siteServer`, `topologyFromPlant`, `topologyHealth` | HTTP composition and topology graph |
 
 | `exportQuery`, `exportStream`, `exportSink`, `exportJob` | Generic export ports over plantApi / `@yarkivaev/scada/client` |
 | `siteSync`, `siteSyncSites`, `siteSyncBind` | Pull kinds from an allowlisted remote plantApi into local persistence |

package/index.js

@@ -15,6 +15,7 @@ export { default as pubsub } from './src/domain/shared/pubsub.js';
 
 export { default as plantApi } from './src/application/plantApi.js';
 export { default as topologyFromPlant } from './src/application/topologyFromPlant.js';
+export { default as topologyHealth } from './src/application/topologyHealth.js';
 export { default as tagCatalog } from './src/infrastructure/catalog/tagCatalog.js';
 export { default as machineInPlant } from './src/application/machineInPlant.js';
 export { default as shopWithTimeline } from './src/application/shopWithTimeline.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "2.3.63",
+  "version": "2.3.64",
   "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",

package/src/application/plantApi.js

@@ -41,7 +41,7 @@ export default function plantApi(basePath, plant, config) {
     const decorate = opts.decorateTimeline || pass;
     const routeList = [
         ...catalogRoute(basePath, opts.tagCatalog),
-        ...topologyRoute(basePath, plant),
+        ...topologyRoute(basePath, plant, time),
         ...machineRoute(basePath, plant),
         ...stateRoute(basePath, plant),
         ...measurementStream(basePath, plant, time),

package/src/application/topologyHealth.js

@@ -0,0 +1,128 @@
+/**
+ * Paints topology node status from live sensor current() readings.
+ * Does not read kube or Prometheus. Unmatched nodes keep their existing status.
+ *
+ * @param {object} graph - topology contract { plant, nodes, links }
+ * @param {object} plant - plant with shops().get() machines and sensors
+ * @param {function} [clock] - () => Date
+ * @returns {Promise<object>} graph with status overlays
+ *
+ * @example
+ *   await topologyHealth(graph, plant, () => new Date());
+ */
+function age(reading, now) {
+    if (!reading || reading.found !== true || !reading.timestamp) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return now.getTime() - new Date(reading.timestamp).getTime();
+}
+
+function grade(ms) {
+    if (!Number.isFinite(ms)) {
+        return 'down';
+    }
+    if (ms <= 300000) {
+        return 'ok';
+    }
+    if (ms <= 1800000) {
+        return 'degraded';
+    }
+    return 'down';
+}
+
+function rollup(states) {
+    if (states.length === 0) {
+        return undefined;
+    }
+    if (states.every((item) => {
+        return item === 'ok';
+    })) {
+        return 'ok';
+    }
+    if (states.every((item) => {
+        return item === 'down';
+    })) {
+        return 'down';
+    }
+    return 'degraded';
+}
+
+async function sample(id, item, now) {
+    try {
+        return [id, grade(age(await item.current(), now))];
+    } catch {
+        return [id, 'down'];
+    }
+}
+
+async function probeMachine(machineId, item, now) {
+    const keys = Object.keys(item.sensors || {});
+    const pairs = await Promise.all(keys.map((key) => {
+        return sample(`${machineId}-${key}`, item.sensors[key], now);
+    }));
+    const status = rollup(pairs.map((pair) => {
+        return pair[1];
+    }));
+    if (status) {
+        pairs.push([machineId, status]);
+    }
+    return pairs;
+}
+
+function machineMarks(pairs, machineIds) {
+    return machineIds.map((machineId) => {
+        const hit = pairs.find((pair) => {
+            return pair[0] === machineId;
+        });
+        return hit ? hit[1] : undefined;
+    }).filter(Boolean);
+}
+
+async function probeShop(shopId, area, now) {
+    const machines = area.machines.get();
+    const chunks = await Promise.all(Object.entries(machines).map(([machineId, item]) => {
+        return probeMachine(machineId, item, now);
+    }));
+    const pairs = chunks.flat();
+    const status = rollup(machineMarks(pairs, Object.keys(machines)));
+    if (status) {
+        pairs.push([shopId, status]);
+    }
+    return pairs;
+}
+
+function statusOf(node, marks) {
+    if (marks.has(node.id)) {
+        return marks.get(node.id);
+    }
+    if (node.kind === 'collector' && node.parent && marks.has(node.parent)) {
+        return marks.get(node.parent);
+    }
+    return undefined;
+}
+
+function paint(graph, marks) {
+    return {
+        plant: graph.plant,
+        links: graph.links,
+        nodes: graph.nodes.map((node) => {
+            const status = statusOf(node, marks);
+            if (!status) {
+                return node;
+            }
+            return { ...node, status };
+        })
+    };
+}
+
+export default async function topologyHealth(graph, plant, clock) {
+    if (!plant.shops || typeof plant.shops.get !== 'function') {
+        return graph;
+    }
+    const now = clock ? clock() : new Date();
+    const shops = plant.shops.get();
+    const chunks = await Promise.all(Object.entries(shops).map(([shopId, area]) => {
+        return probeShop(shopId, area, now);
+    }));
+    return paint(graph, new Map(chunks.flat()));
+}

package/src/infrastructure/http/plant/routes/topologyRoute.js

@@ -1,20 +1,23 @@
 import { jsonResponse, route } from '@yarkivaev/simple-server';
 import topologyFromPlant from '../../../../application/topologyFromPlant.js';
+import topologyHealth from '../../../../application/topologyHealth.js';
 
 /**
  * Plant topology graph route.
  *
  * @param {string} basePath - API base path
  * @param {object} plant - plant domain object
+ * @param {function} [clock] - () => Date for sensor freshness
  * @returns {array} route objects
  *
  * @example
  *   topologyRoute('/api/v1', plant);
  */
-export default function topologyRoute(basePath, plant) {
+export default function topologyRoute(basePath, plant, clock) {
     return [
-        route('GET', `${basePath}/topology`, (req, res) => {
-            jsonResponse(topologyFromPlant(plant)).send(res);
+        route('GET', `${basePath}/topology`, async (req, res) => {
+            const graph = await topologyHealth(topologyFromPlant(plant), plant, clock);
+            jsonResponse(graph).send(res);
         })
     ];
 }