@yarkivaev/source-to-sink 1.3.1 → 1.3.3

package/index.js

@@ -15,6 +15,7 @@
  * - lokiSource: Loki polling source (accepts URL)
  * - modbusSource: Modbus TCP polling source (accepts host/port)
  * - modbusRtuSource: Modbus RTU polling source (accepts serial path)
+ * - modbusRtuBusSource: Modbus RTU multi-slave bus on one serial path
  * - mqttSink: MQTT publishing sink (accepts URL)
  *
  * @example
@@ -39,5 +40,6 @@ export { default as stompSource } from './src/stompSource.js';
 export { default as stompSend } from './src/stompSend.js';
 export { default as lokiSource } from './src/lokiSource.js';
 export { default as modbusSource, modbusRtuSource } from './src/modbusSource.js';
+export { default as modbusRtuBusSource } from './src/modbusRtuBusSource.js';
 export { default as mqttSink } from './src/mqttSink.js';
 export { default as sqliteSink } from './src/sqliteSink.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/source-to-sink",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Generic library for building data streaming pipelines",
   "repository": {
     "type": "git",

package/src/modbusRtuBusSource.js

@@ -0,0 +1,118 @@
+import ModbusRTU from 'modbus-serial';
+
+/**
+ * Validates RTU bus source arguments.
+ *
+ * @param {string} path - Serial device path
+ * @param {object} serial - Serial options with baudRate
+ * @param {Array} slaves - Slave descriptors
+ */
+function assertBusArgs(path, serial, slaves) {
+    if (typeof path !== 'string' || path.length === 0) {
+        throw new Error('Serial path must be a non-empty string');
+    }
+    if (!serial || typeof serial.baudRate !== 'number' || serial.baudRate <= 0) {
+        throw new Error('Serial baudRate must be a positive number');
+    }
+    if (!Array.isArray(slaves) || slaves.length === 0) {
+        throw new Error('Slaves must be a non-empty array');
+    }
+}
+
+/**
+ * Reads one slave holding-register block and forwards it to its collector.
+ *
+ * @param {object} client - ModbusRTU client
+ * @param {object} slave - slaveId and collector
+ * @param {number} address - PDU start address
+ * @param {number} count - Register count
+ * @returns {Promise<void>}
+ */
+function readSlave(client, slave, address, count) {
+    client.setID(slave.slaveId);
+    return client.readHoldingRegisters(address, count).then((result) => {
+        slave.collector.accept(result.data);
+    });
+}
+
+/**
+ * Polls all slaves on the bus sequentially.
+ *
+ * @param {object} client - ModbusRTU client
+ * @param {Array} slaves - Slave descriptors
+ * @param {number} address - PDU start address
+ * @param {number} count - Register count
+ * @returns {Promise<void>}
+ */
+function pollSlaves(client, slaves, address, count) {
+    return slaves.reduce((chain, slave) => {
+        return chain.then(() => {
+            return readSlave(client, slave, address, count);
+        });
+    }, Promise.resolve());
+}
+
+/**
+ * Modbus RTU bus source: one serial port, several slave IDs polled in sequence.
+ *
+ * @example
+ * const source = modbusRtuBusSource(
+ *   '/dev/ttyUSB0',
+ *   { baudRate: 9600, stopBits: 2, parity: 'none' },
+ *   [{ slaveId: 1, collector: t1 }, { slaveId: 2, collector: t2 }],
+ *   { address: 1280, count: 30, interval: 5 }
+ * );
+ * source.start();
+ *
+ * @param {string} path - Serial device path
+ * @param {object} serial - baudRate, dataBits, stopBits, parity
+ * @param {Array<{slaveId: number, collector: object}>} slaves - Slave poll targets
+ * @param {object} poll - address, count, interval, optional log
+ * @returns {object} Source with start() and stop()
+ */
+export default function modbusRtuBusSource(path, serial, slaves, poll) {
+    assertBusArgs(path, serial, slaves);
+    const log = poll.log || console;
+    const client = new ModbusRTU();
+    const line = {
+        baudRate: serial.baudRate,
+        dataBits: serial.dataBits || 8,
+        stopBits: serial.stopBits || 1,
+        parity: serial.parity || 'none'
+    };
+    let handle = null;
+    let opened = false;
+    function runPoll() {
+        pollSlaves(client, slaves, poll.address, poll.count).catch((err) => {
+            log.error(`RTU bus poll on ${path} failed: ${err.message}`);
+        });
+    }
+    function attempt() {
+        client.connectRTUBuffered(path, line).then(() => {
+            opened = true;
+            handle = setInterval(runPoll, poll.interval * 1000);
+            runPoll();
+        }).catch((err) => {
+            log.error(`Connection to ${path} failed, retrying: ${err.message}`);
+            handle = setTimeout(attempt, poll.interval * 1000);
+        });
+    }
+    return {
+        start() {
+            if (!(opened || handle)) {
+                attempt();
+            }
+        },
+        stop() {
+            if (handle) {
+                clearInterval(handle);
+                clearTimeout(handle);
+                handle = null;
+            }
+            if (opened) {
+                client.close();
+                opened = false;
+            }
+        }
+    };
+}

package/src/modbusSource.js

@@ -4,7 +4,7 @@ import pollingSource from './pollingSource.js';
 /**
  * Idle state for Modbus connection.
  *
- * @returns {object} State with connected() returning false and no retry handle
+ * @returns {object} State with no open attempt
  */
 function idle() {
   return {
@@ -13,6 +13,9 @@ function idle() {
     },
     retrying() {
       return false;
+    },
+    opening() {
+      return false;
     }
   };
 }
@@ -31,12 +34,34 @@ function retrying(handle) {
     retrying() {
       return true;
     },
+    opening() {
+      return false;
+    },
     cancel() {
       clearTimeout(handle);
     }
   };
 }
 
+/**
+ * In-flight TCP or RTU connect state.
+ *
+ * @returns {object} State with opening() returning true
+ */
+function opening() {
+  return {
+    connected() {
+      return false;
+    },
+    retrying() {
+      return false;
+    },
+    opening() {
+      return true;
+    }
+  };
+}
+
 /**
  * Connected state for Modbus connection.
  *
@@ -51,12 +76,44 @@ function connected(client) {
     retrying() {
       return false;
     },
+    opening() {
+      return false;
+    },
     disconnect() {
       client.close();
     }
   };
 }
 
+/**
+ * Starts one connect attempt and ignores results after stop().
+ *
+ * @param {object} bag - Mutable lifecycle bag
+ */
+function attempt(bag) {
+  const token = bag.epoch;
+  bag.state = opening();
+  bag.connect(bag.client).then(() => {
+    if (token !== bag.epoch) {
+      bag.client.close();
+      return;
+    }
+    bag.delay = bag.interval;
+    bag.state = connected(bag.client);
+    bag.source.start();
+  }).catch((err) => {
+    if (token !== bag.epoch) {
+      return;
+    }
+    bag.log.error(`Connection to ${bag.target} failed, retrying in ${bag.delay}s: ${err.message}`);
+    const handle = setTimeout(() => {
+      attempt(bag);
+    }, bag.delay * 1000);
+    bag.state = retrying(handle);
+    bag.delay = Math.min(bag.delay * 2, bag.maxDelay);
+  });
+}
+
 /**
  * Shared Modbus polling lifecycle for TCP and RTU transports.
  *
@@ -64,60 +121,42 @@ function connected(client) {
  * @returns {object} Source with start() and stop() methods
  */
 function modbusPollingSource(options) {
-  const {
-    connect,
-    target,
-    address,
-    count,
-    interval,
-    collector,
-    clk,
-    client,
-    log
-  } = options;
-  let state = idle();
+  const { address, count, interval, collector, clk, client } = options;
   async function fetch() {
     const result = await client.readHoldingRegisters(address, count);
     return [result.data];
   }
-  const maxDelay = 300;
-  const source = pollingSource(fetch, interval, collector, clk);
-  let delay = interval;
-  function attempt() {
-    connect(client).then(() => {
-      delay = interval;
-      state = connected(client);
-      source.start();
-    }).catch((err) => {
-      log.error(`Connection to ${target} failed, retrying in ${delay}s: ${err.message}`);
-      const handle = setTimeout(attempt, delay * 1000);
-      state = retrying(handle);
-      delay = Math.min(delay * 2, maxDelay);
-    });
-  }
+  const bag = {
+    ...options,
+    state: idle(),
+    epoch: 0,
+    maxDelay: 300,
+    source: pollingSource(fetch, interval, collector, clk),
+    delay: interval
+  };
   return {
     /**
      * Connects to the Modbus device and starts polling.
      */
     start() {
-      if (state.connected() || state.retrying()) {
+      if (bag.state.connected() || bag.state.retrying() || bag.state.opening()) {
         return;
       }
-      attempt();
+      attempt(bag);
     },
     /**
      * Stops polling and disconnects from the Modbus device.
      */
     stop() {
-      source.stop();
-      if (state.retrying()) {
-        state.cancel();
-        state = idle();
+      bag.epoch += 1;
+      bag.source.stop();
+      if (bag.state.retrying()) {
+        bag.state.cancel();
       }
-      if (state.connected()) {
-        state.disconnect();
-        state = idle();
+      if (bag.state.connected() || bag.state.opening()) {
+        bag.client.close();
       }
+      bag.state = idle();
     }
   };
 }

package/test/test_modbusRtuBusSource.js

@@ -0,0 +1,47 @@
+import assert from 'node:assert';
+import { describe, it } from 'mocha';
+import modbusRtuBusSource from '../src/modbusRtuBusSource.js';
+
+describe('modbusRtuBusSource', () => {
+    it('throws on empty serial path', () => {
+        assert.throws(
+            () => {
+                return modbusRtuBusSource('', { baudRate: 9600 }, [{ slaveId: 1, collector: { accept() {} } }], {
+                    address: 1280,
+                    count: 30,
+                    interval: 5
+                });
+            },
+            /Serial path must be a non-empty string/u,
+            'Should reject empty serial path'
+        );
+    });
+
+    it('throws on empty slaves list', () => {
+        assert.throws(
+            () => {
+                return modbusRtuBusSource(`/dev/ttyUSB${Math.floor(Math.random() * 9)}`, { baudRate: 9600 }, [], {
+                    address: 1280,
+                    count: 30,
+                    interval: 5
+                });
+            },
+            /Slaves must be a non-empty array/u,
+            'Should reject empty slaves array'
+        );
+    });
+
+    it('creates source with start method for multiple slaves', () => {
+        const path = `/dev/ttyUSB${Math.floor(Math.random() * 9)}`;
+        const source = modbusRtuBusSource(
+            path,
+            { baudRate: 9600, stopBits: 2 },
+            [
+                { slaveId: 1, collector: { accept() {} } },
+                { slaveId: 2, collector: { accept() {} } }
+            ],
+            { address: 1280, count: 30, interval: 5 }
+        );
+        assert.strictEqual(typeof source.start, 'function', 'Should expose start for RTU bus source');
+    });
+});

package/test/test_modbusSource.js

@@ -1,8 +1,89 @@
 import assert from 'node:assert';
+import net from 'node:net';
 import { describe, it } from 'mocha';
 import modbusSource from '../src/modbusSource.js';
 import fakeClock from './fakeClock.js';
 
+/**
+ * TCP listener that counts concurrent sockets on an ephemeral port.
+ *
+ * @returns {Promise<object>} Gate with port, live, peak, close
+ */
+function countingListen() {
+    let live = 0;
+    let peak = 0;
+    const sockets = new Set();
+    const server = net.createServer((sock) => {
+        live += 1;
+        if (live > peak) {
+            peak = live;
+        }
+        sockets.add(sock);
+        sock.on('close', () => {
+            sockets.delete(sock);
+            live -= 1;
+        });
+    });
+    return new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', () => {
+            resolve({
+                port: server.address().port,
+                live() {
+                    return live;
+                },
+                peak() {
+                    return peak;
+                },
+                close() {
+                    for (const sock of sockets) {
+                        sock.destroy();
+                    }
+                    return new Promise((done) => {
+                        server.close(done);
+                    });
+                }
+            });
+        });
+    });
+}
+
+/**
+ * Resolves after the given delay.
+ *
+ * @param {number} ms - Delay in milliseconds
+ * @returns {Promise<void>} Timer promise
+ */
+function settle(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+
+/**
+ * Waits until probe is true or the timeout elapses.
+ *
+ * @param {Function} probe - Condition
+ * @param {number} limit - Timeout in milliseconds
+ * @returns {Promise<void>} Resolves when probe holds
+ */
+function until(probe, limit) {
+    const deadline = Date.now() + limit;
+    function tick(resolve, reject) {
+        if (probe()) {
+            resolve();
+            return;
+        }
+        if (Date.now() >= deadline) {
+            reject(new Error('condition did not hold before timeout'));
+            return;
+        }
+        setTimeout(() => {
+            tick(resolve, reject);
+        }, 20);
+    }
+    return new Promise(tick);
+}
+
 describe('modbusSource', () => {
   it('throws on empty host', () => {
     const collector = { accept: () => {} };
@@ -118,4 +199,73 @@ describe('modbusSource', () => {
     source.stop();
     assert.strictEqual(true, true, 'Should not crash on unreachable host');
   });
+
+  it('does not open a second TCP socket when start is called twice', async function() {
+    const gate = await countingListen();
+    const source = modbusSource(
+      '127.0.0.1',
+      gate.port,
+      4000,
+      14,
+      5,
+      { accept() {} },
+      fakeClock(1 + Math.floor(Math.random() * 100)),
+      { error() {} }
+    );
+    source.start();
+    await until(() => {
+      return gate.live() >= 1;
+    }, 2000);
+    source.start();
+    await settle(150);
+    const peak = gate.peak();
+    source.stop();
+    await gate.close();
+    assert.strictEqual(peak, 1, 'second start opened another Modbus TCP socket');
+  });
+
+  it('closes the TCP socket when stop is called after connect', async function() {
+    const gate = await countingListen();
+    const source = modbusSource(
+      '127.0.0.1',
+      gate.port,
+      4000,
+      14,
+      5,
+      { accept() {} },
+      fakeClock(3 + Math.floor(Math.random() * 100)),
+      { error() {} }
+    );
+    source.start();
+    await until(() => {
+      return gate.live() >= 1;
+    }, 2000);
+    source.stop();
+    await until(() => {
+      return gate.live() === 0;
+    }, 2000);
+    const live = gate.live();
+    await gate.close();
+    assert.strictEqual(live, 0, 'stop after connect left a Modbus TCP socket open');
+  });
+
+  it('does not keep a TCP socket when stop is called during connect', async function() {
+    const gate = await countingListen();
+    const source = modbusSource(
+      '127.0.0.1',
+      gate.port,
+      4000,
+      14,
+      5,
+      { accept() {} },
+      fakeClock(7 + Math.floor(Math.random() * 100)),
+      { error() {} }
+    );
+    source.start();
+    source.stop();
+    await settle(400);
+    const live = gate.live();
+    await gate.close();
+    assert.strictEqual(live, 0, 'stop during connect left a Modbus TCP socket open');
+  });
 });