@yarkivaev/scada 2.3.114 → 2.3.116

package/src/infrastructure/opcua/session.js

@@ -0,0 +1,60 @@
+import { checkSubscription, watchSubscription } from './subscriptionHealth.js';
+import { AttributeIds, TimestampsToReturn } from 'node-opcua';
+
+function deliver(state, channel, value, publish, options) {
+    if (state.active && !state.failure && value.statusCode.isGood()) {
+        const accepted = Promise.resolve().then(() => {
+            if (state.active && !state.failure) {
+                return publish(channel, value.value.value);
+            }
+            return undefined;
+        }).catch((error) => {
+            try {
+                options.onError?.(error, state.connection);
+            } catch {
+                // Callback isolation.
+            }
+        }).finally(() => { state.pending.delete(accepted); });
+        state.pending.add(accepted);
+    }
+}
+async function monitors(subscription, state, connection, publish, options) {
+    await Promise.all(connection.channels.map(async (channel) => {
+        const item = await subscription.monitor({ nodeId: channel.nodeId, attributeId: AttributeIds.Value },
+            { samplingInterval: connection.publishMs, discardOldest: true, queueSize: 10 }, TimestampsToReturn.Both);
+        if (!item.statusCode.isGood()) {
+            throw new Error(`Cannot monitor ${channel.nodeId}: ${item.statusCode.toString()}`);
+        }
+        item.on('changed', (value) => { deliver(state, channel, value, publish, options); });
+    }));
+}
+function pause(state, milliseconds) {
+    return new Promise((resolve) => {
+        state.wake = resolve;
+        state.timer = setTimeout(resolve, milliseconds);
+    }).finally(() => { clearTimeout(state.timer); });
+}
+async function heartbeat(state, activeSession, connection, publish, options) {
+    while (state.active) {
+        checkSubscription(state, options);
+        // Fresh reads are serialized; a slow read cannot overlap the next heartbeat.
+        // eslint-disable-next-line no-await-in-loop
+        await pause(state, connection.heartbeatMs);
+        if (state.active) {
+            checkSubscription(state, options);
+            // eslint-disable-next-line no-await-in-loop
+            const values = await activeSession.read(connection.channels.map(({ nodeId }) => { return { nodeId, attributeId: AttributeIds.Value }; }), 0);
+            values.forEach((value, index) => { deliver(state, connection.channels[index], value, publish, options); });
+        }
+    }
+}
+export default async function session(state, client, connection, publish, options) {
+    const activeSession = await client.createSession();
+    if (state.active) {
+        const subscription = await activeSession.createSubscription2({ requestedPublishingInterval: connection.publishMs,
+            requestedLifetimeCount: 30, requestedMaxKeepAliveCount: 3, maxNotificationsPerPublish: 0, publishingEnabled: true, priority: 0 });
+        watchSubscription(state, subscription);
+        await monitors(subscription, state, connection, publish, options);
+        await heartbeat(state, activeSession, connection, publish, options);
+    }
+}

package/src/infrastructure/opcua/source.js

@@ -0,0 +1,35 @@
+import { positive, validateConnections } from './config.js';
+export { validateConnections } from './config.js';
+
+/** Independent OPC UA endpoints delivering opaque channel metadata and values. */
+export default function opcuaSource(connections, collector, options = {}) {
+    const settings = { retryMs: 1000, connectTimeoutMs: 5000, requestTimeoutMs: 5000, ...options };
+    validateConnections(connections);
+    if (!collector || typeof collector.accept !== 'function') {
+        throw new TypeError('Collector must have an accept() method');
+    }
+    ['retryMs', 'connectTimeoutMs', 'requestTimeoutMs'].forEach((name) => { positive(settings[name], name); });
+    let endpoints;
+    let stopping = Promise.resolve();
+    let revision = 0;
+    return {
+        async start() {
+            revision += 1;
+            const requested = revision;
+            await stopping;
+            // Importing the package or validating a factory never loads node-opcua.
+            const { default: endpoint } = await import('./endpoint.js');
+            if (requested === revision) {
+                endpoints ??= connections.map((connection) => {
+                    return endpoint(connection, (channel, value) => { return collector.accept({ channel, value }); }, settings);
+                });
+                endpoints.forEach((item) => { item.start(); });
+            }
+        },
+        stop() {
+            revision += 1;
+            stopping = Promise.all((endpoints ?? []).map((item) => { return item.stop(); }));
+            return stopping;
+        }
+    };
+}

package/src/infrastructure/opcua/subscriptionHealth.js

@@ -0,0 +1,28 @@
+function failed(state, message) {
+    if (state.active) {
+        state.failure = new Error(message);
+        state.wake?.();
+    }
+}
+export function watchSubscription(state, subscription) {
+    state.lastPublish = Date.now();
+    state.subscription = subscription;
+    subscription.on('keepalive', () => { state.lastPublish = Date.now(); });
+    subscription.on('received_notifications', () => { state.lastPublish = Date.now(); });
+    subscription.on('terminated', () => { failed(state, 'OPC UA subscription terminated'); });
+    subscription.on('status_changed', (status) => {
+        if (!status.isGood()) {
+            failed(state, `OPC UA subscription status: ${status.toString()}`);
+        }
+    });
+}
+export function checkSubscription(state, options) {
+    const { subscription } = state;
+    const silence = Math.max(subscription.publishingInterval * subscription.maxKeepAliveCount * 3, options.requestTimeoutMs);
+    if (Date.now() - state.lastPublish > silence) {
+        failed(state, 'OPC UA subscription stopped publishing');
+    }
+    if (state.failure) {
+        throw state.failure;
+    }
+}

package/src/infrastructure/operators/operatorsSync.js

@@ -1,3 +1,5 @@
+import { intervalSource } from '@yarkivaev/source-to-sink';
+
 const DEFAULT_INTERVAL_MS = 30000;
 
 async function refresh(source, provider) {
@@ -25,33 +27,7 @@ async function refresh(source, provider) {
  */
 export default function operatorsSync(source, provider, options) {
     const intervalMs = options && options.intervalMs ? options.intervalMs : DEFAULT_INTERVAL_MS;
-    let timer;
-    let active = false;
-    async function tick() {
-        try {
-            await refresh(source, provider);
-        } catch {
-            /* next tick retries; stale snapshot remains */
-        }
-    }
-    return {
-        async start() {
-            if (active) {
-                return;
-            }
-            active = true;
-            await tick();
-            timer = setInterval(() => {
-                void tick();
-            }, intervalMs);
-        },
-        stop() {
-            if (!active) {
-                return;
-            }
-            active = false;
-            clearInterval(timer);
-            timer = undefined;
-        }
-    };
+    return intervalSource(intervalMs, {
+        accept() { return refresh(source, provider); }
+    }, { immediate: true });
 }

package/src/infrastructure/persistence/clickhouse/streamHub.js

@@ -9,14 +9,16 @@
  *   const sub = hub.watch('m1/V', since, 1000, onRow, { unit: 'V', clock });
  *   sub.cancel();
  */
+import { intervalSource } from '@yarkivaev/source-to-sink';
 import pollTopicCursors from './pollTopicCursors.js';
 
 const hubs = new WeakMap();
 
 function defaultSchedule(step, fn) {
-    const timer = setInterval(fn, step);
+    const source = intervalSource(step, { accept: fn });
+    void source.start();
     return () => {
-        clearInterval(timer);
+        return source.stop();
     };
 }
 
@@ -74,21 +76,25 @@ function cursorsOf(bucket) {
     return cursors;
 }
 
+function advance(watcher, timestamp) {
+    if (timestamp.getTime() > watcher.lastTs.getTime()) {
+        watcher.lastTs = timestamp;
+    }
+}
+
 function dispatch(bucket, rows) {
-    rows.forEach((row) => {
+    return rows.reduce(async (previous, row) => {
+        await previous;
         const group = bucket.watchers.get(row.topic);
-        if (!group) {
-            return;
-        }
+        if (!group) { return; }
         const timestamp = parseTimestamp(row.ts);
-        group.forEach((watcher) => {
-            if (timestamp.getTime() <= watcher.lastTs.getTime()) {
-                return;
-            }
-            watcher.callback({ timestamp, value: row.value, unit: watcher.unit });
-            watcher.lastTs = timestamp;
-        });
-    });
+        await [...group].reduce(async (previousWatcher, watcher) => {
+            await previousWatcher;
+            if (timestamp.getTime() <= watcher.lastTs.getTime()) { return; }
+            await watcher.callback({ timestamp, value: row.value, unit: watcher.unit });
+            advance(watcher, timestamp);
+        }, Promise.resolve());
+    }, Promise.resolve());
 }
 
 function buildHub(connection, schedule) {
@@ -106,7 +112,7 @@ function buildHub(connection, schedule) {
                     cursorsOf(bucket),
                     bucket.clock()
                 );
-                dispatch(bucket, rows);
+                await dispatch(bucket, rows);
             } catch (err) {
                 console.error( // eslint-disable-line no-console
                     `Stream batch failed on ${connection.url()}:`,

package/src/infrastructure/persistence/metricsSensor.js

@@ -1,3 +1,4 @@
+import { intervalSource } from '@yarkivaev/source-to-sink';
 import seriesRows, { parseTimestamp } from './seriesRows.js';
 
 function pollStream(spec) {
@@ -6,21 +7,23 @@ function pollStream(spec) {
         return new Date();
     });
     let lastTs = since;
-    const timer = setInterval(async () => {
+    const source = intervalSource(step, { async accept() {
         try {
             const rows = await read.poll(topic, lastTs.toISOString(), time().toISOString());
-            rows.forEach((row) => {
+            await rows.reduce(async (previous, row) => {
+                await previous;
                 const timestamp = parseTimestamp(row.ts);
-                callback({ timestamp, value: row.value, unit });
+                await callback({ timestamp, value: row.value, unit });
                 lastTs = timestamp;
-            });
+            }, Promise.resolve());
         } catch {
             /* next poll retries */
         }
-    }, step);
+    } });
+    void source.start();
     return {
         cancel() {
-            clearInterval(timer);
+            return source.stop();
         }
     };
 }

package/src/infrastructure/sync/operationSyncIngest.js

@@ -1,4 +1,4 @@
-import durableConsume from '../ingest/durableConsume.js';
+import { amqpSource } from '@yarkivaev/source-to-sink';
 import operationCodec from './operationCodec.js';
 import operationSyncSink from './operationSyncSink.js';
 
@@ -43,25 +43,13 @@ export function operationConsumer(codec, channel) {
  *   const ingest = operationSyncIngest(amqpUrl, 'scada.operations.ingest', dataAccess.operations);
  *   await ingest.start();
  */
-function subscribeOperations(queue, prefetch, codec) {
-    return async (channel) => {
-        await channel.assertQueue(queue, { durable: true });
-        channel.prefetch(prefetch);
-        const onMessage = operationConsumer(codec, channel);
-        const tag = await channel.consume(queue, onMessage, { noAck: false });
-        return tag.consumerTag;
-    };
-}
-
 export default function operationSyncIngest(amqpUrl, queue, operations, options = {}) {
     const prefetch = options.prefetch || 32;
     const sink = operationSyncSink(operations);
     const codec = operationCodec(sink);
-    const session = durableConsume(
-        amqpUrl,
-        subscribeOperations(queue, prefetch, codec),
-        options
-    );
+    const session = amqpSource(amqpUrl, queue, {
+        accept(delivery) { return acceptOperationDeliver(codec, delivery.content); }
+    }, { ...options, prefetch });
     return {
         start() {
             return session.start();