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

package/lib/Queue/Queue.js

@@ -1,11 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-const amqp_ts_1 = require("../amqp-ts");
-const Binding_1 = require("../Binding");
-const Message_1 = require("../Message");
+import { Binding } from "../Binding.js";
+import { Deferred } from "../Deferred.js";
+import { Message } from "../Message.js";
 /** Represents an AQMP queue. */
-class Queue {
+export class Queue {
+    connection;
+    options;
+    /** A broker-side consumer cancel this soon after the consumer was registered again does not re-initialize. */
+    static CancelLoopWindowMs = 1000;
+    /**
+     * A promise that resolves once the connection is initialized and the queue is declared on its channel. It is
+     * replaced by a pending promise while the queue is re-initialized after a lost connection or a closed channel. It
+     * rejects when the queue fails on its own, or when the connection is closed or recovery gives up while it is pending.
+     */
+    initialized;
+    /**
+     * The AMQP channel.
+     * @internal
+     */
+    _channel;
+    /**
+     * A promise that resolves when a consumer handler is registered and initialized.
+     * @internal
+     */
+    _consumerInitialized;
+    _name;
+    /** @internal */
+    _consumer;
+    _consumerOptions;
+    _consumerTag;
+    _consumerStopping;
+    _deleting;
+    _closing;
+    log;
+    _deferred;
+    _consumerDeferred;
+    /** The generation of the last initialization, and that initialization. */
+    _generation;
+    _initializing = Promise.resolve();
+    /** Changes with every initialization, so a superseded one can tell. */
+    _attempt = 0;
+    /** The channel the queue was successfully declared on, and its model. */
+    _readyChannel;
+    _readyModel;
+    /** The channel the consumer is registered on, or being registered on. */
+    _consumerChannel;
+    _consuming = Promise.resolve();
+    /** The generation in which a broker-side consumer cancel made the queue re-initialize, until it re-consumed. */
+    _cancelReinitGeneration;
+    /**
+     * When the current consumer was registered by a re-initialization after a broker-side cancel. Another cancel within
+     * {@link Queue.CancelLoopWindowMs} of that does not re-initialize again, which stops a cancel loop.
+     */
+    _cancelRecoveredAt;
+    /**
+     * The generation in which the broker refused the consumer. Registering it again on the same connection would be
+     * refused again, so it is only registered again after the next reconnect.
+     */
+    _consumerRefusedIn;
+    /** Why the queue failed on its own, after which it is no longer declared. */
+    _failure;
+    /** Settles {@link _initializedChanged} for those waiting on it. */
+    _changed;
+    /** Counts deliveries; bound once so it can be removed again. */
+    _onDelivery = () => {
+        this.connection._increaseCounter("receivedMessages");
+    };
     /** Returns the name of the queue. */
     get name() {
         return this._name;
@@ -25,50 +84,249 @@ class Queue {
         this.options = options;
         this.log = this.connection.loggerFactory(this.constructor, { queue: name });
         this._name = name;
+        this._deferred = this.connection._createDeferred();
+        this.initialized = this._deferred.promise;
         this.connection._queues[this._name] = this;
-        this._initialize();
+        this.connection._forgetFailure(this);
+        // while disconnected the next connect initializes it
+        if (this.connection._model) {
+            this._initialize(this.connection._model, this.connection._generation).catch(() => { });
+        }
     }
-    /** Waits until the connection is initialized then creates a channel and declares the queue on it. */
-    _initialize() {
-        this.initialized = new Promise((resolve, reject) => {
-            this.connection.initialized
-                .then(() => {
-                this.connection.connection.createChannel((createChannelError, channel) => {
-                    /* istanbul ignore if */
-                    if (createChannelError) {
-                        reject(createChannelError);
-                    }
-                    else {
-                        this._channel = channel;
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        this._channel.on("delivery", this.handleReceivedMessageEvent.bind(this));
-                        const callback = (err, ok) => {
-                            /* istanbul ignore if */
-                            if (err) {
-                                this.log.error({ error: err }, "Failed to create queue '%s'.", this._name);
-                                delete this.connection._queues[this._name];
-                                reject(err);
-                            }
-                            else {
-                                if (this.options.prefetch) {
-                                    this._channel.prefetch(this.options.prefetch);
-                                }
-                                resolve(ok);
-                            }
-                        };
-                        if (this.options.noCreate) {
-                            this._channel.checkQueue(this._name, callback);
-                        }
-                        else {
-                            this._channel.assertQueue(this._name, this.options, callback);
-                        }
-                    }
-                });
-            })
-                .catch((err) => {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                this.log.warn(err, "Channel failure, error caused during connection!");
+    /**
+     * Creates a channel on the given model and declares the queue on it, then settles {@link initialized}. Does nothing
+     * if the queue was already initialized for the given generation. The consumer is started by
+     * {@link _initializeConsumer}.
+     * @internal
+     */
+    _initialize(model, generation) {
+        if (this.connection._queues[this._name] !== this) {
+            // failed, closed or deleted: only a new declaration brings it back
+            return Promise.reject(this._failure ?? new Error(`Queue '${this._name}' is no longer declared`));
+        }
+        if (this._generation !== generation) {
+            this._generation = generation;
+            this._initializing = this._declare(model, ++this._attempt);
+        }
+        return this._initializing;
+    }
+    /**
+     * Replaces a settled {@link initialized} (and consumer promise) with a pending one, until the queue is initialized
+     * again. When only the channel closed (`connectionLost` false), a consumer the broker refused on this connection
+     * keeps its rejected promise: it is not registered again before the next reconnect, so a pending one would never
+     * settle until then.
+     * @internal
+     */
+    _invalidate(connectionLost = true) {
+        this._readyChannel = undefined;
+        this._pendInitialized();
+        const refused = this._consumerRefusedIn !== undefined && this._consumerRefusedIn === this._generation;
+        if (this._consumerDeferred?.settled && (connectionLost || !refused)) {
+            this._consumerDeferred = this.connection._createDeferred();
+            this._consumerInitialized = this._consumerDeferred.promise;
+        }
+    }
+    /** Replaces a settled {@link initialized} with a pending one. */
+    _pendInitialized() {
+        if (this._deferred.settled) {
+            this._deferred = this.connection._createDeferred();
+            this.initialized = this._deferred.promise;
+            this._notifyChanged();
+        }
+    }
+    /**
+     * Whether the queue or its connection is closed or deleted on purpose, so nothing initializes it again.
+     * @internal
+     */
+    get _isClosedOnPurpose() {
+        return this._closing !== undefined || this._deleting !== undefined || this.connection._isStopped;
+    }
+    /**
+     * Resolves once {@link initialized} is no longer the given promise, or once nothing will replace it any more
+     * because the queue or its connection is closed or deleted. Used by a send whose channel turned out to be closing.
+     * @internal
+     */
+    _initializedChanged(ready) {
+        if (this.initialized !== ready || this._isClosedOnPurpose) {
+            return Promise.resolve();
+        }
+        this._changed ??= new Deferred();
+        return this._changed.promise;
+    }
+    /**
+     * Wakes up whoever waits in {@link _initializedChanged}.
+     * @internal
+     */
+    _notifyChanged() {
+        const changed = this._changed;
+        this._changed = undefined;
+        changed?.resolve();
+    }
+    /**
+     * Rejects {@link initialized} and the consumer promise if they are still pending. Used when the connection is closed
+     * or recovery gave up.
+     * @internal
+     */
+    _rejectPending(err) {
+        if (!this._deferred.settled) {
+            this._deferred.reject(err);
+        }
+        if (this._consumerDeferred?.settled === false) {
+            this._consumerDeferred.reject(err);
+        }
+    }
+    /**
+     * Registers the consumer, if there is one, on the channel the queue is declared on, unless it already is
+     * registered there or the broker refused it on this connection. The consumer promise is pending until the
+     * registration is done.
+     * @internal
+     */
+    _initializeConsumer() {
+        const channel = this._readyChannel;
+        if (this._consumer === undefined ||
+            channel === undefined ||
+            channel === this._consumerChannel ||
+            this._consumerRefusedIn === this._generation) {
+            return this._consuming;
+        }
+        if (this._consumerDeferred.settled) {
+            this._consumerDeferred = this.connection._createDeferred();
+            this._consumerInitialized = this._consumerDeferred.promise;
+        }
+        this._consumerChannel = channel;
+        this._consuming = this._consume(channel, this._readyModel);
+        return this._consuming;
+    }
+    /**
+     * Re-creates the channel after it closed while the connection stayed up, declares the queue again and restores its
+     * bindings, which a broker-side delete removes as well. Only then {@link initialized} resolves. The caller registers
+     * the consumer again.
+     */
+    _reinitialize(model, generation) {
+        this._generation = generation;
+        this._initializing = this._declare(model, ++this._attempt, true);
+        return this._initializing;
+    }
+    async _declare(model, attempt, rebind = false) {
+        try {
+            const channel = await model.createChannel();
+            channel.on("error", (err) => {
+                this.log.warn({ err }, "Channel of queue '%s' failed: %s", this._name, err.message);
             });
+            channel.on("close", () => this._onChannelClose(channel, model));
+            if (attempt !== this._attempt) {
+                await channel.close().catch(() => { });
+                return;
+            }
+            this._channel = channel;
+            channel.on("delivery", this._onDelivery);
+            const ok = this.options.noCreate
+                ? await channel.checkQueue(this._name)
+                : await channel.assertQueue(this._name, this.options);
+            if (this.options.prefetch) {
+                await channel.prefetch(this.options.prefetch);
+            }
+            if (attempt !== this._attempt) {
+                await channel.close().catch(() => { });
+                return;
+            }
+            this._readyChannel = channel;
+            this._readyModel = model;
+            if (rebind) {
+                await Binding._rebindContaining(this, model);
+                if (attempt !== this._attempt) {
+                    return;
+                }
+            }
+            // a reply and the connection's close can arrive together: never resolve on a closed connection
+            if (this.connection._isModelClosed(model)) {
+                throw new Error("Connection closed while the queue was initialized");
+            }
+            this._deferred.resolve(ok);
+        }
+        catch (err) {
+            if (attempt !== this._attempt) {
+                return;
+            }
+            if (this.connection._isModelClosed(model)) {
+                // the next connect initializes it again, until then initialized stays pending
+                this.log.debug({ err }, "Connection lost while initializing queue '%s'.", this._name);
+                throw err;
+            }
+            this.log.error({ err }, "Failed to create queue '%s'.", this._name);
+            delete this.connection._queues[this._name];
+            this._failure = err;
+            // the consumer cannot be registered on a queue that failed
+            this._rejectPending(err);
+            this.connection._onEntityFailed(this, err);
+            throw err;
+        }
+    }
+    /**
+     * Registers the consumer on the given channel. A refusal (for example 403 because another connection holds an
+     * exclusive consumer) is also reported through `error_connection`, since during recovery the consumer would
+     * otherwise stop silently.
+     */
+    async _consume(channel, model) {
+        const options = this._consumerOptions;
+        try {
+            const ok = await channel.consume(this._name, this._createConsumerWrapper(channel, options?.noAck === true), options);
+            if (channel !== this._consumerChannel) {
+                // stopped or registered elsewhere meanwhile, but the broker registered it all the same
+                this._cancelSuperseded(channel, ok.consumerTag);
+                return;
+            }
+            if (this.connection._isModelClosed(model)) {
+                throw new Error("Connection closed while the consumer was registered");
+            }
+            this._consumerTag = ok.consumerTag;
+            const recovered = this._cancelReinitGeneration !== undefined && this._cancelReinitGeneration === this._generation;
+            this._cancelRecoveredAt = recovered ? Date.now() : undefined;
+            this._cancelReinitGeneration = undefined;
+            this._consumerDeferred.resolve(ok);
+        }
+        catch (err) {
+            if (channel !== this._consumerChannel || this.connection._isModelClosed(model)) {
+                // superseded, or the next connect registers it again
+                throw err;
+            }
+            this.log.error({ err }, "Failed to start the consumer of queue '%s'.", this._name);
+            this._consumerRefusedIn = this._generation;
+            this._consumerDeferred.reject(err);
+            this.connection._reportFailure(err);
+            throw err;
+        }
+    }
+    /** Cancels a consumer registration that completed after it was superseded, so it does not keep receiving messages. */
+    _cancelSuperseded(channel, consumerTag) {
+        Promise.resolve()
+            .then(() => channel.cancel(consumerTag))
+            .catch((err) => {
+            this.log.debug({ err }, "Cancelling a superseded consumer of queue '%s' failed: %s", this._name, err.message);
+        });
+    }
+    /**
+     * A channel that closes while the connection stays up (for example after a double ack) is re-created, the queue
+     * declared again and its consumer registered again. Closes during a failed declaration or consumer registration, on
+     * a lost connection or caused by {@link close} or {@link delete} are left alone.
+     */
+    _onChannelClose(channel, model) {
+        if (channel !== this._readyChannel || this._closing !== undefined || this._deleting !== undefined) {
+            return;
+        }
+        // a consumer registration that the broker refused closes the channel as well; retrying it would loop
+        const consumeFailed = channel === this._consumerChannel && this._consumerDeferred?.settled === false;
+        const generation = this._generation;
+        this._invalidate(false);
+        // the connection emits its own close right after closing its channels, so look at it once that happened
+        queueMicrotask(() => {
+            if (!this.connection._isModelUsable(model) || this._generation !== generation) {
+                return;
+            }
+            this.log.warn("Channel of queue '%s' closed, re-initializing it.", this._name);
+            this._reinitialize(model, generation)
+                .then(() => (consumeFailed ? undefined : this._initializeConsumer()))
+                .catch(() => { });
         });
     }
     /**
@@ -79,33 +337,6 @@ class Queue {
     send(message) {
         message.sendTo(this);
     }
-    rpc(requestParameters) {
-        return new Promise((resolve, reject) => {
-            const processRpc = () => {
-                let consumerTag;
-                this._channel.consume(amqp_ts_1.DIRECT_REPLY_TO_QUEUE, (resultMsg) => {
-                    this._channel.cancel(consumerTag);
-                    const result = new Message_1.Message(resultMsg.content, resultMsg.properties);
-                    result.fields = resultMsg.fields;
-                    resolve(result);
-                }, { noAck: true }, (err, ok) => {
-                    /* istanbul ignore if */
-                    if (err) {
-                        reject(new Error("amqp-ts: Queue.rpc error: " + err.message));
-                    }
-                    else {
-                        // send the rpc request
-                        consumerTag = ok.consumerTag;
-                        const message = new Message_1.Message(requestParameters, {
-                            replyTo: amqp_ts_1.DIRECT_REPLY_TO_QUEUE,
-                        });
-                        message.sendTo(this);
-                    }
-                });
-            };
-            this.initialized.then(processRpc);
-        });
-    }
     /**
      * Sets the prefetch of the current quere. This limits the amount of unacknowledged messages on a channel. If you
      * already specified this in the options in the constructor you don't need to set it here again.
@@ -115,23 +346,17 @@ class Queue {
      */
     prefetch(count) {
         this.initialized.then(() => {
-            this._channel.prefetch(count);
+            this._channel.prefetch(count).catch((err) => {
+                this.log.warn({ err }, "Setting the prefetch of queue '%s' failed.", this._name);
+            });
             this.options.prefetch = count;
+        }, (err) => {
+            this.log.warn({ err }, "Cannot set the prefetch of queue '%s', it failed to initialize.", this._name);
         });
     }
-    recover() {
-        return new Promise((resolve, reject) => {
-            this.initialized.then(() => {
-                this._channel.recover((err, _ok) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(null);
-                    }
-                });
-            });
-        });
+    async recover() {
+        await this.initialized;
+        await this._channel.recover();
     }
     /**
      * Actives a consumer by binding the given handler to this queue.
@@ -149,33 +374,54 @@ class Queue {
         }
         this._consumerOptions = options;
         this._consumer = onMessage;
-        this._initializeConsumer();
+        delete this._consumerRefusedIn;
+        this._consumerDeferred = this.connection._createDeferred();
+        this._consumerInitialized = this._consumerDeferred.promise;
+        // registers right away if the queue is ready, otherwise once it is; a reconnect registers it as well
+        this.initialized.then(() => this._initializeConsumer().catch(() => { }), (err) => this._consumerDeferred?.reject(err));
         return this._consumerInitialized;
     }
     /**
-     * Initializes the consumer with a handler function. Resolves the @see _consumerInitialized promise once the handler
-     * is bound.
+     * Wraps the consumer handler for messages delivered on the given channel. A message that arrives after the consumer
+     * was stopped, before the broker confirmed the cancel, is given back to the queue for another consumer; one that
+     * needs no acknowledgement cannot be given back.
      */
-    _initializeConsumer() {
-        const activateConsumerWrapper = (msg) => {
+    _createConsumerWrapper(channel, noAck) {
+        return (msg) => {
+            if (msg === null) {
+                this._onConsumerCancelled(channel);
+                return;
+            }
+            if (this._consumer === undefined) {
+                this.log.debug("Message for the stopped consumer of queue '%s', requeuing it.", this._name);
+                if (!noAck) {
+                    try {
+                        channel.nack(msg, false, true);
+                    }
+                    catch (err) {
+                        // the channel closed meanwhile, which requeues it as well
+                        this.log.debug({ err }, "Requeuing a message of queue '%s' failed.", this._name);
+                    }
+                }
+                return;
+            }
             try {
-                const message = new Message_1.Message(msg.content, msg.properties);
+                const message = new Message(msg.content, msg.properties);
                 message.fields = msg.fields;
                 message._message = msg;
-                message._channel = this._channel;
+                message._channel = channel;
                 const result = this._consumer(message);
                 // convert the result to a promise if it isn't one already
                 Promise.resolve(result)
                     .then((resultValue) => {
-                    var _a;
                     // check if there is a reply-to
                     if (msg.properties.replyTo && resultValue) {
-                        if (!(resultValue instanceof Message_1.Message)) {
-                            resultValue = new Message_1.Message(resultValue, (_a = this._consumerOptions.properties) !== null && _a !== void 0 ? _a : {});
+                        if (!(resultValue instanceof Message)) {
+                            resultValue = new Message(resultValue, this._consumerOptions.properties ?? {});
                         }
                         resultValue.properties.correlationId = msg.properties.correlationId;
                         this.log.debug("Replying directly to queue %s", msg.properties.replyTo);
-                        this._channel.sendToQueue(msg.properties.replyTo, resultValue.content, resultValue.properties);
+                        channel.sendToQueue(msg.properties.replyTo, resultValue.content, resultValue.properties);
                     }
                 })
                     .catch((err) => {
@@ -187,89 +433,98 @@ class Queue {
                 this.log.error({ err, correlationId: msg.properties.correlationId, consumerTag: msg.fields.consumerTag }, "Consuming the message %s returned error: %s", msg.properties.correlationId, err.message);
             }
         };
-        this._consumerInitialized = new Promise((resolve, reject) => {
-            this.initialized.then(() => {
-                this._channel.consume(this._name, activateConsumerWrapper, this._consumerOptions, (err, ok) => {
-                    /* istanbul ignore if */
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        this._consumerTag = ok.consumerTag;
-                        resolve(ok);
-                    }
-                });
-            });
-        });
     }
     /**
-     * Completely removes the consumer handler and cancels the channel.
+     * The broker cancelled the consumer, for example because the queue was deleted. The channel stays open, so nothing
+     * else would notice: close it, which re-declares the queue, restores its bindings and registers the consumer again
+     * through the channel close handling. A `noCreate` queue that is gone then fails like any failed declaration.
+     */
+    _onConsumerCancelled(channel) {
+        if (channel !== this._consumerChannel ||
+            channel !== this._readyChannel ||
+            this._closing !== undefined ||
+            this._deleting !== undefined) {
+            return;
+        }
+        if (this._cancelRecoveredAt !== undefined && Date.now() - this._cancelRecoveredAt < Queue.CancelLoopWindowMs) {
+            const err = new Error(`The consumer of queue '${this._name}' was cancelled by the broker again right after it was registered ` +
+                "again; it is registered again on the next reconnect.");
+            this.log.error({ err }, "%s", err.message);
+            // the consumer is gone until then, like a refused one, and nobody would notice otherwise
+            this._consumerRefusedIn = this._generation;
+            this._consumerDeferred = this.connection._createDeferred();
+            this._consumerDeferred.reject(err);
+            this._consumerInitialized = this._consumerDeferred.promise;
+            this.connection._reportFailure(err);
+            return;
+        }
+        this.log.warn("The consumer of queue '%s' was cancelled by the broker, re-initializing the queue.", this._name);
+        this._cancelReinitGeneration = this._generation;
+        // a publish fails until the broker confirmed the close, so sends must wait for the re-initialization instead of
+        // taking the channel for closed on purpose; the close handling still needs the ready channel
+        this._pendInitialized();
+        channel.close().catch(() => { });
+    }
+    /**
+     * Completely removes the consumer handler and cancels the consumer on the broker. A consumer the broker refused has
+     * nothing to cancel, it is only removed. A consumer whose channel closes meanwhile is registered again on a new one,
+     * so that registration is waited for and cancelled instead.
      */
-    stopConsumer() {
+    async stopConsumer() {
         if (this._consumerStopping || this._consumerInitialized == undefined) {
-            return Promise.resolve();
+            return;
         }
         this._consumerStopping = true;
-        return new Promise((resolve, reject) => {
-            this._consumerInitialized.then(() => {
-                this._channel.cancel(this._consumerTag, (err, _ok) => {
-                    /* istanbul ignore if */
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        delete this._consumerInitialized;
-                        delete this._consumer;
-                        delete this._consumerOptions;
-                        delete this._consumerStopping;
-                        resolve();
+        try {
+            for (;;) {
+                const consumer = this._consumerInitialized;
+                const registered = await consumer.then(() => true, () => false);
+                if (this._consumerInitialized !== consumer) {
+                    // invalidated meanwhile, a registration is under way again
+                    continue;
+                }
+                if (!registered) {
+                    break;
+                }
+                try {
+                    await this._consumerChannel.cancel(this._consumerTag);
+                    break;
+                }
+                catch (err) {
+                    if (this._consumerInitialized === consumer) {
+                        throw err;
                     }
-                });
-            });
-        });
+                    // the channel closed while cancelling and the consumer is being registered again
+                }
+            }
+        }
+        finally {
+            // a failed cancel can be retried
+            delete this._consumerStopping;
+        }
+        delete this._consumerInitialized;
+        delete this._consumerDeferred;
+        delete this._consumer;
+        delete this._consumerOptions;
+        delete this._consumerChannel;
+        delete this._consumerRefusedIn;
     }
     /**
      * Removes any bindings of this queue, the consumer handler and then deletes the queue.
      */
     delete() {
         if (this._deleting === undefined) {
-            this._deleting = new Promise((resolve, reject) => {
-                this.initialized
-                    .then(() => {
-                    return Binding_1.Binding.removeBindingsContaining(this);
-                })
-                    .then(() => {
-                    return this.stopConsumer();
-                })
-                    .then(() => {
-                    return this._channel.deleteQueue(this._name, {}, (deleteQueueError, ok) => {
-                        /* istanbul ignore if */
-                        if (deleteQueueError) {
-                            reject(deleteQueueError);
-                        }
-                        else {
-                            delete this.initialized; // invalidate queue
-                            delete this.connection._queues[this._name]; // remove the queue from our administration
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                            this._channel.removeListener("delivery", this.handleReceivedMessageEvent.bind(this));
-                            this._channel.close((channelCloseError) => {
-                                /* istanbul ignore if */
-                                if (channelCloseError) {
-                                    reject(channelCloseError);
-                                }
-                                else {
-                                    delete this._channel;
-                                    delete this.connection;
-                                    resolve(ok);
-                                }
-                            });
-                        }
-                    });
-                })
-                    .catch((err) => {
-                    reject(err);
-                });
-            });
+            this._deleting = (async () => {
+                this._notifyChanged();
+                await this.initialized;
+                await Binding.removeBindingsContaining(this);
+                await this.stopConsumer();
+                const ok = await this._channel.deleteQueue(this._name, {});
+                delete this.connection._queues[this._name]; // remove the queue from our administration
+                this._channel.removeListener("delivery", this._onDelivery);
+                await this._channel.close();
+                return ok;
+            })();
         }
         return this._deleting;
     }
@@ -278,35 +533,15 @@ class Queue {
      */
     close() {
         if (this._closing === undefined) {
-            this._closing = new Promise((resolve, reject) => {
-                this.initialized
-                    .then(() => {
-                    return Binding_1.Binding.removeBindingsContaining(this);
-                })
-                    .then(() => {
-                    return this.stopConsumer();
-                })
-                    .then(() => {
-                    delete this.initialized; // invalidate queue
-                    delete this.connection._queues[this._name]; // remove the queue from our administration
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    this._channel.removeListener("delivery", this.handleReceivedMessageEvent.bind(this));
-                    this._channel.close((err) => {
-                        /* istanbul ignore if */
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            delete this._channel;
-                            delete this.connection;
-                            resolve(null);
-                        }
-                    });
-                })
-                    .catch((err) => {
-                    reject(err);
-                });
-            });
+            this._closing = (async () => {
+                this._notifyChanged();
+                await this.initialized;
+                await Binding.removeBindingsContaining(this);
+                await this.stopConsumer();
+                delete this.connection._queues[this._name]; // remove the queue from our administration
+                this._channel.removeListener("delivery", this._onDelivery);
+                await this._channel.close();
+            })();
         }
         return this._closing;
     }
@@ -318,22 +553,20 @@ class Queue {
      * @param args Any arguments.
      */
     bind(source, pattern = "", args = {}) {
-        const binding = new Binding_1.Binding(this, source, pattern, args);
+        const binding = new Binding(this, source, pattern, args);
         return binding.initialized;
     }
     /**
-     * Unbinds the queue from the given exchange by deleting the binding.
+     * Unbinds the queue from the given exchange by deleting the binding. Resolves right away if there is no such
+     * binding, for example because it was unbound before.
      *
      * @param source The exchange to unbind from.
      * @param pattern The pattern the queue was bind with.
      * @param _args Any additional arguments.
      */
-    unbind(source, pattern = "", _args = {}) {
-        return this.connection._bindings[Binding_1.Binding.id(this, source, pattern)].delete();
-    }
-    handleReceivedMessageEvent(_args) {
-        this.connection._increaseCounter("receivedMessages");
+    async unbind(source, pattern = "", _args = {}) {
+        // a binding that does not exist (any more) has nothing to delete
+        await this.connection._bindings[Binding.id(this, source, pattern)]?.delete();
     }
 }
-exports.Queue = Queue;
 //# sourceMappingURL=Queue.js.map