comq 0.22.0 → 0.23.0

package/source/channel.js

@@ -27,14 +27,6 @@ class Channel {
   /** @type {string[]} */
   #tags = []
 
-  /**
-   * How each queue was declared, so that the queue holding what it could not
-   * process is declared to live exactly as long as it does.
-   *
-   * @type {Map<string, comq.amqp.options.Queue>}
-   */
-  #queues = new Map()
-
   /**
    * The exchange and key each held queue is bound under, so that sealing withdraws them.
    *
@@ -88,8 +80,7 @@ class Channel {
     // the consumers of the previous channel went down with it, their tags mean nothing here
     this.#tags = []
 
-    // a fresh channel has declared nothing, and bound nothing
-    this.#queues.clear()
+    // a fresh channel has bound nothing
     this.#held.clear()
 
     await this.#channel.prefetch(this.#topology.prefetch)
@@ -384,8 +375,6 @@ class Channel {
 
     const { queue } = await this.#channel.assertQueue(name, options)
 
-    this.#queues.set(queue, options)
-
     return [queue]
   }
 
@@ -485,21 +474,23 @@ class Channel {
    * The queue a message is kept in once it has run out of attempts. It has no consumer
    * either: what is in it is waiting for a person.
    *
-   * It is declared to live exactly as long as the queue it serves, which for a groupless
-   * subscriber means an exclusive queue whose contents go when the connection does. That
-   * is deliberate: such a subscriber is ephemeral by construction, and a durable queue per
-   * generated name would leak one per restart, forever. An ephemeral subscriber's failures
-   * are ephemeral too.
+   * One queue serves every queue this channel consumes, as one retry queue serves every
+   * source that shares its delay. A parked message carries the queue it came from, so a
+   * queue per source would name what the message already says, and stay on the broker
+   * long after the queue it was named for has gone.
+   *
+   * It is durable whatever the channel is. A groupless subscriber's own queue goes with
+   * its connection, but what it could not process is waiting for a person, and there is
+   * nobody left to tell.
    *
-   * @param {string} queue the queue the message was consumed from
    * @returns {Promise<void>}
    */
-  async #assertParkedQueue (queue) {
+  async #assertParkedQueue () {
     if (!this.#topology.acknowledgments) return
 
-    const options = this.#queues.get(queue) ?? (this.#topology.durable ? DURABLE : EXCLUSIVE)
-
-    await this.#assertQueue(parkedQueueOf(queue), options)
+    // declared here rather than when a message is first parked, for the reason the retry
+    // queues are: the failure handler is the least likely moment for a declare to succeed
+    await this.#assertQueue(PARKED, DURABLE)
   }
 
   /** The waits between attempts, as a ladder even when it is one rung. */
@@ -556,8 +547,9 @@ class Channel {
   }
 
   /**
-   * The retry topology is asserted once per channel and a parked queue once per queue:
-   * `lazy` keys an initializer by the arguments it takes, and both again after a recovery.
+   * The retry and parking topology is asserted once per channel: `lazy` keys an
+   * initializer by the arguments it takes, and neither takes any. Both again after
+   * a recovery.
    */
   #consume = lazy(this, [this.#assertRetryQueue, this.#assertParkedQueue],
     /**
@@ -660,7 +652,7 @@ class Channel {
       [PARKED_AT_HEADER]: Date.now()
     })
 
-    await this.#publish(DEFAULT, parkedQueueOf(queue), message.content, properties)
+    await this.#publish(DEFAULT, PARKED, message.content, properties)
 
     this.#channel.ack(message)
 
@@ -775,9 +767,9 @@ const INTERRUPTION = /** @type {Error} */ Symbol('internal interruption')
 const RESOURCE_LOCKED = 405
 
 const RETRY_PREFIX = 'comq.retry.'
-const PARKED_PREFIX = 'comq.parked.'
 
-const parkedQueueOf = (queue) => PARKED_PREFIX + queue
+/** Where every message that has run out of attempts is kept, whatever it was consumed from. */
+const PARKED = 'comq.parked'
 
 // Everything comq writes onto a message, under its own prefix: AMQP defines no retry
 // counter, so this one is comq's invention rather than a convention, and an unprefixed

package/source/index.js

@@ -4,7 +4,6 @@ const { connect, assert } = require('./connect')
 const { Retry, Park } = require('./verdicts')
 const { Unroutable } = require('./unroutable')
 const { Interrupted } = require('./interrupted')
-const { Abandoned } = require('./abandoned')
 
 exports.connect = connect
 exports.assert = assert
@@ -13,4 +12,3 @@ exports.Retry = Retry
 exports.Park = Park
 exports.Unroutable = Unroutable
 exports.Interrupted = Interrupted
-exports.Abandoned = Abandoned

package/source/io.js

@@ -6,7 +6,6 @@ const { Promex } = require('promex')
 const { memo, failsafe, lazy, track } = require('./attributes')
 const { verdictOf, PARK } = require('./verdicts')
 const { Unroutable } = require('./unroutable')
-const { Abandoned } = require('./abandoned')
 
 const { decode } = require('./decode')
 const { encode } = require('./encode')
@@ -31,8 +30,15 @@ class IO {
   /** @type {comq.Channel} */
   #events
 
-  /** @type {Map<string, comq.ReplyEmitter>} */
-  #emitters = new Map()
+  /**
+   * Where this IO's replies arrive. One queue answers every request it makes: a reply is
+   * found by its correlation identifier, which is unique across processes, so a queue per
+   * target would name what the identifier already tells apart — and the broker would hold
+   * one for every distinct queue the caller has ever requested.
+   *
+   * @type {comq.ReplyEmitter}
+   */
+  #emitter
 
   /** @type {comq.ReplyEmitter | null} */
   #control = null
@@ -40,9 +46,6 @@ class IO {
   /** @type {Map<Promex, comq.Request>} */
   #pendingReplies = new Map()
 
-  /** Whether this has stopped waiting for Replies, see `abandon`. */
-  #abandoning = false
-
   /** @type {[comq.diagnostics.Event, Function][]} */
   #forwarders = []
 
@@ -254,30 +257,6 @@ class IO {
     await this.#destroyStreams(this.#replyStreams)
   })
 
-  /**
-   * Stops waiting for Replies: every one still outstanding is rejected with `Abandoned`, and a
-   * Request made from now on is refused with it.
-   *
-   * A close waits for every consumer callback to return, and such a callback may be waiting on
-   * a Request of its own. Where the answer to that Request is the very thing going away — the
-   * process it would come from is shutting down alongside this one — the close waits for as
-   * long as the answer takes. This is how that wait is ended. What the Requests themselves do
-   * is not affected: they were sent and may well be processed; what is given up is this side's
-   * interest in the answers.
-   *
-   * Callable at any time, including while a close is already under way.
-   */
-  abandon = memo(async () => {
-    this.#abandoning = true
-
-    // the same three steps `#abandon` takes for one Reply whose caller stopped waiting
-    for (const [reply, request] of this.#pendingReplies) {
-      request.emitter.off(request.properties.correlationId)
-      this.#pendingReplies.delete(reply)
-      reply.reject(new Abandoned())
-    }
-  })
-
   close = memo(async () => {
     await this.seal()
     await this.#destroyStreams(this.#replyPipes)
@@ -340,13 +319,20 @@ class IO {
     return [buffer, properties]
   }
 
-  async #consumeReplies (queue) {
-    const emitter = io.createReplyEmitter(queue)
-    const consumer = this.#getReplyConsumer(queue, emitter)
+  async #consumeReplies () {
+    this.#emitter = await this.#consumeRepliesOf(REPLY)
+  }
 
-    this.#emitters.set(queue, emitter)
+  /**
+   * @param {string} label
+   * @returns {Promise<comq.ReplyEmitter>}
+   */
+  async #consumeRepliesOf (label) {
+    const emitter = io.createReplyEmitter(label)
+
+    await this.#replies.consume(emitter.queue, this.#getReplyConsumer(emitter))
 
-    await this.#replies.consume(emitter.queue, consumer)
+    return emitter
   }
 
   // endregion
@@ -417,11 +403,10 @@ class IO {
       })
 
   /**
-   * @param {string} queue
    * @param {comq.ReplyEmitter} emitter
    * @returns {comq.channels.Consumer}
    */
-  #getReplyConsumer = (queue, emitter) =>
+  #getReplyConsumer = (emitter) =>
     (message) => {
       const payload = decode(message)
 
@@ -453,11 +438,8 @@ class IO {
 
     signal?.throwIfAborted()
 
-    // one made now would be waited for by nobody: the Replies are abandoned already
-    if (this.#abandoning) throw new Abandoned()
-
     const [buffer, contentType] = this.#encode(payload, terms.encoding)
-    const request = this.#createRequest(target, contentType, signal)
+    const request = this.#createRequest(contentType, signal)
     const properties = { ...request.properties }
 
     if (expires !== undefined) {
@@ -524,13 +506,12 @@ class IO {
    * The request holds no copy of what was sent: a retransmission encodes the
    * payload anew, and an unanswered request would otherwise keep two of it.
    *
-   * @param {string} queue
    * @param {comq.Encoding} contentType
    * @param {AbortSignal} [signal]
    * @return {comq.Request}
    */
-  #createRequest (queue, contentType, signal) {
-    const emitter = this.#emitters.get(queue)
+  #createRequest (contentType, signal) {
+    const emitter = this.#emitter
     const correlationId = emitter.next()
 
     /** @type {comq.amqp.Properties} */
@@ -611,11 +592,7 @@ class IO {
    * @return {Promise<comq.ReplyEmitter>}
    */
   async #createControl () {
-    const queue = 'control'
-
-    await this.#consumeReplies(queue)
-
-    return this.#emitters.get(queue)
+    return await this.#consumeRepliesOf(CONTROL)
   }
 
   /**
@@ -724,6 +701,12 @@ const DEFAULT = 'application/json'
 
 const RETRANSMISSION = /** @type {Error} */ Symbol('retransmission')
 
+/** What this IO's replies arrive on, before the random suffix that makes the queue its own. */
+const REPLY = 'comq.reply'
+
+/** What a producer steers its reply streams from, likewise. */
+const CONTROL = 'control'
+
 /**
  * What a caller passed, settled once: a timeout becomes the moment the Request expires, so that
  * every attempt of it shares one deadline.

package/test/ReplyPipe.test.js

@@ -168,3 +168,43 @@ it('should heartbeat while idle', async () => {
 
   pipe.destroy()
 })
+
+// the confirmation is published before the source is read, and a blocked broker holds the publish
+// for as long as it is blocked: the source may fail in the meantime, and nobody listens to it yet
+it('should survive a source that fails before the confirmation is sent', async () => {
+  const gate = new Promex()
+
+  reply.mockImplementation(async (message, properties) => {
+    sent.push([message, properties])
+    await gate
+
+    return true
+  })
+
+  const source = new Readable({ objectMode: true, read () {} })
+  const creating = ReplyPipe.create(request, source, channel, feedback, reply)
+
+  source.destroy(new Error('nothing arrived'))
+
+  await timeout(10)
+
+  gate.resolve()
+
+  const pipe = await creating
+
+  await closing(pipe)
+
+  expect(source.destroyed).toStrictEqual(true)
+})
+
+it('should destroy the source if the confirmation cannot be sent', async () => {
+  reply.mockImplementation(async () => {
+    throw new Error('channel closed')
+  })
+
+  const source = new Readable({ objectMode: true, read () {} })
+
+  await expect(ReplyPipe.create(request, source, channel, feedback, reply)).rejects.toThrow('channel closed')
+
+  expect(source.destroyed).toStrictEqual(true)
+})

package/test/channel.test.js

@@ -1040,6 +1040,7 @@ describe('release', () => {
 describe('failed messages', () => {
   const DELAY = 1000
   const RETRY = 'comq.retry.' + DELAY
+  const PARKED = 'comq.parked'
 
   let queue
   let exception
@@ -1108,10 +1109,18 @@ describe('failed messages', () => {
     it('should assert the parked queue', async () => {
       await channel.consume(queue, consumer)
 
-      expect(chan.assertQueue).toHaveBeenCalledWith('comq.parked.' + queue,
+      expect(chan.assertQueue).toHaveBeenCalledWith(PARKED,
         expect.objectContaining({ durable: true }))
     })
 
+    it('should not name the parked queue after the queue it serves', async () => {
+      await channel.consume(queue, consumer)
+
+      const named = chan.assertQueue.mock.calls.filter(([name]) => name.includes(queue))
+
+      expect(named).toHaveLength(1) // the source queue itself
+    })
+
     it('should assert the source queue first', async () => {
       await channel.consume(queue, consumer)
 
@@ -1130,15 +1139,14 @@ describe('failed messages', () => {
       expect(queues).toHaveLength(1)
     })
 
-    it('should assert a parked queue per consumed queue', async () => {
-      const one = generate()
-      const another = generate()
+    it('should assert one parked queue however many queues are consumed', async () => {
+      await channel.consume(generate(), consumer)
+      await channel.consume(generate(), consumer)
+      await channel.consume(generate(), consumer)
 
-      await channel.consume(one, consumer)
-      await channel.consume(another, consumer)
+      const parked = chan.assertQueue.mock.calls.filter(([name]) => name === PARKED)
 
-      expect(chan.assertQueue).toHaveBeenCalledWith('comq.parked.' + one, expect.anything())
-      expect(chan.assertQueue).toHaveBeenCalledWith('comq.parked.' + another, expect.anything())
+      expect(parked).toHaveLength(1)
     })
 
     it('should not assert either without acknowledgments', async () => {
@@ -1156,7 +1164,9 @@ describe('failed messages', () => {
       expect(chan.assertExchange).not.toHaveBeenCalled()
     })
 
-    it('should declare the parked queue exclusive for an exclusive queue', async () => {
+    it('should declare the parked queue durable whatever the channel is', async () => {
+      // what a groupless subscriber could not process is waiting for a person, and
+      // there is nobody left to tell once its own queue has gone with its connection
       jest.clearAllMocks()
 
       topology.durable = false
@@ -1166,9 +1176,10 @@ describe('failed messages', () => {
       await channel.consume(queue, consumer)
 
       const [, options] = chan.assertQueue.mock.calls
-        .find(([name]) => name === 'comq.parked.' + queue)
+        .find(([name]) => name === PARKED)
 
-      expect(options).toMatchObject({ exclusive: true })
+      expect(options).toMatchObject({ durable: true })
+      expect(options.exclusive).toBeUndefined()
     })
 
     it('should re-assert after recovery', async () => {
@@ -1181,7 +1192,7 @@ describe('failed messages', () => {
       const repl = await getCreatedChannel(replacement)
 
       expect(repl.assertExchange).toHaveBeenCalledWith(RETRY, 'fanout', expect.anything())
-      expect(repl.assertQueue).toHaveBeenCalledWith('comq.parked.' + queue, expect.anything())
+      expect(repl.assertQueue).toHaveBeenCalledWith(PARKED, expect.anything())
     })
   })
 
@@ -1471,7 +1482,7 @@ describe('failed messages', () => {
 
       expect(asserted()).toStrictEqual(['comq.retry.1000'])
       expect(publications().map(([exchange, key]) => exchange || key))
-        .toStrictEqual(['comq.retry.1000', 'comq.parked.' + queue])
+        .toStrictEqual(['comq.retry.1000', PARKED])
     })
   })
 
@@ -1486,7 +1497,7 @@ describe('failed messages', () => {
       const [exchange, key] = publications()[0]
 
       expect(exchange).toStrictEqual('')
-      expect(key).toStrictEqual('comq.parked.' + queue)
+      expect(key).toStrictEqual(PARKED)
     })
 
     it('should not retry once the attempts are spent', async () => {
@@ -1563,7 +1574,7 @@ describe('failed messages', () => {
 
       const targets = publications().map(([, key]) => key)
 
-      expect(targets).toStrictEqual([queue, 'comq.parked.' + queue])
+      expect(targets).toStrictEqual([queue, PARKED])
     })
 
     it('should give a message one delivery more than the ladder has rungs', async () => {
@@ -1581,7 +1592,7 @@ describe('failed messages', () => {
 
       const targets = publications().map(([, key]) => key)
 
-      expect(targets).toStrictEqual([queue, queue, 'comq.parked.' + queue])
+      expect(targets).toStrictEqual([queue, queue, PARKED])
     })
   })
 
@@ -1596,7 +1607,7 @@ describe('failed messages', () => {
       const [exchange, key] = publications()[0]
 
       expect(exchange).toStrictEqual('')
-      expect(key).toStrictEqual('comq.parked.' + queue)
+      expect(key).toStrictEqual(PARKED)
       expect(publications()).toHaveLength(1)
     })
 
@@ -1684,7 +1695,7 @@ describe('failed messages', () => {
 
       await deliver(delivery({}))
 
-      expect(publications()[0][1]).toStrictEqual('comq.parked.' + queue)
+      expect(publications()[0][1]).toStrictEqual(PARKED)
     })
   })
 

package/test/io.request.test.js

@@ -41,7 +41,7 @@ let replies
 
 let promise
 
-const REPLY = new RegExp(`^${queue}..[0-9a-f]+$`)
+const REPLY = /^comq\.reply\.\.[0-9a-f]+$/
 
 beforeEach(async () => {
   promise = io.request(queue, payload)
@@ -62,6 +62,17 @@ it('should consume replies queue', async () => {
   expect(replies.consume).toHaveBeenCalledWith(expect.stringMatching(REPLY), expect.any(Function))
 })
 
+it('should consume one replies queue however many queues are requested', async () => {
+  // a reply is found by its correlation identifier, so a queue per target would
+  // name what the identifier already tells apart
+  io.request(generate(), payload)
+  io.request(generate(), payload)
+
+  await immediate()
+
+  expect(replies.consume).toHaveBeenCalledTimes(1)
+})
+
 describe('send', () => {
   let call
 
@@ -84,9 +95,8 @@ describe('send', () => {
 
   it('should set replyTo', async () => {
     const properties = call[2]
-    const rx = new RegExp(`^${queue}..[a-z0-9]+`)
 
-    expect(properties.replyTo).toMatch(rx)
+    expect(properties.replyTo).toMatch(REPLY)
   })
 
   it('should consume replyTo', async () => {

package/types/index.d.ts

@@ -38,9 +38,3 @@ export class Unroutable extends Error {
 export class Interrupted extends Error {
   readonly reason: string
 }
-
-/**
- * A Reply nobody is waiting for any more, or a Request made once the waiting has stopped.
- * See `IO.abandon`.
- */
-export class Abandoned extends Error {}

package/types/io.d.ts

@@ -119,12 +119,6 @@ declare namespace comq {
 
     seal(): Promise<void>
 
-    /**
-     * Stops waiting for Replies: every one still outstanding is rejected with `Abandoned`, and a
-     * Request made from now on is refused with it. Callable while a close is already under way.
-     */
-    abandon(): Promise<void>
-
     close(): Promise<void>
 
     diagnose(event: 'open', listener: (index?: number) => void): void

package/features/closing.feature

@@ -1,32 +0,0 @@
-Feature: Abandoning the Replies a close is waiting for
-
-  A consumer callback may call out while it runs, and a close waits for every callback to return.
-  Where the answer that callback waits for is the one thing going away with the close, the two
-  wait for each other. Abandoning ends that wait.
-
-  Background:
-    Given an active connection to the broker
-
-  Scenario: Abandoning lets a close finish
-    Given a producer replying `upstream` queue by requesting the `downstream` queue
-    When the consumer sends a request to the `upstream` queue
-    And the producer is handling the request
-    And the connection abandons its replies
-    Then the connection closes within 1000ms
-    And the producer was told its reply is abandoned
-    And the consumer was told its own reply is abandoned
-
-  Scenario: A close already under way is told to stop waiting
-    Given a producer replying `upstream` queue by requesting the `downstream` queue
-    When the consumer sends a request to the `upstream` queue
-    And the producer is handling the request
-    And the connection has started closing
-    And the connection abandons its replies
-    Then the connection closes within 1000ms
-
-  Scenario: A Request made once the Replies are abandoned is refused
-    Given a producer replying `upstream` queue by requesting the `downstream` queue
-    When the consumer sends a request to the `upstream` queue
-    And the producer is handling the request
-    And the connection abandons its replies
-    Then a request to the `downstream` queue is refused as abandoned

package/features/steps/closing.js

@@ -1,109 +0,0 @@
-'use strict'
-
-const assert = require('node:assert')
-const { Given, When, Then } = require('@cucumber/cucumber')
-const { Abandoned } = require('../../')
-const { timeout } = require('../../test/helpers')
-
-Given('a producer replying {token} queue by requesting the {token} queue',
-  /**
-   * @param {string} queue
-   * @param {string} downstream
-   * @this {comq.features.Context}
-   */
-  async function (queue, downstream) {
-    this.handling = new Promise((resolve) => { this.handled = resolve })
-
-    const producer = async (request) => {
-      const reply = this.io.request(downstream, request)
-
-      this.handled()
-
-      try {
-        return await reply
-      } catch (error) {
-        // recorded rather than rethrown: what this asserts is what the caller was told,
-        // and a rejected producer would have the delivery retried on top of it
-        this.abandoned = error
-
-        return null
-      }
-    }
-
-    await this.io.reply(queue, producer)
-  })
-
-When('the producer is handling the request',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    await this.handling
-
-    // the consumer's own Request is outstanding as well, and abandoning abandons that one too;
-    // its outcome is taken here so that it is asserted rather than left to surface as an
-    // unhandled rejection
-    this.reply.catch((error) => { this.refused = error })
-  })
-
-When('the connection has started closing',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    this.closing = this.io.close()
-  })
-
-When('the connection abandons its replies',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    await this.io.abandon()
-  })
-
-Then('the connection closes within {number}ms',
-  /**
-   * @param {number} ms
-   * @this {comq.features.Context}
-   */
-  async function (ms) {
-    const io = this.io
-
-    // taken off the world so that the hook on the way out does not await a close
-    // this may have just proven does not end
-    this.io = undefined
-    this.connected = false
-
-    const closing = io.close().then(() => true, () => true)
-    const closed = await Promise.race([closing, timeout(ms).then(() => false)])
-
-    assert.ok(closed, `The connection did not close within ${ms}ms`)
-  })
-
-Then('the producer was told its reply is abandoned',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    assert.ok(this.abandoned instanceof Abandoned,
-      `The producer was told ${this.abandoned ?? 'nothing'}`)
-  })
-
-Then('the consumer was told its own reply is abandoned',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    assert.ok(this.refused instanceof Abandoned,
-      `The consumer was told ${this.refused ?? 'nothing'}`)
-  })
-
-Then('a request to the {token} queue is refused as abandoned',
-  /**
-   * @param {string} queue
-   * @this {comq.features.Context}
-   */
-  async function (queue) {
-    await assert.rejects(() => this.io.request(queue, null), Abandoned)
-  })

package/source/abandoned.js

@@ -1,15 +0,0 @@
-'use strict'
-
-/**
- * A Reply nobody is waiting for any more, or a Request made once the waiting has stopped. The
- * Request itself was sent and may well be processed; what was given up is the answer.
- */
-class Abandoned extends Error {
-  constructor () {
-    super('The connection no longer waits for a Reply')
-
-    this.name = 'Abandoned'
-  }
-}
-
-exports.Abandoned = Abandoned