@yarkivaev/scada 1.4.0 → 2.3.45

package/src/infrastructure/ingest/db/runRetention.js

@@ -0,0 +1,58 @@
+function intervalFor(days) {
+    return `${days} days`;
+}
+
+async function deleteStale(pool, days) {
+    const window = intervalFor(days);
+    await pool.query('BEGIN');
+    try {
+        const metrics = await pool.query(
+            'DELETE FROM metrics WHERE ts < NOW() - $1::interval',
+            [window]
+        );
+        const segments = await pool.query(
+            `DELETE FROM segments
+             WHERE end_time > start_time
+               AND end_time < NOW() - $1::interval`,
+            [window]
+        );
+        const alerts = await pool.query(
+            'DELETE FROM alerts WHERE "timestamp" < NOW() - $1::interval',
+            [window]
+        );
+        const decisions = await pool.query(
+            'DELETE FROM user_decisions WHERE start_time < NOW() - $1::interval',
+            [window]
+        );
+        await pool.query('COMMIT');
+        return {
+            metrics: metrics.rowCount,
+            segments: segments.rowCount,
+            alerts: alerts.rowCount,
+            userDecisions: decisions.rowCount
+        };
+    } catch (error) {
+        await pool.query('ROLLBACK');
+        throw error;
+    }
+}
+
+async function vacuumTables(pool) {
+    const names = ['metrics', 'segments', 'alerts', 'user_decisions'];
+    await Promise.all(names.map((name) => {
+        return pool.query(`VACUUM ANALYZE ${name}`);
+    }));
+}
+
+/**
+ * Deletes Postgres rows older than the retention window and vacuums tables.
+ *
+ * @param {object} pool - pg.Pool instance
+ * @param {number} days - retention window length in days
+ * @returns {Promise<{retentionDays: number, deleted: object}>}
+ */
+export default async function runRetention(pool, days) {
+    const deleted = await deleteStale(pool, days);
+    await vacuumTables(pool);
+    return { retentionDays: days, deleted };
+}

package/src/infrastructure/ingest/ingestCheckpoint.js

@@ -0,0 +1,71 @@
+import { ingestCursorAt, ingestCursorEmpty } from '../../domain/ingest/ingestCursor.js';
+
+function findRow(store, source, machine) {
+    return store.checkpoints.find((row) => {
+        return row.source === source && row.machine === machine;
+    });
+}
+
+/**
+ * In-memory ingest checkpoint port for tests and local runs.
+ *
+ * @param {object} store - shared store with checkpoints array
+ * @returns {object} checkpoint port with read and write methods
+ */
+export default function ingestCheckpointMemory(store) {
+    if (!store.checkpoints) {
+        store.checkpoints = [];
+    }
+    return {
+        read(source, machine) {
+            const row = findRow(store, source, machine);
+            if (!row) {
+                return Promise.resolve(ingestCursorEmpty());
+            }
+            return Promise.resolve(ingestCursorAt(new Date(row.cursor_at)));
+        },
+        write(source, machine, cursorAt) {
+            const row = findRow(store, source, machine);
+            if (row) {
+                row.cursor_at = new Date(cursorAt);
+                return Promise.resolve();
+            }
+            store.checkpoints.push({
+                source,
+                machine,
+                cursor_at: new Date(cursorAt)
+            });
+            return Promise.resolve();
+        }
+    };
+}
+
+/**
+ * PostgreSQL ingest checkpoint port backed by ingest_checkpoints table.
+ *
+ * @param {object} pool - pg pool with query method
+ * @returns {object} checkpoint port with read and write methods
+ */
+export function ingestCheckpointPg(pool) {
+    return {
+        read(source, machine) {
+            return pool.query(
+                'SELECT cursor_at FROM ingest_checkpoints WHERE source = $1 AND machine = $2',
+                [source, machine]
+            ).then((result) => {
+                if (result.rows.length === 0) {
+                    return ingestCursorEmpty();
+                }
+                return ingestCursorAt(new Date(result.rows[0].cursor_at));
+            });
+        },
+        write(source, machine, cursorAt) {
+            return pool.query(
+                `INSERT INTO ingest_checkpoints (source, machine, cursor_at)
+                 VALUES ($1, $2, $3)
+                 ON CONFLICT (source, machine) DO UPDATE SET cursor_at = EXCLUDED.cursor_at`,
+                [source, machine, cursorAt]
+            );
+        }
+    };
+}

package/src/infrastructure/ingest/modbus/mx210Tcp.js

@@ -0,0 +1,81 @@
+import { modbusSource } from '@yarkivaev/source-to-sink';
+
+const layout = [
+    { offset: 0, channel: 'AI1' },
+    { offset: 3, channel: 'AI2' },
+    { offset: 6, channel: 'AI3' },
+    { offset: 9, channel: 'AI4' },
+    { offset: 12, channel: 'AI5' }
+];
+
+/**
+ * Decodes a CDAB-format float from two uint16 registers.
+ *
+ * @param {number} low - First uint16 register (low word)
+ * @param {number} high - Second uint16 register (high word)
+ * @returns {number} Decoded float32 value
+ */
+function decode(low, high) {
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setUint16(0, high);
+    view.setUint16(2, low);
+    return view.getFloat32(0);
+}
+
+/**
+ * Transformer that maps MX210 register blocks to metrics sink records.
+ *
+ * @param {string} device - Device name in topic path
+ * @param {object} collector - Collector with accept(record)
+ * @returns {object} Transformer with accept(registers)
+ */
+export function mx210Metrics(device, collector) {
+    return {
+        accept(registers) {
+            const ts = Date.now();
+            for (const entry of layout) {
+                collector.accept({
+                    topic: `MX210/${device}/GET/${entry.channel}/VALUE`,
+                    ts,
+                    value: decode(registers[entry.offset], registers[entry.offset + 1])
+                });
+            }
+        }
+    };
+}
+
+/**
+ * Owen MX210 TCP stream descriptor for central silent-stream Modbus backup.
+ *
+ * Opens a Modbus poll that writes ClickHouse metrics records (topic, ts, value),
+ * not MQTT publish envelopes.
+ *
+ * @example
+ *   const stream = mx210Tcp('m-1', '192.0.2.10', 502);
+ *   const poll = stream.open(collector, clock, 5);
+ *   poll.start();
+ *
+ * @param {string} name - Stream id (device name in MX210 topics)
+ * @param {string} host - Modbus TCP host
+ * @param {number} port - Modbus TCP port
+ * @returns {object} Stream with name() and open(collector, clock, interval)
+ */
+export default function mx210Tcp(name, host, port) {
+    return Object.freeze({
+        name() {
+            return name;
+        },
+        open(collector, clk, interval) {
+            return modbusSource(
+                host,
+                port,
+                4000,
+                14,
+                interval,
+                mx210Metrics(name, collector),
+                clk
+            );
+        }
+    });
+}

package/src/infrastructure/ingest/modbus/silentStreams.js

@@ -0,0 +1,152 @@
+import { clock } from '@yarkivaev/source-to-sink';
+
+/**
+ * Whether a stream is past the silence budget.
+ *
+ * @param {Map<string, number>} lastSeen - Stream id to last edge millis
+ * @param {string} name - Stream id
+ * @param {object} clk - Clock
+ * @param {number} budgetMs - Silence budget in milliseconds
+ * @returns {boolean} True when Modbus backup should run
+ */
+function isSilent(lastSeen, name, clk, budgetMs) {
+    const at = lastSeen.get(name);
+    if (at === undefined) {
+        return true;
+    }
+    return clk.millis() - at >= budgetMs;
+}
+
+/**
+ * Stops one active poll if present.
+ *
+ * @param {Map<string, object>} active - Active polls by name
+ * @param {string} name - Stream id
+ */
+function stopOne(active, name) {
+    const poll = active.get(name);
+    if (!poll) {
+        return;
+    }
+    poll.stop();
+    active.delete(name);
+}
+
+/**
+ * Starts one poll when not already active.
+ *
+ * @param {Map<string, object>} active - Active polls by name
+ * @param {object} source - Stream source
+ * @param {object} collector - Metrics collector
+ * @param {object} clk - Clock
+ * @param {number} intervalSec - Poll interval seconds
+ */
+function startOne(active, source, collector, clk, intervalSec) {
+    const name = source.name();
+    if (active.has(name)) {
+        return;
+    }
+    const poll = source.open(collector, clk, intervalSec);
+    active.set(name, poll);
+    poll.start();
+}
+
+/**
+ * Reconciles active polls with current silence state.
+ *
+ * @param {object} state - Gate mutable state
+ */
+function pulse(state) {
+    if (!state.running || !state.collector) {
+        return;
+    }
+    for (const source of state.sources) {
+        const name = source.name();
+        if (isSilent(state.lastSeen, name, state.clk, state.budgetMs)) {
+            startOne(state.active, source, state.collector, state.clk, state.intervalSec);
+        } else {
+            stopOne(state.active, name);
+        }
+    }
+}
+
+/**
+ * Builds mutable gate state from config.
+ *
+ * @param {object} config - silentStreams config
+ * @returns {object} Mutable state bag
+ */
+function gateState(config) {
+    const { budget, interval, sources } = config;
+    return {
+        budgetMs: budget * 1000,
+        intervalSec: interval,
+        sources,
+        clk: config.clock || clock(),
+        delay: config.delay || ((fn, ms) => {
+            return setInterval(fn, ms);
+        }),
+        clear: config.clear || clearInterval,
+        lastSeen: new Map(),
+        active: new Map(),
+        collector: undefined,
+        timer: undefined,
+        running: false
+    };
+}
+
+/**
+ * Polls configured Modbus streams only while their edge telemetry is silent.
+ *
+ * Edge freshness is reported via seen(name); Modbus writes go to the bound sink
+ * and never count as seen. Streams never seen are treated as already silent.
+ *
+ * @example
+ *   const streams = silentStreams({
+ *     budget: 15,
+ *     interval: 5,
+ *     sources: [mx210Tcp('m-1', '192.0.2.10', 502)]
+ *   });
+ *   streams.bind(clickhouseSink);
+ *   streams.start();
+ *
+ * @param {object} config - budget (sec), interval (sec), sources, optional clock/delay/clear
+ * @returns {object} Gate with seen, bind, start, stop, pulse
+ */
+export default function silentStreams(config) {
+    const state = gateState(config);
+    function runPulse() {
+        pulse(state);
+    }
+    return {
+        seen(name, at = state.clk.millis()) {
+            state.lastSeen.set(name, at);
+            if (state.running) {
+                runPulse();
+            }
+        },
+        bind(sink) {
+            state.collector = {
+                accept(record) {
+                    sink.write([record]);
+                }
+            };
+        },
+        start() {
+            state.running = true;
+            runPulse();
+            state.timer = state.delay(runPulse, state.intervalSec * 1000);
+        },
+        stop() {
+            state.running = false;
+            if (state.timer !== undefined) {
+                state.clear(state.timer);
+                state.timer = undefined;
+            }
+            for (const name of [...state.active.keys()]) {
+                stopOne(state.active, name);
+            }
+        },
+        pulse: runPulse
+    };
+}

package/src/infrastructure/ingest/mqtt/metricsTransformer.js

@@ -0,0 +1,54 @@
+/**
+ * Transformer for converting raw MQTT messages to metrics records.
+ *
+ * Parses payloads as JSON. Accepts either a raw number or an object
+ * with a value field. Logs when payload cannot be resolved to a
+ * numeric value.
+ *
+ * @example
+ *   const transformer = metricsTransformer(collector);
+ *   transformer.accept({ topic: 'sensors/temp', payload: '42.5' });
+ *   transformer.accept({ topic: 'sensors/temp', payload: '{"ts":123,"value":42}' });
+ *
+ * @param {object} collector - Collector with accept() method
+ * @param {object} [log] - Logger with warn() method
+ * @returns {object} Transformer with accept() method
+ */
+export default function metricsCodec(collector, log = console) {
+    if (!collector || typeof collector.accept !== 'function') {
+        throw new Error('Collector must have an accept() method');
+    }
+    return {
+        /**
+         * Accepts raw MQTT message and transforms to metrics record.
+         *
+         * @param {object} raw - Raw message with topic and payload
+         */
+        accept(raw) {
+            let parsed;
+            try {
+                parsed = JSON.parse(raw.payload);
+            } catch {
+                log.warn(`Cannot resolve payload on ${raw.topic}: not valid JSON`);
+                return;
+            }
+            if (typeof parsed === 'number') {
+                collector.accept({
+                    topic: raw.topic,
+                    ts: Date.now(),
+                    value: parsed
+                });
+                return;
+            }
+            if (typeof parsed === 'object' && parsed !== null && typeof parsed.value === 'number') {
+                collector.accept({
+                    topic: raw.topic,
+                    ts: parsed.ts || Date.now(),
+                    value: parsed.value
+                });
+                return;
+            }
+            log.warn(`Cannot resolve payload on ${raw.topic}: no numeric value found`);
+        }
+    };
+}

package/src/infrastructure/ingest/mqtt/modbusDeviceSpec.js

@@ -0,0 +1,112 @@
+/**
+ * Parses Modbus device connection specs from MODBUS_DEVICES entries.
+ *
+ * TCP format: name:host:port
+ * RTU format: name:rtu:path:baud[:line][:slaveId]
+ *
+ * @example
+ * parseModbusDeviceSpec('cooling-1:rtu:/dev/ttyUSB0:9600:8N1:1');
+ * parseModbusDeviceSpec('m-2:192.0.2.11:502');
+ */
+
+/**
+ * Parses serial line format such as 8N1 into modbus-serial options.
+ *
+ * @param {string} line - Data bits, parity letter, stop bits (e.g. 8N1)
+ * @returns {object} dataBits, parity, stopBits
+ */
+export function parseModbusLineFormat(line) {
+  if (typeof line !== 'string' || line.length !== 3) {
+    throw new Error(`Serial line format must be three characters such as 8N1, got: ${line}`);
+  }
+  const dataBits = parseInt(line.charAt(0), 10);
+  const parityLetter = line.charAt(1).toUpperCase();
+  const stopBits = parseInt(line.charAt(2), 10);
+  let parity = '';
+  if (parityLetter === 'N') {
+    parity = 'none';
+  } else if (parityLetter === 'E') {
+    parity = 'even';
+  } else if (parityLetter === 'O') {
+    parity = 'odd';
+  }
+  if (parity.length === 0 || Number.isNaN(dataBits) || Number.isNaN(stopBits)) {
+    throw new Error(`Serial line format must be such as 8N1, got: ${line}`);
+  }
+  return { dataBits, parity, stopBits };
+}
+
+/**
+ * Parses RTU device spec parts into connection parameters.
+ *
+ * @param {string} spec - Full device spec string
+ * @param {Array<string>} parts - Colon-separated spec parts
+ * @returns {object} RTU device descriptor
+ */
+function parseRtuDeviceSpec(spec, parts) {
+  const name = parts[0];
+  const path = parts[2];
+  const baudRate = parseInt(parts[3], 10);
+  const line = parts[4] || '8N1';
+  const slaveId = parseInt(parts[5] || '1', 10);
+  if (typeof path !== 'string' || path.length === 0) {
+    throw new Error(`RTU path must be a non-empty string in spec: ${spec}`);
+  }
+  if (Number.isNaN(baudRate) || baudRate <= 0) {
+    throw new Error(`RTU baud rate must be positive in spec: ${spec}`);
+  }
+  if (Number.isNaN(slaveId) || slaveId <= 0) {
+    throw new Error(`RTU slave id must be positive in spec: ${spec}`);
+  }
+  return {
+    kind: 'rtu',
+    name,
+    path,
+    serial: {
+      baudRate,
+      slaveId,
+      ...parseModbusLineFormat(line)
+    }
+  };
+}
+
+/**
+ * Parses TCP device spec parts into connection parameters.
+ *
+ * @param {string} spec - Full device spec string
+ * @param {Array<string>} parts - Colon-separated spec parts
+ * @returns {object} TCP device descriptor
+ */
+function parseTcpDeviceSpec(spec, parts) {
+  const name = parts[0];
+  const host = parts[1];
+  const port = parseInt(parts[2], 10);
+  if (typeof host !== 'string' || host.length === 0) {
+    throw new Error(`TCP host must be a non-empty string in spec: ${spec}`);
+  }
+  if (Number.isNaN(port) || port <= 0) {
+    throw new Error(`TCP port must be positive in spec: ${spec}`);
+  }
+  return { kind: 'tcp', name, host, port };
+}
+
+/**
+ * Parses one MODBUS_DEVICES entry into TCP or RTU connection parameters.
+ *
+ * @param {string} spec - Comma-separated device spec fragment
+ * @returns {object} Parsed device connection descriptor
+ */
+export function parseModbusDeviceSpec(spec) {
+  if (typeof spec !== 'string' || spec.trim().length === 0) {
+    throw new Error('Device spec must be a non-empty string');
+  }
+  const parts = spec.trim().split(':');
+  const name = parts[0];
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new Error('Device name must be a non-empty string');
+  }
+  if (parts[1] === 'rtu') {
+    return parseRtuDeviceSpec(spec, parts);
+  }
+  return parseTcpDeviceSpec(spec, parts);
+}