@yarkivaev/scada 2.3.54 → 2.3.55

package/package.json

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

package/src/application/metricsPlant.js

@@ -29,6 +29,7 @@ export default async function metricsPlant(machines, options) {
         pool,
         alerts: options.alerts,
         userDecisions: options.userDecisions,
+        segments: options.segments,
         shopName: options.shopName
     });
     return plant(initialized({ [shop.name()]: shop }, Object.values));

package/src/application/plantServer.js

@@ -6,6 +6,7 @@ import postgresPool from '../infrastructure/persistence/postgresPool.js';
 import stompAlerts from '../infrastructure/messaging/stomp/alerts/stompAlerts.js';
 import stompTimelineSegments from '../infrastructure/messaging/stomp/stompTimelineSegments.js';
 import userDecisions from '../infrastructure/messaging/stomp/userDecisions.js';
+import segmentRetags from '../infrastructure/messaging/stomp/segmentRetags.js';
 import { parseRequestTimeoutMs, virtualClock } from '@yarkivaev/simple-server';
 
 function stompCollectorFactory(stompUrl, destination, credentials) {
@@ -63,7 +64,13 @@ async function initStomp(stomp, translations, requirePool) {
         passcode: stomp.passcode,
         host: stomp.host
     });
-    return { alerts, userDecisions: decisions };
+    const segments = segmentRetags({
+        stompUrl: stomp.url,
+        login: stomp.login,
+        passcode: stomp.passcode,
+        host: stomp.host
+    });
+    return { alerts, userDecisions: decisions, segments };
 }
 
 /**
@@ -79,8 +86,8 @@ async function initStomp(stomp, translations, requirePool) {
  *   await plantServer({ port: 3000, basePath: '/api/v1', plantFactory, extraRoutes });
  */
 export default async function plantServer(config) {
-    const { alerts, userDecisions: decisions } = await initStomp(config.stomp, config.translations, config.requirePool);
-    const p = await config.plantFactory({ alerts, userDecisions: decisions });
+    const { alerts, userDecisions: decisions, segments: retags } = await initStomp(config.stomp, config.translations, config.requirePool);
+    const p = await config.plantFactory({ alerts, userDecisions: decisions, segments: retags });
     const segments = wireTimelineSegments(config.stomp, p);
     const clock = virtualClock(() => {
         return new Date();

package/src/application/shopWithTimeline.js

@@ -1,9 +1,11 @@
 import pubsub from '../domain/shared/pubsub.js';
 import timeline from '../domain/timeline/timeline.js';
 import pgTimeline from '../infrastructure/persistence/pg/timeline.js';
+import segmentStatePg from '../infrastructure/persistence/pg/segments.js';
 import memoryTimelineStore, { memoryTimelineRead } from '../infrastructure/persistence/memory/timeline.js';
 import ownerTimeline from '../infrastructure/messaging/ownership/ownerTimeline.js';
 import stompTimeline from '../infrastructure/messaging/stomp/timeline.js';
+import retagBody from '../infrastructure/messaging/stomp/retagBody.js';
 
 function parseStart(requestId) {
     const raw = decodeURIComponent(String(requestId));
@@ -69,6 +71,34 @@ function writePort(name, decisions, owners) {
     }, owners)(name);
 }
 
+function ownsLocal(owners, name) {
+    if (!owners) {
+        return true;
+    }
+    return owners.resolve(name).kind !== 'edge';
+}
+
+async function persistTags(pool, patch) {
+    const state = segmentStatePg(pool);
+    const tagsJson = JSON.stringify(patch.tags);
+    const propsJson = JSON.stringify(patch.properties || {});
+    const count = patch.resolved
+        ? await state.resolveRequest(patch.machine, patch.start, tagsJson, propsJson)
+        : await state.retag(patch.machine, patch.start, tagsJson, propsJson);
+    if (!count) {
+        throw new RangeError(`Segment ${patch.machine} at ${patch.start.toISOString()} was not updated`);
+    }
+    return state.rowAt(patch.machine, patch.start);
+}
+
+async function confirm(pool, patch, segments) {
+    const row = await persistTags(pool, patch);
+    if (segments) {
+        await segments.publish(retagBody(patch.machine, row, patch.tags, patch.properties || {}));
+    }
+    return row;
+}
+
 /**
  * Builds a machine timeline from PostgreSQL persistence and STOMP user decisions.
  *
@@ -82,7 +112,7 @@ function writePort(name, decisions, owners) {
  *   const tl = shopWithTimeline('machine1', { pool, userDecisions, owners });
  */
 export default function shopWithTimeline(name, options) {
-    const { pool, userDecisions: decisions, owners } = options;
+    const { pool, userDecisions: decisions, owners, segments } = options;
     if (pool && decisions) {
         const bus = pubsub();
         const read = pgTimeline(pool, name);
@@ -95,11 +125,29 @@ export default function shopWithTimeline(name, options) {
             stream: port.stream,
             bus,
             async retag(start, tags, properties, audit) {
+                if (ownsLocal(owners, name)) {
+                    await confirm(pool, {
+                        machine: name,
+                        start,
+                        tags,
+                        properties,
+                        resolved: false
+                    }, segments);
+                }
                 await write.retag(start, tags, properties, audit);
                 bus.emit({ type: 'resolved', segment: resolvedStub(start, tags, properties), audit });
             },
             async respond(requestId, body, audit) {
                 const start = parseStart(requestId);
+                if (ownsLocal(owners, name)) {
+                    await confirm(pool, {
+                        machine: name,
+                        start,
+                        tags: body.tags,
+                        properties: body.properties || {},
+                        resolved: true
+                    }, segments);
+                }
                 await write.respond(start, body.tags, body.properties || {}, audit);
                 bus.emit({ type: 'resolved', request: { id: requestId, start }, audit });
                 return { id: requestId, ...body };

package/src/domain/timeline/cycleLookback.js

@@ -0,0 +1,37 @@
+function tagList(row) {
+    const raw = row.tags;
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        return JSON.parse(raw);
+    }
+    return [];
+}
+
+/**
+ * Walks newest-first timeline rows until a reset tag and returns them oldest-first.
+ *
+ * Reset ids are opaque; callers pass cycle start/stop tags.
+ *
+ * @param {Array<object>} rows - newest-first rows with tags
+ * @param {Array<string>} resetTags - tag ids that close the lookback
+ * @returns {Array<object>} chronological slice including the reset row
+ *
+ * @example
+ *   cycleLookback(newestFirst, ['cycle-start', 'cycle-stop'])
+ */
+export default function cycleLookback(rows, resetTags) {
+    const reset = new Set(resetTags);
+    const collected = [];
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i];
+        collected.push(row);
+        if (tagList(row).some((id) => {
+            return reset.has(id);
+        })) {
+            break;
+        }
+    }
+    return collected.reverse();
+}

package/src/infrastructure/http/edge/routes/checkpoint/checkpointRoutes.js

@@ -37,6 +37,38 @@ function segmentRoute(token, checkpointState) {
     });
 }
 
+function cyclePriorQuery(query) {
+    if (!query.machineId) {
+        return { error: 'machineId is required' };
+    }
+    const before = parseFrom(query.before);
+    if (before === null) {
+        return { error: 'before must be a number' };
+    }
+    const reset = toTopicList(query.reset);
+    if (reset.length === 0) {
+        return { error: 'reset is required' };
+    }
+    return { machineId: query.machineId, before, reset };
+}
+
+function cyclePriorRoute(token, checkpointState) {
+    return route('GET', '/v1/checkpoint/cycle-prior', async (req, res, params, query) => {
+        void params;
+        if (!hasAccess(req, token)) {
+            sendForbidden(res);
+            return;
+        }
+        const parsed = cyclePriorQuery(query);
+        if (parsed.error) {
+            errorResponse('BAD_REQUEST', parsed.error, 400).send(res);
+            return;
+        }
+        const items = await checkpointState.cyclePrior(parsed.machineId, parsed.before, parsed.reset);
+        jsonResponse({ items }).send(res);
+    });
+}
+
 export default function checkpointRoutes(token, checkpointState) {
     return [
         route('GET', '/v1/checkpoint/replay-cursor', async (req, res, params, query) => {
@@ -53,6 +85,7 @@ export default function checkpointRoutes(token, checkpointState) {
             jsonResponse({ machineId: query.machineId, cursor }).send(res);
         }),
         segmentRoute(token, checkpointState),
+        cyclePriorRoute(token, checkpointState),
         route('GET', '/v1/checkpoint/pending-segments', async (req, res) => {
             if (!hasAccess(req, token)) {
                 sendForbidden(res);

package/src/infrastructure/messaging/stomp/retagBody.js

@@ -0,0 +1,39 @@
+function asList(raw) {
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        return JSON.parse(raw);
+    }
+    return [];
+}
+
+/**
+ * Builds a segments-exchange retag payload matching supervisor SegmentMessage.retag.
+ *
+ * @param {string} machine - machine id
+ * @param {object} row - persisted segment with start_time, end_time, duration, name, options
+ * @param {string[]} tags - operator tags
+ * @param {object} properties - operator properties
+ * @returns {object} STOMP JSON body
+ *
+ * @example
+ *   retagBody('icht1', row, ['to_ladle'], {})
+ */
+export default function retagBody(machine, row, tags, properties) {
+    const options = asList(row.options);
+    const props = properties && Object.keys(properties).length > 0 ? properties : null;
+    return {
+        type: 'retag',
+        status: 'completed',
+        machine,
+        name: row.name,
+        start: new Date(row.start_time).getTime(),
+        end: new Date(row.end_time).getTime(),
+        duration: row.duration,
+        tags,
+        options: options.length > 0 ? options : null,
+        properties: props,
+        resolved: true
+    };
+}

package/src/infrastructure/messaging/stomp/segmentRetags.js

@@ -0,0 +1,35 @@
+import { stompSend } from '@yarkivaev/source-to-sink';
+
+const DEFAULT_DESTINATION = '/exchange/scada.segments';
+
+/**
+ * Publishes operator retag envelopes to the segments exchange.
+ *
+ * @param {object} config - publisher configuration
+ * @param {string} config.stompUrl - STOMP broker URL
+ * @param {string} [config.destination] - STOMP destination
+ * @param {string} [config.login] - STOMP login
+ * @param {string} [config.passcode] - STOMP passcode
+ * @param {string} [config.host] - STOMP vhost header
+ * @returns {object} publisher with publish(body)
+ *
+ * @example
+ *   const retags = segmentRetags({ stompUrl });
+ *   await retags.publish(retagBody('icht1', row, ['to_ladle'], {}));
+ */
+export default function segmentRetags(config) {
+    if (!config.stompUrl) {
+        throw new Error('stompUrl is required for segment retag publisher');
+    }
+    const destination = config.destination || DEFAULT_DESTINATION;
+    const stompOptions = {
+        login: config.login,
+        passcode: config.passcode,
+        host: config.host
+    };
+    return {
+        async publish(body) {
+            await stompSend(config.stompUrl, destination, body, stompOptions);
+        }
+    };
+}

package/src/infrastructure/persistence/memory/checkpoints.js

@@ -1,3 +1,5 @@
+import cycleLookback from '../../../domain/timeline/cycleLookback.js';
+
 function parseJsonField(raw) {
     if (!raw) {
         return null;
@@ -93,6 +95,17 @@ export default function checkpointStateMemory(store) {
         },
         segment(machineId, startEpoch) {
             return segmentAt(store, machineId, startEpoch);
+        },
+        cyclePrior(machineId, beforeEpoch, resetTags) {
+            const beforeMs = Number(beforeEpoch) * 1000;
+            const rows = store.segments.filter((row) => {
+                return row.machine === machineId && new Date(row.start_time).getTime() < beforeMs;
+            }).sort((a, b) => {
+                return new Date(b.start_time) - new Date(a.start_time);
+            });
+            return cycleLookback(rows, resetTags).map((row) => {
+                return segmentItem(row);
+            });
         }
     };
 }

package/src/infrastructure/persistence/memory/segments.js

@@ -65,19 +65,23 @@ export default function segmentStateMemory(store) {
         },
         retag(machineId, start, tagsJson, propertiesJson) {
             const row = findRow(store, machineId, start);
-            if (row) {
-                row.tags = tagsJson;
-                row.properties = propertiesJson;
+            if (!row) {
+                return 0;
             }
+            row.tags = tagsJson;
+            row.properties = propertiesJson;
+            return 1;
         },
         resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
             const row = findRow(store, machineId, startKey);
-            if (row) {
-                row.tags = tagsJson;
-                row.properties = propertiesJson;
-                row.resolved = true;
-                row.consumed = false;
+            if (!row) {
+                return 0;
             }
+            row.tags = tagsJson;
+            row.properties = propertiesJson;
+            row.resolved = true;
+            row.consumed = false;
+            return 1;
         }
     };
 }

package/src/infrastructure/persistence/pg/checkpoints.js

@@ -1,4 +1,5 @@
 import segmentStatePg from './segments.js';
+import cycleLookback from '../../../domain/timeline/cycleLookback.js';
 
 function parseJsonField(raw) {
     if (!raw) {
@@ -110,6 +111,19 @@ export default function checkpointStatePg(pool, metricsEnabled = true) {
         },
         segment(machineId, startEpoch) {
             return segmentAt(pool, machineId, startEpoch);
+        },
+        cyclePrior(machineId, beforeEpoch, resetTags) {
+            return pool.query(
+                `SELECT name, start_time, end_time, duration, tags, options, properties
+                 FROM segments
+                 WHERE machine = $1 AND start_time < $2
+                 ORDER BY start_time DESC`,
+                [machineId, new Date(beforeEpoch * 1000)]
+            ).then((result) => {
+                return cycleLookback(result.rows, resetTags).map((row) => {
+                    return segmentItem(row, machineId);
+                });
+            });
         }
     };
 }

package/src/infrastructure/persistence/pg/segments.js

@@ -33,16 +33,18 @@ export default function segmentStatePg(pool) {
             return result.rows;
         },
         async retag(machineId, start, tagsJson, propertiesJson) {
-            await pool.query(
+            const result = await pool.query(
                 'UPDATE segments SET tags = $1, properties = $2 WHERE machine = $3 AND start_time = $4',
                 [tagsJson, propertiesJson, machineId, start]
             );
+            return result.rowCount;
         },
         async resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
-            await pool.query(
+            const result = await pool.query(
                 'UPDATE segments SET tags = $1, properties = $2, resolved = TRUE, consumed = FALSE WHERE machine = $3 AND start_time = $4',
                 [tagsJson, propertiesJson, machineId, startKey]
             );
+            return result.rowCount;
         }
     };
 }