@azuliani/node-service 0.0.1

package/Client/Client.js

@@ -0,0 +1,246 @@
+"use strict";
+
+const zmq = require("zeromq/v5-compat");
+const MonitoredSocket = require("./MonitoredSocket");
+
+const RPCClient = require("./RPCClient");
+const SourceClient = require("./SourceClient");
+const SharedObjectClient = require("./SharedObjectClient");
+const PullClient = require("./PullClient");
+const SinkClient = require("./SinkClient");
+
+class Client {
+    constructor(descriptor, options = {}){
+        // options.initDelay - Delay in ms before SharedObjectClient calls _init() after subscribe().
+        //                     Allows time to receive queued diffs before fetching full state.
+        //                     Default: 100ms
+        this.descriptor = descriptor;
+        this.transports = {};
+        this._options = options;
+
+        // Timestamp-based heartbeat tracking
+        this._lastSourceMessageTime = null;      // Updated on EVERY source message (O(1))
+        this._serverHeartbeatFrequencyMs = null; // Learned from first heartbeat
+        this._heartbeatCheckInterval = null;     // Periodic check interval
+        this._isSourceConnected = false;         // Track connection state
+
+        this.sourceDisconnections = {};
+
+        this._setupTransports();
+        this._setupEndpoints();
+    }
+
+    _setupTransports(){
+        for(let transport in this.descriptor.transports){
+            switch (transport){
+                case 'source':
+                    this._setupSource(this.descriptor.transports.source.client);
+                    break;
+                case 'sink':
+                    this._setupSink(this.descriptor.transports.sink.client);
+                    break;
+                case 'rpc':
+                    this._setupRpc(this.descriptor.transports.rpc.client);
+                    break;
+                case 'pushpull':
+                    this._setupPull();
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    _setupSource(hostname){
+        this._monitoredSource = new MonitoredSocket('sub');
+        this.transports.source = this._monitoredSource.sock;
+
+        this.transports.source.connect(hostname);
+        this._sourceHostname = hostname;
+        this.transports.source.on('message', this._sourceCallback.bind(this));
+        this._monitoredSource.on('disconnected', this._sourceClosed.bind(this));
+        this._monitoredSource.on('connected', this._sourceConnected.bind(this));
+
+        // Subscribe to heartbeat channel
+        this.transports.source.subscribe('_heartbeat');
+    }
+
+    _setupSink(hostname){
+        const sock = new zmq.socket('push');
+        this.transports.sink = sock;
+        sock.connect(hostname);
+    }
+
+    _sourceCallback(endpoint, message){
+        // O(1) timestamp update - MUST be first, before any parsing
+        this._lastSourceMessageTime = Date.now();
+
+        // Mark as connected when we receive messages (more reliable than ZMQ monitor)
+        if (!this._isSourceConnected) {
+            this._isSourceConnected = true;
+            // Emit connected events for endpoints
+            for (let ep of this.descriptor.endpoints) {
+                if (ep.type === 'Source' || ep.type === 'SharedObject') {
+                    console.error(ep.name, 'connected');
+                    this[ep.name].emit('connected');
+                    // Re-init SharedObjects that were disconnected
+                    if (ep.type === 'SharedObject' && this.sourceDisconnections[ep.name]) {
+                        this[ep.name]._init();
+                        delete this.sourceDisconnections[ep.name];
+                    }
+                }
+            }
+        }
+
+        // Handle heartbeat specially
+        if (endpoint.toString() === '_heartbeat') {
+            this._processHeartbeat(JSON.parse(message));
+            return;
+        }
+
+        const data = JSON.parse(message);
+        this[endpoint]._processMessage(data);
+    }
+
+    _processHeartbeat(data) {
+        // Lazy activation: learn frequency from first heartbeat
+        if (this._serverHeartbeatFrequencyMs === null && data.frequencyMs) {
+            this._serverHeartbeatFrequencyMs = data.frequencyMs;
+            this._startHeartbeatChecking();
+        }
+    }
+
+    _startHeartbeatChecking() {
+        // Check once per heartbeat period
+        this._heartbeatCheckInterval = setInterval(() => {
+            this._checkHeartbeatTimeout();
+        }, this._serverHeartbeatFrequencyMs);
+    }
+
+    _checkHeartbeatTimeout() {
+        if (this._lastSourceMessageTime === null || !this._isSourceConnected) {
+            return;
+        }
+
+        const timeSinceLastMessage = Date.now() - this._lastSourceMessageTime;
+        const timeoutThreshold = this._serverHeartbeatFrequencyMs * 3;
+
+        if (timeSinceLastMessage > timeoutThreshold) {
+            this._heartbeatFailed();
+        }
+    }
+
+    _sourceConnected(){
+        // Idempotent - may already be marked connected by _sourceCallback
+        if (this._isSourceConnected) return;
+        this._isSourceConnected = true;
+        this._lastSourceMessageTime = Date.now();  // Reset on reconnect
+
+        for(let endpoint of this.descriptor.endpoints) {
+            if (endpoint.type === 'Source' || endpoint.type === 'SharedObject') {
+                console.error(endpoint.name, 'connected');
+                this[endpoint.name].emit('connected');
+                if (endpoint.type === 'SharedObject' && this.sourceDisconnections[endpoint.name]) {
+                    // _init() now guards against being called when not subscribed
+                    this[endpoint.name]._init();
+                    delete this.sourceDisconnections[endpoint.name];
+                }
+            }
+        }
+    }
+
+    _sourceClosed(){
+        // Idempotent - prevent double-firing
+        if (!this._isSourceConnected) return;
+        this._isSourceConnected = false;
+
+        for(let endpoint of this.descriptor.endpoints) {
+            if (endpoint.type === 'Source' || endpoint.type === 'SharedObject') {
+                console.error(endpoint.name, 'disconnected');
+                this[endpoint.name].emit('disconnected');
+                if (endpoint.type === 'SharedObject') {
+                    this[endpoint.name]._emitDisconnectDiffs();  // BEFORE flush
+                    this[endpoint.name]._flushData();
+                    this.sourceDisconnections[endpoint.name] = true;
+                }
+            }
+        }
+    }
+
+    _heartbeatFailed(){
+        console.error('Heartbeat failed source transport -> Closing connection', this._sourceHostname, this.descriptor.endpoints.map((item)=>{return item.name}).join(','));
+        this.transports.source.disconnect(this._sourceHostname)
+        this._sourceClosed();
+        this.transports.source.connect(this._sourceHostname)
+    }
+
+    _setupRpc(origHostname) {
+        const hostnameAndPort = origHostname.split(":");
+        const hostname = hostnameAndPort[1].substr(2);
+        const port = hostnameAndPort[2];
+        this.transports.rpc = {hostname, port};
+    }
+
+    _setupPull(hostname){
+        const sock = new zmq.socket("pull");
+        // DON'T CONNECT! Client must explicitly ask!
+        sock.on('message', this._pullCallback.bind(this));
+        this.transports.pushpull = sock;
+    }
+
+    _pullCallback(message){
+        if (!this.PullEndpoint){
+            throw new Error("Got a pull message, but ot Pull enpoint is connected!");
+        }
+
+        this.PullEndpoint._processMessage(JSON.parse(message));
+    }
+
+    _setupEndpoints(){
+        for(let endpoint of this.descriptor.endpoints){
+            switch(endpoint.type){
+                case 'RPC':
+                    this[endpoint.name] = new RPCClient(endpoint, this.transports);
+                    break;
+                case 'Source':
+                    this[endpoint.name] = new SourceClient(endpoint, this.transports);
+                    break;
+                case 'SharedObject':
+                    this[endpoint.name] = new SharedObjectClient(endpoint, this.transports, this._options);
+                    this['_SO_'+endpoint.name] = this[endpoint.name];
+                    break;
+                case 'PushPull':
+                    if (this.PullEndpoint){
+                        throw new Error("Only a singly Pushpull endpoint can be constructed per service!");
+                    }
+                    this[endpoint.name] = new PullClient(endpoint, this.transports, this.descriptor.transports.pushpull.client);
+                    this.PullEndpoint = this[endpoint.name];
+                    break;
+                case 'Sink':
+                    this[endpoint.name] = new SinkClient(endpoint, this.transports, this.descriptor.transports.sink.client);
+                    this.SinkEndpoint = this[endpoint.name];
+                    break;
+                default:
+                    throw "Unknown endpoint type.";
+            }
+        }
+    }
+
+    close() {
+        if (this._heartbeatCheckInterval) {
+            clearInterval(this._heartbeatCheckInterval);
+            this._heartbeatCheckInterval = null;
+        }
+        if (this._monitoredSource) {
+            this._monitoredSource.close();
+        }
+        if (this.transports.sink) {
+            this.transports.sink.close();
+        }
+        if (this.transports.pushpull) {
+            this.transports.pushpull.close();
+        }
+    }
+}
+
+module.exports = Client;

package/Client/MonitoredSocket.js

@@ -0,0 +1,61 @@
+"use strict";
+const zmq = require("zeromq/v5-compat");
+const EventEmitter = require("events").EventEmitter;
+
+class MonitoredSocket extends EventEmitter {
+    constructor(type) {
+        super();
+        this.sock = new zmq.socket(type);
+        this.sock.on('monitor_error', this._handleError.bind(this));
+        this.sock.on('disconnect', this._handleDisconnect.bind(this));
+        this.sock.on('connect_retry', this._handleRetry.bind(this));
+        this.sock.on('connect', this._handleConnected.bind(this));
+        this._monitorSocket();
+    }
+
+    _handleError(err) {
+        console.error('Error in monitoring: %s, will restart monitoring in 5 seconds', err);
+        setTimeout(this._monitorSocket.bind(this), 5000);
+    }
+
+    _handleDisconnect(fd, endpoint){
+        this.emit('disconnected');
+    }
+
+    _handleRetry(fd, endpoint){
+        this.emit('connect_retry');
+    }
+
+    _handleConnected(fd, endpoint){
+        this.emit('connected');
+    }
+
+    _monitorSocket(){
+        try {
+            // v5-compat ignores arguments - it reads all events automatically
+            this.sock.monitor();
+        } catch (err) {
+            // In test environments, monitor failures are non-fatal - the socket still works,
+            // we just won't get ZMQ-level disconnect events.
+            // The heartbeat system will still detect disconnects.
+            if (process.env.NODE_ENV === 'test' && err.code === 'EADDRINUSE') {
+                return;
+            }
+            throw err;
+        }
+    }
+
+    close() {
+        try {
+            this.sock.unmonitor();
+        } catch (err) {
+            // In test environments, unmonitor failures are non-fatal during cleanup
+            if (!(process.env.NODE_ENV === 'test' && err.code === 'EADDRINUSE')) {
+                throw err;
+            }
+        }
+        this.sock.close();
+    }
+}
+
+module.exports = MonitoredSocket;

package/Client/PullClient.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const EventEmitter = require("events").EventEmitter;
+
+class PullClient extends EventEmitter{
+    constructor(endpoint, transports, hostname){
+        super();
+        this.endpoint = endpoint;
+        this.transport = transports.pushpull;
+        this.hostname = hostname;
+        if (!this.transport)
+            throw new Error("Trying to construct Source endpoint without Source transport");
+    }
+
+    subscribe(){
+        this.transport.connect(this.hostname);
+    };
+
+    unsubscribe(){
+        this.transport.disconnect(this.hostname);
+    };
+    
+    _processMessage(data){
+        this.emit("message", data);
+    }
+}
+
+module.exports = PullClient;

package/Client/RPCClient.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const http = require('http');
+const doValidation = require("../misc/Validation").RPCValidation;
+
+class RPCClient {
+    constructor(endpoint, transports) {
+        this.transport = transports.rpc;
+        this.endpoint = endpoint;
+        if (!this.transport)
+            throw "Trying to initialise an RPC service without RPC config!";
+    }
+
+    call(input, timeout, callback) {
+        const self = this;
+        if (!callback) { // Make compatible with old code
+            callback = timeout;
+            timeout = 10e3;
+        }
+
+        doValidation(this.endpoint, 'input', input, false);
+
+        let answer_received = false;
+        let answer_timeout = setTimeout(() => {
+            if (!answer_received)
+                callback('timeout');
+            callback = null;
+            answer_received = null;
+        }, timeout);
+        const postData = JSON.stringify({
+            endpoint: this.endpoint.name,
+            input: input
+        });
+        const options = {
+            hostname: this.transport.hostname,
+            port: this.transport.port,
+            path: '/',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(postData)
+            }
+        };
+        const req = http.request(options, (answer) => {
+            answer_received = true;
+            clearTimeout(answer_timeout);
+            answer_timeout = null;
+
+            let body = "";
+            answer.on('data', function (data) {
+                body += data;
+            });
+            answer.on('end', function () {
+                const answer = JSON.parse(body);
+
+                if (!answer.err) {
+                    doValidation(self.endpoint, 'output', answer.res, true);
+                }
+
+                if (callback) {
+                    callback(answer.err, answer.res);
+                }
+            });
+        });
+
+        req.on('error', (e) => {
+            console.error(`problem with request: ${e.message}`);
+            answer_received = true;
+            clearTimeout(answer_timeout);
+            answer_timeout = null;
+
+            if(callback) {
+                callback(e.message);
+                callback = null;
+            }
+        });
+        req.write(postData);
+        req.end();
+    }
+}
+
+module.exports = RPCClient;
+

package/Client/SharedObjectClient.js

@@ -0,0 +1,283 @@
+"use strict";
+
+const EventEmitter = require("events").EventEmitter;
+const deepDiff = require("@azuliani/deep-diff");
+const parseDiffDates = require("../misc/Validation").parseDiffDates;
+const parseFullDates = require("../misc/Validation").parseFullDates;
+
+const REPORTEVERY = 2000;
+const OUTSTANDINGDIFFSTIMEOUT = 2000;
+
+class SharedObjectClient extends EventEmitter {
+    constructor(endpoint, transports, options = {}) {
+        super();
+        if (!transports.rpc || !transports.source)
+            throw new Error("Shared object " + endpoint.name + " needs both Source and RPC transports to be configured");
+
+        this.endpoint = endpoint;
+        this.initTransport = transports.rpc;
+        this.updateTransport = transports.source;
+        // Delay before fetching full state after subscribe. ZMQ subscriptions take
+        // time to propagate to the server, so we wait to allow queued diffs to arrive
+        // first. If too short, we may miss early diffs and end up with version gaps.
+        this._initDelay = options.initDelay ?? 100;
+        this._fetchTimeoutMs = options.initTimeout ?? 3000;
+
+        // Connection and subscription state
+        this._connected = false;
+        this._subscribed = false;
+        this._initTimeout = null;  // Tracks pending init/retry timeouts
+        this._initInFlight = false;
+
+        // Listen to events emitted by parent Client
+        this.on('connected', () => { this._connected = true; });
+        this.on('disconnected', () => { this._connected = false; });
+
+        // Initialize state
+        this.data = {};
+        this._v = 0;
+        this.firstChange = null;
+        this.lastChange = null;
+        this.outstandingDiffs = 0;
+        this.timeSum = 0;
+        this.timeCount = 0;
+        this.ready = false;
+    }
+
+    get connected() {
+        return this._connected;
+    }
+
+    get subscribed() {
+        return this._subscribed;
+    }
+
+    subscribe() {
+        this._subscribed = true;
+        this.updateTransport.subscribe("_SO_" + this.endpoint.name);
+        this._initTimeout = setTimeout(() => { this._init() }, this._initDelay);
+    }
+
+    unsubscribe() {
+        this._subscribed = false;
+        if (this._initTimeout) {
+            clearTimeout(this._initTimeout);
+            this._initTimeout = null;
+        }
+        this.updateTransport.unsubscribe("_SO_" + this.endpoint.name);
+        if (this.endpoint.slicedCache) {
+            this.endpoint.slicedCache.clear();
+        }
+    }
+
+    _processMessage(data) {
+        if (data.endpoint === "_SO_" + this.endpoint.name) {
+            // During init (!ready): queue ALL messages regardless of version.
+            // When init snapshot arrives, messages with v <= snapshot are discarded,
+            // and remaining messages are applied in order.
+            //
+            // After init (ready): require sequential versioning. Gaps trigger reinit.
+
+            if (this.ready) {
+                // Post-init: enforce sequential versioning
+                const expectedVersion = this.lastChange ? this.lastChange.v + 1 : this._v + 1;
+
+                // Skip stale messages (already processed, can arrive after re-init)
+                if (!this.lastChange && data.message.v <= this._v) {
+                    return;
+                }
+
+                // Version gap detected - reinit to recover
+                if (data.message.v !== expectedVersion) {
+                    console.error(new Date(), "(" + this.endpoint.name + ") Out of order message! Expected v=" + expectedVersion + ", got v=" + data.message.v + ". Reinit.");
+                    return this._init();
+                }
+            }
+
+            // Link message into queue (always, during init; sequentially verified, after init)
+            if (!this.lastChange) {
+                this.firstChange = data.message;
+            } else {
+                this.lastChange.next = data.message;
+            }
+            this.lastChange = data.message;
+
+            this.outstandingDiffs++;
+
+            setImmediate(() => { this._tryApply() });
+        }
+    }
+
+    _tryApply() {
+        const totalDiffs = [];
+        const now = +(new Date());
+
+        if (!this.firstChange || !this.ready) {
+            return;
+        }
+
+
+        let ptr = this.firstChange;
+
+        while (ptr) {
+            // Version gap in queued messages - can happen if initDelay was too short
+            // and we missed early diffs. Reinit to recover.
+            if (ptr.v !== this._v + 1) {
+                console.error(new Date(), "(" + this.endpoint.name + ") Version gap in queued message! Expected v=" + (this._v + 1) + ", got v=" + ptr.v + ". Reinit.");
+                return this._init();
+            }
+
+            // Diffs are already reversed by Server!
+            let diffs = ptr.diffs;
+            safePush(totalDiffs, diffs)
+
+            for(let diff of diffs) {
+                parseDiffDates(this.endpoint, diff);
+            }
+            deepDiff.applyDiff(this.data, diffs);
+
+            this.timeSum += now - new Date(ptr.now);
+            this.timeCount++;
+
+            this._v++;
+
+            ptr = ptr.next;
+        }
+
+        this.firstChange = null;
+        this.lastChange = null;
+        this.outstandingDiffs = 0;
+
+        if (totalDiffs.length > 0) {
+
+            //setImmediate(() => { this.emit('update', totalDiffs); });
+            this.emit('update', totalDiffs);
+
+            if (this.timeCount > REPORTEVERY) {
+                console.error("(" + this.endpoint.name + ") Average time: " + (this.timeSum / this.timeCount) + " ms");
+                this.emit('timing', this.timeSum / this.timeCount);
+                this.timeSum = 0;
+                this.timeCount = 0;
+            }
+
+            if (this.outstandingDiffsTimeout) {
+                console.error(new Date(), "(" + this.endpoint.name + ") Managed to process messages. Clearing the outstanding diffs timer.");
+                clearTimeout(this.outstandingDiffsTimeout);
+                delete this.outstandingDiffsTimeout;
+            }
+
+        } else if (this.ready && this.outstandingDiffs > 10) {
+            if (!this.outstandingDiffsTimeout) {
+                console.error(new Date(), "(" + this.endpoint.name + ") Too many outstanding diffs. Starting the re-init timer.");
+                this.outstandingDiffsTimeout = setTimeout( () => {
+                    console.error(new Date(), "(" + this.endpoint.name + ") Actually calling init now after outstanding diffs.");
+                    delete this.outstandingDiffsTimeout;
+                    this._init();
+                }, OUTSTANDINGDIFFSTIMEOUT);
+            }
+        }
+    }
+
+    _prepareForInit() {
+        // Reset state but preserve message queue - it will be filtered
+        // when HTTP snapshot arrives (keeping only v > snapshot version)
+        this.data = {};
+        this._v = 0;
+        this.timeSum = 0;
+        this.timeCount = 0;
+        this.ready = false;
+    }
+
+    _emitDisconnectDiffs() {
+        // Generate synthetic diffs showing all properties deleted
+        const diffs = [];
+        for (const key of Object.keys(this.data)) {
+            diffs.push({
+                kind: 'D',           // Deletion
+                path: [key],
+                lhs: this.data[key]  // The value being deleted
+            });
+        }
+        if (diffs.length > 0) {
+            this.emit('update', diffs);
+        }
+    }
+
+    _flushData() {
+        // Reset all state on disconnect
+        this._prepareForInit();
+        // Also clear message queue (unlike _prepareForInit which preserves it)
+        this.firstChange = null;
+        this.lastChange = null;
+        this.outstandingDiffs = 0;
+    }
+
+    _init() {
+        if (!this._subscribed || this._initInFlight) return;
+
+        this._initInFlight = true;
+        this._prepareForInit();
+
+        fetch(`http://${this.initTransport.hostname}:${this.initTransport.port}/`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                endpoint: `_SO_${this.endpoint.name}`,
+                input: "init"
+            }),
+            signal: AbortSignal.timeout(this._fetchTimeoutMs)
+        })
+        .then((res) => {
+            if (!res.ok) throw new Error(`HTTP ${res.status}`);
+            return res.json();
+        })
+        .then((answer) => {
+            if (!this._subscribed) return;
+
+            parseFullDates(this.endpoint, answer.res.data);
+            this.data = answer.res.data;
+            this._v = answer.res.v;
+
+            let ptr = this.firstChange;
+            let skipped = 0;
+            while (ptr && ptr.v <= answer.res.v) {
+                ptr = ptr.next;
+                skipped++;
+            }
+
+            this.firstChange = ptr || null;
+            this.lastChange = null;
+            this.outstandingDiffs = 0;
+
+            while (ptr) {
+                this.outstandingDiffs++;
+                this.lastChange = ptr;
+                ptr = ptr.next;
+            }
+
+            console.error(`${new Date()} (${this.endpoint.name}) Init installed version ${answer.res.v}. Skipped ${skipped} past changes. Have ${this.outstandingDiffs} outstanding changes.`);
+
+            this.ready = true;
+            this._tryApply();
+            this.emit('init', {v: answer.res.v, data: answer.res.data});
+        })
+        .catch((err) => {
+            console.error(`(${this.endpoint.name}) Init failed: ${err.message}`);
+            if (this._subscribed) {
+                this._initTimeout = setTimeout(() => this._init(), 1000);
+            }
+        })
+        .finally(() => {
+            this._initInFlight = false;
+        });
+    }
+}
+
+function safePush(to, push) {
+    let startIndex = to.length;
+    for(let i = 0; i<push.length; i++) {
+        to[startIndex+i] = push[i];
+    }
+}
+
+module.exports = SharedObjectClient;