comq 0.5.1-dev.1 → 0.5.2-dev.0

package/.github/workflows/codeql.yml

@@ -14,9 +14,11 @@ name: "CodeQL"
 on:
   push:
     branches: [ "main" ]
+    paths: [ "source/**" ]
   pull_request:
     # The branches below must be a subset of the branches above
     branches: [ "main" ]
+    paths: [ "source/**" ]
   schedule:
     - cron: '15 8 * * 3'
 

package/examples/events/consumer.js

@@ -1,5 +1,3 @@
-'use strict'
-
 import { connect } from 'comq'
 import { url } from '../const.js'
 

package/examples/events/producer.js

@@ -1,5 +1,3 @@
-'use strict'
-
 import { connect } from 'comq'
 import { url } from '../const.js'
 

package/examples/rpc/consumer.js

@@ -1,5 +1,3 @@
-'use strict'
-
 import { connect } from 'comq'
 import { url } from '../const.js'
 

package/examples/rpc/producer.js

@@ -1,5 +1,3 @@
-'use strict'
-
 import { connect } from 'comq'
 import { url } from '../const.js'
 

package/lerna.json

@@ -1,5 +1,5 @@
 {
   "useWorkspaces": true,
-  "version": "0.5.1-dev.1",
+  "version": "0.5.2-dev.0",
   "conventionalCommits": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.5.1-dev.1",
+  "version": "0.5.2-dev.0",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",

package/readme.md

@@ -173,6 +173,13 @@ The following encoding formats are supported:
 - `application/octet-stream`
 - `text/plain`
 
+## Flow Control
+
+When [back pressure](https://www.rabbitmq.com/flow-control.html) is applied to a channel or the
+underlying broker connection is lost, any current and future outgoing messages will be paused.
+Corresponding returned promises will remain in a `pending` state until the pressure is removed or
+the connection is restored.
+
 ## Connection Tolerance
 
 When initially connecting to the broker or if the established connection is lost, connection
@@ -191,10 +198,6 @@ A sharded connection is a mechanism that uses multiple connections simultaneousl
 balancing and mitigate failover scenarios, utilizing a set of broker instances that are **not**
 combined into a cluster.
 
-`async connect(...shards: string[]): IO`
-
-Returns an instance of `IO` once a successful connection to one of the shards is established.
-
 Outgoing messages are sent to a single connection chosen at random from the shard pool. Shards that
 lose their underlying connection or experience channel [back pressure](#flow-control) on
 corresponding channel are removed from the pool until the issue is resolved. Pending messages
@@ -203,6 +206,10 @@ are available, messages will wait until any shard's connection is re-established
 
 Incoming messages are consumed from all shards.
 
+`async connect(...shards: string[]): IO`
+
+Returns an instance of `IO` once a successful connection to one of the shards is established.
+
 ### Example
 
 ```javascript
@@ -218,13 +225,6 @@ await io.close()
 
 ```
 
-## Flow Control
-
-When [back pressure](https://www.rabbitmq.com/flow-control.html) is applied to a channel or the
-underlying broker connection is lost, any current and future outgoing messages will be paused.
-Corresponding returned promises will remain in a `pending` state until the pressure is removed or
-the connection is restored.
-
 ## Topology
 
 Topology is designed to deliver maximum performance while ensuring that the **at least once**
@@ -366,3 +366,8 @@ established, there is no way to capture the initial `open` event.
 ```javascript
 io.diagnose('flow', (type) => console.log(`Back pressure was applied to the ${type} channel`))
 ```
+
+# Gratitude
+
+I want to express my deep appreciation to [@mzabolotko](https://github.com/mzabolotko) for his
+generous contribution of time and expertise.

package/source/channel.js

@@ -198,7 +198,7 @@ class Channel {
    * @param {comq.amqp.options.Publish} options
    */
   async #publish (exchange, queue, buffer, options) {
-    if (this.#paused !== undefined) await this.#paused
+    if (this.#paused !== undefined) await this.#unpaused()
 
     options = Object.assign({ persistent: this.#topology.persistent }, options)
 
@@ -282,8 +282,6 @@ class Channel {
     this.#paused = promex()
     this.#channel.once('drain', this.#unpause)
     this.#diagnostics.emit('flow')
-
-    if (this.#failfast) throw INTERRUPTION
   }
 
   /**
@@ -299,6 +297,11 @@ class Channel {
     this.#diagnostics.emit('drain')
   }
 
+  async #unpaused () {
+    if (this.#failfast) throw INTERRUPTION // tell shards.Channel to remove this one from the pool
+    else await this.#paused
+  }
+
   async #recover (exception) {
     if (permanent(exception)) return false
     else await this.#recovery

package/source/shards/channel.js

@@ -22,8 +22,8 @@ class Channel {
   /** @type {Set<Promise<comq.Channel>>} */
   #pending = new Set()
 
-  /** @type {Record<comq.Channel, toa.generic.Promex>} */
-  #bench = {}
+  /** @type {Map<comq.Channel, toa.generic.Promex>} */
+  #bench = new Map()
 
   /** @type {comq.topology.type} */
   #type
@@ -87,6 +87,8 @@ class Channel {
     this.#add(channel)
     this.#pipe(channel)
 
+    channel.diagnose('flow', () => this.#remove((channel)))
+    channel.diagnose('drain', () => this.#recover(channel))
     channel.diagnose('recover', () => this.#recover(channel))
   }
 
@@ -127,18 +129,17 @@ class Channel {
   #remove (channel) {
     if (!this.#channels.has(channel)) return
 
-    this.#diagnostics.emit('remove', channel.index)
-
-    this.#bench[channel] = promex()
+    this.#bench.set(channel, promex())
     this.#channels.delete(channel)
     this.#pool = Array.from(this.#channels)
+    this.#diagnostics.emit('remove', channel.index)
   }
 
   /**
    * @param {comq.Channel} channel
    */
   #recover (channel) {
-    if (channel in this.#bench) this.#comeback(channel)
+    if (this.#bench.has(channel)) this.#comeback(channel)
 
     this.#add(channel)
 
@@ -147,8 +148,8 @@ class Channel {
   }
 
   #comeback (channel) {
-    this.#bench[channel].resolve(channel)
-    delete this.#bench[channel]
+    this.#bench.get(channel).resolve(channel)
+    this.#bench.delete(channel)
   }
 
   /**
@@ -180,7 +181,7 @@ class Channel {
 
     for (const channel of this.#channels) promises.push(fn(channel))
     for (const pending of this.#pending) promises.push(pending.then(fn))
-    for (const recover of Object.values(this.#bench)) promises.push(recover.then(fn))
+    for (const recover of this.#bench.values()) promises.push(recover.then(fn))
 
     return promises
   }
@@ -196,8 +197,9 @@ class Channel {
 
     try {
       await fn(channel)
-    } catch (e) {
+    } catch {
       this.#remove(channel)
+
       await this.#one(fn)
     }
   }

package/test/channel.test.js

@@ -871,6 +871,7 @@ describe('diagnostics', () => {
 describe('transient', () => {
   const exchange = generate()
   const queue = generate()
+  const label = generate()
   const buffer = randomBytes(8)
   const index = random()
 
@@ -879,25 +880,27 @@ describe('transient', () => {
     chan = await getCreatedChannel()
   })
 
-  it('should throw transient exceptions on publish', async () => {
-    chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
+  it.each(/** @type {string[]} */ ['publish', 'send'])('should throw transient exceptions on %s',
+    async (method) => {
+      chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
 
-    await expect(channel.publish(exchange, buffer)).rejects.toThrow()
-  })
+      await expect(channel[method](label, buffer)).rejects.toThrow()
+    })
 
-  it('should throw transient exceptions on send', async () => {
-    chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
+  it('should not throw when back pressure is applied', async () => {
+    chan.publish.mockImplementationOnce(backpressure.publish)
 
-    await expect(channel.send(queue, buffer)).rejects.toThrow()
+    await expect(channel.publish(exchange, buffer)).resolves.not.toThrow()
   })
 
-  it('should throw on back pressure', async () => {
+  it('should throw if backpressure was applied before', async () => {
     chan.publish.mockImplementationOnce(backpressure.publish)
 
+    await expect(channel.publish(exchange, buffer)).resolves.not.toThrow()
     await expect(channel.publish(exchange, buffer)).rejects.toBeDefined()
   })
 
-  it('should not ignore exceptions on `throw()`', async () => {
+  it('should not ignore exceptions on `fire()`', async () => {
     chan.publish.mockImplementation(() => { throw new Error('Channel closed') })
 
     await expect(channel.fire(queue, buffer)).rejects.toThrow()

package/test/connection.mock.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const channel = /** @type {jest.MockedFunction<(sharded?: boolean, index?: number) => comq.Channel>} */ jest.fn(
+const channel = /** @type {jest.MockedFunction<(sharded?: boolean, index?: number) => jest.MockedObject<comq.Channel>>} */ jest.fn(
   (sharded = false, index = undefined) => ({
     index,
     sharded,

package/test/shards/channel.test.js

@@ -357,6 +357,40 @@ it('should not throw on recovery (if the "bench" is empty)', async () => {
   expect(emit).not.toThrow()
 })
 
+it('should remove channel with back pressure from the pool', async () => {
+  channel = await create(connections, type)
+
+  const queue = generate()
+  const buffer = randomBytes(8)
+  const channels = await getCreatedChannels()
+  const chan = sample(channels)
+  const flowCalls = chan.diagnose.mock.calls.filter((call) => call[0] === 'flow')
+  const drainCalls = chan.diagnose.mock.calls.filter((call) => call[0] === 'drain')
+  const flowListeners = flowCalls.map((call) => call[1])
+  const drainListeners = drainCalls.map((call) => call[1])
+
+  async function send () {
+    for (let i = 0; i < 10; i++) await channel.send(queue, buffer)
+  }
+
+  await send()
+  expect(chan.send).toHaveBeenCalled()
+  chan.send.mockClear()
+
+  // emit 'flow'
+  for (const listener of flowListeners) listener()
+
+  await send()
+  expect(chan.send).not.toHaveBeenCalled()
+  chan.send.mockClear()
+
+  // emit 'drain'
+  for (const listener of drainListeners) listener()
+
+  await send()
+  expect(chan.send).toHaveBeenCalled()
+})
+
 /**
  * @return {Promise<jest.MockedObject<comq.Channel>[]>}
  */