node-firebird 1.1.9 → 2.0.0

package/lib/wire/eventConnection.js

@@ -3,111 +3,113 @@ const { XdrReader } = require('./serialize');
 const DEFAULT_ENCODING = 'utf8';
 const Const = require('./const');
 
-var EventConnection = function (host, port, callback, db) {
-    var self = this;
-    this.db = db;
-    this.emgr = null;
-    this._isClosed = false;
-    this._isOpened = false;
-    this._socket = net.createConnection(port, host);
-    this._bind_events(host, port, callback);
-    this.error;
-    this.eventcallback;
-};
+class EventConnection {
+    constructor(host, port, callback, db) {
+        var self = this;
+        this.db = db;
+        this.emgr = null;
+        this._isClosed = false;
+        this._isOpened = false;
+        this._socket = net.createConnection(port, host);
+        this._bind_events(host, port, callback);
+        this.error;
+        this.eventcallback;
+    }
 
-EventConnection.prototype._bind_events = function (host, port, callback) {
-    var self = this;
+    _bind_events(host, port, callback) {
+        var self = this;
 
-    self._socket.on('close', function () {
+        self._socket.on('close', function () {
 
-        self._isClosed = true;
-    })
+            self._isClosed = true;
+        })
 
-    self._socket.on('error', function (e) {
+        self._socket.on('error', function (e) {
 
-        self.error = e;
-    })
+            self.error = e;
+        })
 
-    self._socket.on('connect', function () {
-        self._isClosed = false;
-        self._isOpened = true;
-        if (callback)
-            callback();
-    });
+        self._socket.on('connect', function () {
+            self._isClosed = false;
+            self._isOpened = true;
+            if (callback)
+                callback();
+        });
 
-    self._socket.on('data', function (data) {
-        var xdr, buf;
+        self._socket.on('data', function (data) {
+            var xdr, buf;
 
-        if (!self._xdr) {
-            xdr = new XdrReader(data);
-        } else {
-            xdr = self._xdr;
-            delete (self._xdr);
-            buf = Buffer.from(data.length + xdr.buffer.length);
-            xdr.buffer.copy(buf);
-            data.copy(buf, xdr.buffer.length);
-            xdr.buffer = buf;
-        }
+            if (!self._xdr) {
+                xdr = new XdrReader(data);
+            } else {
+                xdr = self._xdr;
+                delete (self._xdr);
+                buf = Buffer.from(data.length + xdr.buffer.length);
+                xdr.buffer.copy(buf);
+                data.copy(buf, xdr.buffer.length);
+                xdr.buffer = buf;
+            }
 
-        try {
-            var item, op;
-            var op_pos = xdr.pos;
-            var tmp_event;
-            while (xdr.pos < xdr.buffer.length) {
-                do {
-                    var r = xdr.readInt();
-                } while (r === Const.op_dummy);
+            try {
+                var item, op;
+                var op_pos = xdr.pos;
+                var tmp_event;
+                while (xdr.pos < xdr.buffer.length) {
+                    do {
+                        var r = xdr.readInt();
+                    } while (r === Const.op_dummy);
 
-                switch (r) {
-                    case Const.op_event:
-                        xdr.readInt(); // db handle
-                        var buf = xdr.readArray();
-                        // first byte is always set to 1
-                        tmp_event = {};
-                        var lst_event = [];
-                        var eventname = '';
-                        var eventcount = 0;
-                        var pos = 1;
-                        while (pos < buf.length) {
-                            var len = buf.readInt8(pos++);
-                            eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
-                            var prevcount = self.emgr.events[eventname] || 0;
-                            pos += len;
-                            eventcount = buf.readInt32LE(pos);
-                            tmp_event[eventname] = eventcount;
-                            pos += 4;
-                            if (prevcount !== eventcount)
-                                lst_event.push({ name: eventname, count: eventcount });
-                        }
-                        xdr.readInt64(); // ignore AST INFO
-                        var event_id = xdr.readInt();
-                        // set the new count in global event hash
-                        for (var evt in tmp_event) {
-                            self.emgr.events[evt] = tmp_event[evt];
-                        }
-                        if (self.eventcallback)
-                            return self.eventcallback(null, { eventid: event_id, events: lst_event });
+                    switch (r) {
+                        case Const.op_event:
+                            xdr.readInt(); // db handle
+                            var buf = xdr.readArray();
+                            // first byte is always set to 1
+                            tmp_event = {};
+                            var lst_event = [];
+                            var eventname = '';
+                            var eventcount = 0;
+                            var pos = 1;
+                            while (pos < buf.length) {
+                                var len = buf.readInt8(pos++);
+                                eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
+                                var prevcount = self.emgr.events[eventname] || 0;
+                                pos += len;
+                                eventcount = buf.readInt32LE(pos);
+                                tmp_event[eventname] = eventcount;
+                                pos += 4;
+                                if (prevcount !== eventcount)
+                                    lst_event.push({ name: eventname, count: eventcount });
+                            }
+                            xdr.readInt64(); // ignore AST INFO
+                            var event_id = xdr.readInt();
+                            // set the new count in global event hash
+                            for (var evt in tmp_event) {
+                                self.emgr.events[evt] = tmp_event[evt];
+                            }
+                            if (self.eventcallback)
+                                return self.eventcallback(null, { eventid: event_id, events: lst_event });
 
-                    default:
-                        return cb(new Error('Unexpected:' + r));
+                        default:
+                            return cb(new Error('Unexpected:' + r));
+                    }
+                }
+            } catch (err) {
+                if (err instanceof RangeError) { // incomplete packet case
+                    xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
+                    xdr.pos = 0;
+                    self._xdr = xdr;
                 }
             }
-        } catch (err) {
-            if (err instanceof RangeError) { // incomplete packet case
-                xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
-                xdr.pos = 0;
-                self._xdr = xdr;
-            }
-        }
-    })
-}
+        })
+    }
 
-EventConnection.prototype.throwClosed = function (callback) {
-    var err = new Error('Event Connection is closed.');
-    this.db.emit('error', err);
-    if (callback)
-        callback(err);
-    return this;
-};
+    throwClosed(callback) {
+        var err = new Error('Event Connection is closed.');
+        this.db.emit('error', err);
+        if (callback)
+            callback(err);
+        return this;
+    }
+}
 
 module.exports = EventConnection;

package/lib/wire/fbEventManager.js

@@ -1,98 +1,133 @@
 const Events = require('events');
 const { doError } = require('../callback');
 
+class FbEventManager extends Events.EventEmitter {
+    constructor(db, eventconnection, eventid, callback) {
+        super();
+        this.db = db;
+        this.eventconnection = eventconnection;
+        this.events = {};
+        this.eventid = eventid;
+        this._createEventLoop(callback);
+    }
 
-function FbEventManager(db, eventconnection, eventid, callback) {
-    this.db = db;
-    this.eventconnection = eventconnection;
-    this.events = {};
-    this.eventid = eventid;
-    this._createEventLoop(callback);
-}
+    _createEventLoop(callback) {
+        var self = this;
+        var cnx = this.db.connection;
+        this.eventconnection.emgr = this;
+        console.log('[EventManager] Creating event loop, eventid:', this.eventid);
+        // create the loop
+        function loop(first) {
+            console.log('[EventManager] Calling queEvents, first:', first, 'events:', Object.keys(self.events));
+            cnx.queEvents(self.events, self.eventid, function (err, ret) {
+                console.log('[EventManager] queEvents callback, err:', err, 'ret:', ret, 'first:', first);
+                if (err) {
+                    console.log('[EventManager] queEvents error:', err);
+                    doError(err, callback);
+                    return;
+                }
+                if (first) {
+                    console.log('[EventManager] First loop complete, calling callback');
+                    callback(null);
+                }
+            })
+        }
 
-FbEventManager.prototype.__proto__ = Object.create(Events.EventEmitter.prototype, {
-    constructor: {
-        value: FbEventManager,
-        enumberable: false
-    }
-});
-
-FbEventManager.prototype._createEventLoop = function (callback) {
-    var self = this;
-    var cnx = this.db.connection;
-    this.eventconnection.emgr = this;
-    // create the loop
-    function loop(first) {
-        cnx.queEvents(self.events, self.eventid, function (err, ret) {
-            if (err) {
-                doError(err, callback);
+        this.eventconnection.eventcallback = function (err, ret) {
+            console.log('[EventManager] eventcallback invoked, err:', err, 'eventid match:', self.eventid === ret?.eventid);
+            if (err || (self.eventid !== ret.eventid)) {
+                doError(err || new Error('Bad eventid'), callback);
                 return;
             }
-            if (first)
-                callback();
-        })
-    }
 
-    this.eventconnection.eventcallback = function (err, ret) {
-        if (err || (self.eventid !== ret.eventid)) {
-            doError(err || new Error('Bad eventid'), callback);
-            return;
-        }
+            ret.events.forEach(function (event) {
+                self.emit('post_event', event.name, event.count)
+            })
 
-        ret.events.forEach(function (event) {
-            self.emit('post_event', event.name, event.count)
-        })
+            loop(false);
+        }
 
-        loop(false);
+        loop(true);
     }
 
-    loop(true);
-}
+    _changeEvent(callback) {
+        var self = this;
 
-FbEventManager.prototype._changeEvent = function (callback) {
-    var self = this;
+        console.log('[EventManager] _changeEvent called, eventid:', this.eventid, 'events:', Object.keys(self.events));
+        // Temporarily suppress the event loop to prevent stale op_event
+        // notifications from pushing spurious queEvents onto the main
+        // connection queue while closeEvents + queEvents are in flight
+        var savedCallback = self.eventconnection.eventcallback;
+        self.eventconnection.eventcallback = null;
+        console.log('[EventManager] Suppressed event callback, calling closeEvents');
 
-    self.db.connection.closeEvents(this.eventid, function (err) {
-        if (err) {
-            doError(err, callback);
-            return;
-        }
-        
-        self.db.connection.queEvents(self.events, self.eventid, callback);
-    })
-}
+        self.db.connection.closeEvents(this.eventid, function (err) {
+            console.log('[EventManager] closeEvents callback, err:', err);
+            if (err) {
+                self.eventconnection.eventcallback = savedCallback;
+                doError(err, callback);
+                return;
+            }
+            
+            console.log('[EventManager] closeEvents success, calling queEvents');
+            self.db.connection.queEvents(self.events, self.eventid, function (err, ret) {
+                console.log('[EventManager] queEvents callback in _changeEvent, err:', err, 'ret:', ret);
+                // Restore the event loop now that our queEvents is safely queued
+                self.eventconnection.eventcallback = savedCallback;
+                console.log('[EventManager] Restored event callback');
+                if (err) {
+                    console.log('[EventManager] queEvents error in _changeEvent:', err);
+                    doError(err, callback);
+                    return;
+                }
+                console.log('[EventManager] _changeEvent complete, calling final callback');
+                callback(null, ret);
+            });
+        })
+    }
 
-FbEventManager.prototype.registerEvent = function (events, callback) {
-    var self = this;
+    registerEvent(events, callback) {
+        var self = this;
 
-    if (self.db.connection._isClosed || self.eventconnection._isClosed)
-        return self.eventconnection.throwClosed(callback);
+        console.log('[EventManager] registerEvent called with events:', events);
+        console.log('[EventManager] Connection closed?', self.db.connection._isClosed, 'Event connection closed?', self.eventconnection._isClosed);
+        
+        if (self.db.connection._isClosed || self.eventconnection._isClosed)
+            return self.eventconnection.throwClosed(callback);
 
-    events.forEach((event) => self.events[event] = self.events[event] || 0);
-    self._changeEvent(callback);
-}
+        events.forEach((event) => self.events[event] = self.events[event] || 0);
+        console.log('[EventManager] Events registered, current events:', Object.keys(self.events));
+        self._changeEvent(callback);
+    }
 
-FbEventManager.prototype.unregisterEvent = function (events, callback) {
-    var self = this;
+    unregisterEvent(events, callback) {
+        var self = this;
 
-    if (self.db.connection._isClosed || self.eventconnection._isClosed)
-        return self.eventconnection.throwClosed(callback);
+        if (self.db.connection._isClosed || self.eventconnection._isClosed)
+            return self.eventconnection.throwClosed(callback);
 
-    events.forEach(function (event) { delete self.events[event] });
-    self._changeEvent(callback);
-}
+        events.forEach(function (event) { delete self.events[event] });
+        self._changeEvent(callback);
+    }
 
-FbEventManager.prototype.close = function (callback) {
-    var self = this;
+    close(callback) {
+        var self = this;
 
-    self.db.connection.closeEvents(this.eventid, function (err) {
-        if (err) {
-            doError(err, callback);
-            return;
-        }
+        // Prevent the event loop from re-queuing on stale op_event notifications
+        // that may arrive between closeEvents and socket.end()
+        self.eventconnection.eventcallback = null;
+
+        self.db.connection.closeEvents(this.eventid, function (err) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
 
-        self.eventconnection._socket.end();
-    });
+            self.eventconnection._socket.end();
+            if (callback)
+                callback();
+        });
+    }
 }
 
 module.exports = FbEventManager;