@yarkivaev/scada 2.4.1 → 2.4.3

package/package.json

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

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

@@ -24,13 +24,23 @@ export default function intervalFoldPg(pool) {
             const start = new Date(sample.ts).toISOString();
             await pool.query(
                 `INSERT INTO segments (machine, kind, name, start_time, end_time, duration, resolved, consumed)
-                 VALUES ($1, $2, $3, $4, $4, 0, TRUE, TRUE)`,
+                 SELECT $1, $2, $3, $4::timestamptz, $4::timestamptz, 0, TRUE, TRUE
+                 WHERE NOT EXISTS (
+                     SELECT 1 FROM (
+                         SELECT start_time, end_time, duration FROM segments
+                         WHERE machine = $1 AND kind = $2
+                         ORDER BY start_time DESC LIMIT 1
+                     ) previous
+                     WHERE start_time >= $4::timestamptz OR end_time > $4::timestamptz
+                         OR (duration = 0 AND end_time >= $4::timestamptz)
+                 )
+                 ON CONFLICT (machine, kind, start_time) DO NOTHING`,
                 [sample.machine, sample.kind, sample.name, start]
             );
         },
         async extend(row, ts) {
             await pool.query(
-                `UPDATE segments SET end_time = $1
+                `UPDATE segments SET end_time = GREATEST(end_time, $1::timestamptz)
                  WHERE machine = $2 AND kind = $3 AND start_time = $4 AND duration = 0`,
                 [new Date(ts).toISOString(), row.machine, row.kind, row.start_time]
             );
@@ -41,7 +51,7 @@ export default function intervalFoldPg(pool) {
             const duration = Math.max(1, Math.round((end.getTime() - start.getTime()) / 1000));
             await pool.query(
                 `UPDATE segments SET end_time = $1, duration = $2
-                 WHERE machine = $3 AND kind = $4 AND start_time = $5 AND duration = 0`,
+                 WHERE machine = $3 AND kind = $4 AND start_time = $5 AND duration = 0 AND end_time < $1::timestamptz`,
                 [end.toISOString(), duration, row.machine, row.kind, row.start_time]
             );
         }

package/src/infrastructure/streams/amqpSink/session.js

@@ -77,7 +77,7 @@ async function connect(state, epoch) {
         if (live.dead) { throw new Error('AMQP session closed during initialization'); }
         await keep(state, live);
     } catch (error) {
-        await closeLive(live);
+        await closeLive(live).catch((failure) => { state.fatal = failure; throw failure; });
         retry(state, epoch);
         throw error;
     }

package/src/infrastructure/streams/amqpSource/session.js

@@ -4,9 +4,9 @@ import brokerClose, { destroyConnection } from '../brokerClose.js';
 import deadline from '../deadline.js';
 import positive from '../positive.js';
 
-async function connectBroker(url) {
+async function connectBroker(url, options) {
     const { default: amqp } = await import('amqplib');
-    return amqp.connect(url, { heartbeat: 10 });
+    return amqp.connect(url, { heartbeat: 10, ...options });
 }
 function reportFailure(error) {
     process.stderr.write(`amqp consume failed ${error.message}\n`);
@@ -36,9 +36,7 @@ function retry(ctx, generation) {
     ctx.state.delay = Math.min(pause * 2, 30000);
     ctx.state.timer = ctx.schedule(() => {
         ctx.state.timer = undefined;
-        ctx.state.opening = deadline(ctx.open(generation), ctx.connectTimeoutMs, 'AMQP connect', (error) => {
-            ctx.state.fatal = error; ctx.state.running = false; ctx.state.generation += 1;
-        });
+        ctx.state.opening = ctx.attempt(generation);
         void ctx.state.opening.catch(ctx.report);
         return ctx.state.opening;
     }, pause);
@@ -65,7 +63,7 @@ async function open(ctx, generation) {
     let complete;
     const live = { closed: false, ready: new Promise((resolve) => { complete = resolve; }) };
     try {
-        live.connection = await ctx.connect(ctx.url);
+        live.connection = await ctx.connect(ctx.url, { timeout: ctx.connectTimeoutMs });
         bind(ctx, generation, live, live.connection);
         await subscribe(ctx, generation, live);
         if (!current(ctx, generation) || live.lost) { await dispose(live, ctx); return; }
@@ -77,6 +75,20 @@ async function open(ctx, generation) {
         retry(ctx, generation);
     } finally { complete(); }
 }
+function recover(ctx, timeout) {
+    if (timeout && ctx.state.fatal === timeout) {
+        ctx.state.fatal = undefined;
+        retry(ctx, ctx.state.generation);
+    }
+}
+function attempt(ctx, generation) {
+    let timeout;
+    const opening = ctx.open(generation);
+    void opening.then(() => { recover(ctx, timeout); }, () => { recover(ctx, timeout); });
+    return deadline(opening, ctx.connectTimeoutMs, 'AMQP connect', (error) => {
+        timeout = error; ctx.state.fatal = error; ctx.state.generation += 1;
+    });
+}
 async function begin(ctx) {
     if (ctx.state.fatal) { throw ctx.state.fatal; }
     if (ctx.state.running) { await ctx.state.opening; return; }
@@ -86,9 +98,7 @@ async function begin(ctx) {
     await ctx.state.stopping;
     await ctx.state.cleanup;
     if (current(ctx, generation)) {
-        ctx.state.opening = deadline(ctx.open(generation), ctx.connectTimeoutMs, 'AMQP connect', (error) => {
-            ctx.state.fatal = error; ctx.state.running = false; ctx.state.generation += 1;
-        });
+        ctx.state.opening = attempt(ctx, generation);
         await ctx.state.opening;
     }
 }
@@ -113,7 +123,8 @@ export default function amqpSession(url, subscribeChannel, options = {}) {
         clear: options.clear || clearTimeout,
         report: options.onError || options.report || reportFailure,
         state: { generation: 0, running: false, delay: 1000 },
-        open(generation) { return open(ctx, generation); }
+        open(generation) { return open(ctx, generation); },
+        attempt(generation) { return attempt(ctx, generation); }
     };
     return {
         start() { return begin(ctx); },