@droidsolutions-oss/amqp-ts 3.0.4 → 4.0.0-develop.1

package/lib/Connection/Connection.js

@@ -1,151 +1,365 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = void 0;
-const AmqpLib = require("amqplib/callback_api");
-const events_1 = require("events");
-const Exchange_1 = require("../Exchange/Exchange");
-const LoggerFactory_1 = require("../LoggerFactory");
-const Queue_1 = require("../Queue/Queue");
-class Connection extends events_1.EventEmitter {
+import { connect } from "amqplib";
+import { EventEmitter } from "node:events";
+import { Binding } from "../Binding.js";
+import { Deferred } from "../Deferred.js";
+import { Exchange } from "../Exchange/Exchange.js";
+import { errorMessage } from "../errorMessage.js";
+import { EmtpyLogger } from "../LoggerFactory.js";
+import { Queue } from "../Queue/Queue.js";
+export class Connection extends EventEmitter {
+    loggerFactory;
+    /**
+     * Resolves once the connection is established and the declared topology was set up. It is replaced by a pending
+     * promise when the connection is lost and resolves again after the next successful reconnect. It rejects when
+     * recovery gives up or the connection is closed before it was established.
+     *
+     * It only reflects the connection: an exchange, queue, binding or consumer that fails on its own does not keep it
+     * from resolving. Use {@link completeConfiguration} to wait for the topology.
+     */
+    initialized;
+    isConnected = false;
+    /**
+     * The current underlying amqplib model, `undefined` while disconnected.
+     * @internal
+     */
+    _model;
+    /**
+     * Identifies the current underlying model. Changes on each successful connect, so entities can tell whether they
+     * are initialized on the current connection.
+     * @internal
+     */
+    _generation = 0;
+    /** @internal */
+    _exchanges;
+    /** @internal */
+    _queues;
+    /** @internal */
+    _bindings;
+    _deferred;
+    _recovering;
+    /** Counter for connect attempts that reach `setup`; each of them gets its own generation. */
+    _lastGeneration = 0;
+    /** The model `setup` is currently running for, and its generation. */
+    _setupModel;
+    _setupGeneration = 0;
+    _closedModels = new WeakSet();
+    _connectedBefore = false;
+    _isClosing = false;
+    _closing;
+    /** Why recovery is over, set by {@link close} or when recovery gave up. Nothing is initialized after that. */
+    _stopError;
+    /** Why exchanges, queues and bindings failed on their own, until the same one is declared again. */
+    _failures = new Map();
+    log;
+    _sentMessagesCounter = 0;
+    _receivedMessagesCounter = 0;
     /**
      *
      * @param url The url to RabbitMQ
-     * @param socketOptions Socket options are passed to {@link AmqpLib.connect}.
-     * @param reconnectStrategy Options specifying the reconnect strategy.
+     * @param socketOptions Socket options are passed to amqplib's `connect`.
+     * @param recovery Options for the automatic reconnect, passed to amqplib's connection recovery. By default it retries
+     * forever with exponential backoff.
      * @param loggerFactory A factory function that returns a logger.
      */
-    constructor(url = "amqp://localhost", socketOptions = {}, reconnectStrategy = { retries: 0, interval: 1500 }, loggerFactory) {
+    constructor(url = "amqp://localhost", socketOptions = {}, recovery = {}, loggerFactory) {
         super();
         this.loggerFactory = loggerFactory;
-        this.isConnected = false;
-        this.connectedBefore = false;
-        this._rebuilding = false;
-        this._isClosing = false;
-        this._sentMessagesCounter = 0;
-        this._receivedMessagesCounter = 0;
         if (!this.loggerFactory) {
-            this.loggerFactory = (_, __) => new LoggerFactory_1.EmtpyLogger();
+            this.loggerFactory = (_, __) => new EmtpyLogger();
         }
         this.log = this.loggerFactory(this.constructor, { module: "amqp-ts" });
-        this.url = url;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        this.socketOptions = socketOptions;
-        this.reconnectStrategy = reconnectStrategy;
         this._exchanges = {};
         this._queues = {};
         this._bindings = {};
-        this.rebuildConnection();
+        this._deferred = new Deferred();
+        this.initialized = this._deferred.promise;
+        // waitForConnect: false resolves right away and defers the first attempt, so the listeners are attached in time
+        this._recovering = connect(url, {
+            ...socketOptions,
+            recovery: { ...recovery, waitForConnect: false, setup: (model) => this._setup(model) },
+        });
+        this._recovering.then((recovering) => this._listen(recovering), 
+        /* istanbul ignore next */ (err) => this._giveUp(err));
     }
-    tryToConnect(thisConnection, retry, callback) {
-        AmqpLib.connect(thisConnection.url, thisConnection.socketOptions, (err, connection) => {
-            /* istanbul ignore if */
-            if (err) {
-                thisConnection.isConnected = false;
-                // only do every retry once, amqplib can return multiple connection errors for one connection request (error?)
-                if (retry <= this._retry) {
-                    //amqpts_log.log("warn" , "Double retry " + retry + ", skipping.", {module: "amqp-ts"});
-                    return;
-                }
-                this.log.warn({ err }, "Connection failed.");
-                this._retry = retry;
-                if (thisConnection.reconnectStrategy.retries === 0 || thisConnection.reconnectStrategy.retries > retry) {
-                    this.log.warn("Connection retry %d in %d ms", retry + 1, thisConnection.reconnectStrategy.interval);
-                    thisConnection.emit("trying_connect");
-                    setTimeout(
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    thisConnection.tryToConnect.bind(this), thisConnection.reconnectStrategy.interval, thisConnection, retry + 1, callback);
-                }
-                else {
-                    //no reconnect strategy, or retries exhausted, so return the error
-                    this.log.warn("Connection failed, exiting: No connection retries left (retry %d).", retry);
-                    callback(err);
+    close() {
+        if (this._closing === undefined) {
+            this._isClosing = true;
+            // buffered sends and anyone awaiting initialized must not wait for a connection that never comes
+            this._stop(new Error("Connection closed"));
+            this._closing = this._close();
+        }
+        return this._closing;
+    }
+    /**
+     * A new deferred for an entity's promise. Once the connection was closed or recovery gave up nothing would
+     * ever settle it, so it is rejected right away.
+     * @internal
+     */
+    _createDeferred() {
+        const deferred = new Deferred();
+        if (this._stopError !== undefined) {
+            deferred.reject(this._stopError);
+        }
+        return deferred;
+    }
+    /**
+     * An exchange, queue or binding failed on its own, not because the connection was lost: it is no longer
+     * declared and its {@link initialized} is rejected.
+     *
+     * The bindings of a failed exchange or queue can never be created any more, so they are rejected and removed as
+     * well. The failure is emitted as `error_connection`, see {@link _reportFailure}.
+     * @internal
+     */
+    _onEntityFailed(entity, err) {
+        if (!(entity instanceof Binding)) {
+            for (const [id, binding] of Object.entries(this._bindings)) {
+                if (binding._source === entity || binding._destination === entity) {
+                    delete this._bindings[id];
+                    binding._rejectPending(err);
                 }
             }
-            else {
-                const restart = (err) => {
-                    this.log.debug({ err }, "Connection error occurred.");
-                    connection.removeListener("error", restart);
-                    //connection.removeListener("end", restart); // not sure this is needed
-                    thisConnection._rebuildAll(err); //try to rebuild the topology when the connection  unexpectedly closes
-                };
-                const onClose = () => {
-                    connection.removeListener("close", onClose);
-                    if (!this._isClosing) {
-                        thisConnection.emit("lost_connection");
-                        restart(new Error("Connection closed by remote host"));
-                    }
-                };
-                connection.on("error", restart);
-                connection.on("close", onClose);
-                //connection.on("end", restart); // not sure this is needed
-                thisConnection.connection = connection;
-                thisConnection.isConnected = true;
-                callback(null);
+        }
+        this._failures.set(Connection._failureKey(entity), err);
+        this._reportFailure(err);
+    }
+    /**
+     * An exchange, queue or binding is declared (again): a failure of an earlier one with the same name no longer
+     * counts for {@link completeConfiguration}.
+     * @internal
+     */
+    _forgetFailure(entity) {
+        this._failures.delete(Connection._failureKey(entity));
+    }
+    static _failureKey(entity) {
+        if (entity instanceof Binding) {
+            return `binding ${entity._id}`;
+        }
+        return `${entity instanceof Queue ? "queue" : "exchange"} ${entity.name}`;
+    }
+    /**
+     * Emits `error_connection` for an exchange, queue, binding or consumer that failed on its own, whether it was
+     * declared for the first time or again during recovery. Nobody has to await the entity's promise, for example after
+     * a `declareQueue` nobody awaits or during recovery, so this is the one signal that always arrives.
+     * @internal
+     */
+    _reportFailure(err) {
+        this._emitSafely("error_connection", err);
+    }
+    /**
+     * The model entities are initialized on right now: the current one, or while `setup` runs the one it runs for.
+     * `undefined` while disconnected.
+     * @internal
+     */
+    get _activeModel() {
+        return this._model ?? this._setupModel;
+    }
+    /**
+     * Whether the connection was closed or recovery gave up, so nothing is initialized any more.
+     * @internal
+     */
+    get _isStopped() {
+        return this._isClosing || this._stopError !== undefined;
+    }
+    /**
+     * Whether the given model has closed.
+     * @internal
+     */
+    _isModelClosed(model) {
+        return this._closedModels.has(model);
+    }
+    /**
+     * Whether a channel of the given model may be re-created after it closed: the model is open, and it is
+     * either the current one or the one `setup` is running for.
+     * @internal
+     */
+    _isModelUsable(model) {
+        return !this._isClosing && !this._closedModels.has(model) && (model === this._model || model === this._setupModel);
+    }
+    async _close() {
+        const recovering = await this._recovering.catch(() => undefined);
+        if (recovering) {
+            await recovering.close();
+        }
+        this._model = undefined;
+        this.isConnected = false;
+        this.log.info("AMQP Connection closed.");
+        this._emitSafely("close_connection");
+    }
+    /**
+     * Recovery is over, because of {@link close} or because it gave up: rejects every promise that is still pending,
+     * the connection's and the entities', since nothing settles them any more.
+     */
+    _stop(err) {
+        this._stopError ??= err;
+        if (!this._deferred.settled) {
+            this._deferred.reject(err);
+        }
+        for (const exchange of Object.values(this._exchanges)) {
+            exchange._rejectPending(err);
+            exchange._notifyChanged();
+        }
+        for (const queue of Object.values(this._queues)) {
+            queue._rejectPending(err);
+            queue._notifyChanged();
+        }
+        for (const binding of Object.values(this._bindings)) {
+            binding._rejectPending(err);
+        }
+    }
+    /**
+     * Emits an event to the user's listeners. Most events are emitted from within amqplib's recovery, where a throwing
+     * listener would stop the reconnect from being scheduled, or from a promise chain, where it would be an unhandled
+     * rejection. So a listener's error is logged instead, and the listeners after it still get the event. The order is
+     * that of `emit`, and `once` listeners remove themselves as usual.
+     */
+    _emitSafely(event, ...args) {
+        for (const listener of this.rawListeners(event)) {
+            try {
+                listener.apply(this, args);
             }
+            catch (err) {
+                this.log.error({ err }, "A listener for '%s' threw: %s", event, errorMessage(err));
+            }
+        }
+    }
+    _listen(recovering) {
+        recovering.on("connect", (model) => this._onConnect(model));
+        recovering.on("disconnect", (err) => this._onDisconnect(err));
+        recovering.on("connect-failed", (err) => {
+            this.log.warn({ err }, "Connection failed.");
+        });
+        recovering.on("reconnect-scheduled", ({ attempt, delay }) => {
+            this.log.warn("Connection retry %d in %d ms", attempt, delay);
+            this._emitSafely("trying_connect");
+        });
+        recovering.on("reconnect-failed", (err) => this._giveUp(err));
+        recovering.on("error", (err) => {
+            this.log.warn({ err }, "Connection error: %s", err.message);
+        });
+        recovering.on("handler-error", (err, event) => {
+            this.log.error({ err }, "A listener for '%s' threw: %s", event, err.message);
+        });
+        recovering.on("blocked", (reason) => {
+            this.log.warn("Connection blocked by the broker: %s", reason);
+        });
+        recovering.on("unblocked", () => {
+            this.log.info("Connection unblocked by the broker.");
         });
     }
-    _rebuildAll(err) {
-        this.log.warn({ err }, "Connection error: %s", err.message);
-        this.log.debug("Rebuilding connection NOW.");
-        this.rebuildConnection();
-        //re initialize exchanges, queues and bindings if they exist
-        for (const exchangeId in this._exchanges) {
-            const exchange = this._exchanges[exchangeId];
-            this.log.debug("Re-initialize Exchange '%s'.", exchange.name);
-            exchange._initialize();
+    /**
+     * Runs after every successful (re)connect, before amqplib installs the model: rebuilds the topology on fresh
+     * channels. It only throws when the model itself closed meanwhile, which makes amqplib schedule another reconnect.
+     */
+    async _setup(model) {
+        const generation = ++this._lastGeneration;
+        this._setupModel = model;
+        this._setupGeneration = generation;
+        // until amqplib installs the model it has no listeners on it, and an "error" without a listener would throw
+        model.on("error", (err) => {
+            this.log.debug({ err }, "Connection error during setup: %s", err.message);
+        });
+        model.on("close", () => {
+            this._closedModels.add(model);
+        });
+        this.log.debug("Initializing the topology on a new connection.");
+        await this._declareEntities(model, generation);
+        if (this._closedModels.has(model)) {
+            throw new Error("Connection closed while the topology was initialized");
         }
-        for (const queueId in this._queues) {
-            const queue = this._queues[queueId];
-            const consumer = queue._consumer;
-            this.log.debug("Re-initialize queue '%s'.", queue.name);
-            queue._initialize();
-            if (consumer) {
-                this.log.debug("Re-initialize consumer for queue '%s'.", queue.name);
-                queue._initializeConsumer();
+    }
+    /**
+     * Initializes every entity that is not initialized on the given generation yet: exchanges, then queues, then
+     * bindings, then queue consumers. Entity failures are handled by the entities themselves.
+     *
+     * A binding whose source exchange belongs to another connection waits for that connection, so it is not awaited:
+     * an outage of the other connection must not hold up this one's recovery.
+     */
+    async _declareEntities(model, generation) {
+        const settle = async (promises) => {
+            await Promise.allSettled(promises);
+        };
+        await settle(Object.values(this._exchanges).map((exchange) => exchange._initialize(model, generation)));
+        await settle(Object.values(this._queues).map((queue) => queue._initialize(model, generation)));
+        await settle(Object.values(this._bindings).flatMap((binding) => {
+            const initializing = binding._initialize(model, generation);
+            if (binding._isCrossConnection) {
+                initializing.catch(() => { });
+                return [];
+            }
+            return [initializing];
+        }));
+        await settle(Object.values(this._queues).map((queue) => queue._initializeConsumer()));
+    }
+    _onConnect(model) {
+        const generation = this._setupGeneration;
+        this._setupModel = undefined;
+        this._model = model;
+        this._generation = generation;
+        this.isConnected = true;
+        // entities declared while setup was running were not part of it
+        void this._declareEntities(model, generation).then(() => {
+            if (this._isClosing || this._model !== model) {
+                return;
+            }
+            this._deferred.resolve();
+            if (this._connectedBefore) {
+                this.log.info("AMQP Connection re-established");
+                this._emitSafely("re_established_connection");
+            }
+            else {
+                this._connectedBefore = true;
+                this.log.info("AQMP Connection established.");
+                this._emitSafely("open_connection");
             }
+        });
+    }
+    _onDisconnect(err) {
+        this._model = undefined;
+        this.isConnected = false;
+        for (const exchange of Object.values(this._exchanges)) {
+            exchange._invalidate();
         }
-        for (const bindingId in this._bindings) {
-            const binding = this._bindings[bindingId];
-            this.log.debug("Re-initialize binding from '%s' to '%s'.", binding._source.name, binding._destination.name);
-            binding._initialize();
+        for (const queue of Object.values(this._queues)) {
+            queue._invalidate();
+        }
+        for (const binding of Object.values(this._bindings)) {
+            binding._invalidate();
+        }
+        this._invalidate();
+        if (!this._isClosing) {
+            this.log.warn({ err }, "Connection lost: %s", err.message);
+            this._emitSafely("lost_connection");
         }
-        return new Promise((resolve, reject) => {
-            this.completeConfiguration().then(() => {
-                this.log.debug("Rebuild success.");
-                resolve(null);
-            }, 
-            /* istanbul ignore next */ (rejectReason) => {
-                this.log.debug("Rebuild failed.");
-                reject(rejectReason);
-            });
-        });
     }
-    close() {
-        this._isClosing = true;
-        return new Promise((resolve, reject) => {
-            this.initialized.then(() => {
-                this.connection.close((err) => {
-                    /* istanbul ignore if */
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        this.isConnected = false;
-                        this.emit("close_connection");
-                        resolve(null);
-                    }
-                });
-            });
-        });
+    /** Recovery gave up: no further reconnect is attempted. */
+    _giveUp(err) {
+        this._model = undefined;
+        this.isConnected = false;
+        this._invalidate();
+        this._stop(err);
+        this.log.warn({ err }, "Connection failed, giving up: %s", errorMessage(err));
+        this._emitSafely("error_connection", err);
+    }
+    /** Replaces a settled {@link initialized} with a pending one. */
+    _invalidate() {
+        if (this._deferred.settled) {
+            this._deferred = new Deferred();
+            this.initialized = this._deferred.promise;
+        }
     }
     /**
-     * Make sure the whole defined connection topology is configured. Goes through each exchange, queue and binding and
-     * waits until all of them are initialized.
+     * Waits until the whole declared topology is initialized: every exchange, queue and binding, and the consumer of
+     * every queue with an activated consumer. Use it to gate the start of an application, since {@link initialized}
+     * only reflects the connection.
      *
-     * @return A promise that fulfills after all defined exchanges, queues and bindings are initialized.
+     * It rejects when one of them failed on its own, at the first connect or later. A failed exchange, queue or binding
+     * counts until one with the same name is declared again (or {@link deleteConfiguration} is called), a refused
+     * consumer until it is registered on the next reconnect. While the connection is down it waits for the reconnect.
+     *
+     * @return A promise that fulfills after all defined exchanges, queues, bindings and consumers are initialized.
      */
     completeConfiguration() {
-        const promises = [];
+        const promises = [...this._failures.values()].map((err) => Promise.reject(err));
         for (const exchangeId in this._exchanges) {
             const exchange = this._exchanges[exchangeId];
             promises.push(exchange.initialized);
@@ -164,27 +378,31 @@ class Connection extends events_1.EventEmitter {
         return Promise.all(promises);
     }
     /**
-     * Delete the whole defined connection topology:
-     * return promise that fulfills after all defined exchanges, queues and bindings have been removed
+     * Deletes the whole defined topology in phases: first the bindings, then the queues together with their consumers,
+     * then the exchanges. Deleting a queue or an exchange deletes its bindings as well, so running the phases one after
+     * the other unbinds every binding only once. A phase that fails does not stop the next one.
+     *
+     * @return A promise that fulfills after all defined exchanges, queues and bindings have been removed, and rejects
+     * with the first failure otherwise.
      */
-    deleteConfiguration() {
-        const promises = [];
-        for (const bindingId in this._bindings) {
-            const binding = this._bindings[bindingId];
-            promises.push(binding.delete());
-        }
-        for (const queueId in this._queues) {
-            const queue = this._queues[queueId];
-            if (queue._consumerInitialized !== undefined) {
-                promises.push(queue.stopConsumer());
+    async deleteConfiguration() {
+        // what failed is not declared any more, so there is nothing to delete
+        this._failures.clear();
+        const failures = [];
+        const phase = async (deletions) => {
+            for (const result of await Promise.allSettled(deletions)) {
+                if (result.status === "rejected") {
+                    failures.push(result.reason);
+                }
             }
-            promises.push(queue.delete());
-        }
-        for (const exchangeId in this._exchanges) {
-            const exchange = this._exchanges[exchangeId];
-            promises.push(exchange.delete());
+        };
+        await phase(Object.values(this._bindings).map((binding) => binding.delete()));
+        // deleting a queue stops its consumer first
+        await phase(Object.values(this._queues).map((queue) => queue.delete()));
+        await phase(Object.values(this._exchanges).map((exchange) => exchange.delete()));
+        if (failures.length > 0) {
+            throw failures[0];
         }
-        return Promise.all(promises);
     }
     /**
      * Declares a new exchange. Dependent on the options it auto creates the exchange if it does not already exists.
@@ -197,7 +415,7 @@ class Connection extends events_1.EventEmitter {
     declareExchange(name, type, options) {
         let exchange = this._exchanges[name];
         if (exchange === undefined) {
-            exchange = new Exchange_1.Exchange(this, name, type, options);
+            exchange = new Exchange(this, name, type, options);
         }
         return exchange;
     }
@@ -224,7 +442,7 @@ class Connection extends events_1.EventEmitter {
     declareQueue(name, options) {
         let queue = this._queues[name];
         if (queue === undefined) {
-            queue = new Queue_1.Queue(this, name, options);
+            queue = new Queue(this, name, options);
         }
         return queue;
     }
@@ -273,8 +491,9 @@ class Connection extends events_1.EventEmitter {
         }
         return Promise.all(promises);
     }
+    /** The current underlying amqplib model, `undefined` while disconnected. */
     get getConnection() {
-        return this.connection;
+        return this._model;
     }
     /**
      * Returns an object with metrics about the connection.
@@ -286,50 +505,11 @@ class Connection extends events_1.EventEmitter {
             sentMessagesCounter: this._sentMessagesCounter,
         };
     }
-    rebuildConnection() {
-        if (this._rebuilding) {
-            // only one rebuild process can be active at any time
-            this.log.debug("AMQP Connection rebuild already in progress, joining active rebuild attempt.");
-            return this.initialized;
-        }
-        this._retry = -1;
-        this._rebuilding = true;
-        this._isClosing = false;
-        // rebuild the connection
-        this.initialized = new Promise((resolve, reject) => {
-            this.tryToConnect(this, 0, (err) => {
-                /* istanbul ignore if */
-                if (err) {
-                    this._rebuilding = false;
-                    reject(err);
-                }
-                else {
-                    this._rebuilding = false;
-                    if (this.connectedBefore) {
-                        this.log.info("AMQP Connection re-established");
-                        this.emit("re_established_connection");
-                    }
-                    else {
-                        this.log.info("AQMP Connection established.");
-                        this.emit("open_connection");
-                        this.connectedBefore = true;
-                    }
-                    resolve(null);
-                }
-            });
-        });
-        /* istanbul ignore next */
-        this.initialized.catch((err) => {
-            this.log.warn({ err }, "Error creating connection!");
-            this.emit("error_connection", err);
-            //throw (err);
-        });
-        return this.initialized;
-    }
     /**
      * Increments an internal counter.
      * @param counter The counter to increase.
      * @param value The increment, default is 1.
+     * @internal
      */
     _increaseCounter(counter, value = 1) {
         switch (counter) {
@@ -342,5 +522,4 @@ class Connection extends events_1.EventEmitter {
         }
     }
 }
-exports.Connection = Connection;
 //# sourceMappingURL=Connection.js.map