@toa.io/bindings.amqp 0.1.0-alpha.12

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020-present Artem Gurtovoi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@toa.io/bindings.amqp",
+  "version": "0.1.0-alpha.12+7af8037",
+  "description": "Toa AMQP Binding",
+  "author": "temich <tema.gurtovoy@gmail.com>",
+  "homepage": "https://github.com/toa-io/toa#readme",
+  "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "amqplib": "0.8.0",
+    "execa": "5.1.1"
+  },
+  "gitHead": "7af80377d59d326298804b1c10c8dffde54abd16"
+}

package/src/broadcast.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+const { newid } = require('@toa.io/gears')
+
+class Broadcast extends Connector {
+  #group
+  #channel
+  #prefix
+
+  constructor (channel, prefix, group) {
+    super()
+
+    this.#group = group === undefined ? newid() : group
+
+    this.#channel = channel
+    this.#prefix = prefix + '.'
+
+    this.depends(channel)
+  }
+
+  async send (label, payload) {
+    await this.#channel.publish(this.#prefix + label, payload, { expiration: 10, persistent: false })
+  }
+
+  async receive (label, callback) {
+    await this.#channel.subscribe(this.#prefix + label, this.#group, callback)
+  }
+}
+
+exports.Broadcast = Broadcast

package/src/channel.js

@@ -0,0 +1,127 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+const { console, newid } = require('@toa.io/gears')
+
+const { pack, unpack } = require('./message')
+
+class Channel extends Connector {
+  #id
+  #connection
+  #channel
+
+  #bound = {}
+  #expected = {}
+
+  constructor (connection) {
+    super()
+
+    this.#id = newid()
+    this.#connection = connection
+
+    this.depends(connection)
+  }
+
+  async connection () {
+    this.#channel = await this.#connection.channel()
+  }
+
+  async request (label, request) {
+    const queue = 'request.' + label
+    const correlation = newid()
+
+    await this.#channel.assertQueue(queue, QUEUE)
+    await this.#bind(label)
+
+    const message = pack(request)
+    const properties = { replyTo: this.#id, correlationId: correlation }
+
+    await this.#channel.sendToQueue(queue, message, properties)
+
+    const reply = await this.#reply(label, correlation)
+
+    return unpack(reply.content)
+  }
+
+  async reply (label, invocation) {
+    const queue = 'request.' + label
+    const exchange = 'reply.' + label
+
+    await this.#channel.assertQueue(queue, QUEUE)
+    await this.#channel.assertExchange(exchange, 'direct', EXCHANGE)
+
+    await this.#channel.consume(queue, async (received) => {
+      const content = unpack(received.content)
+      const reply = await invocation(content)
+
+      const message = pack(reply)
+      const properties = { correlationId: received.properties.correlationId }
+
+      await this.#channel.publish(exchange, received.properties.replyTo, message, properties)
+      await this.#channel.ack(received)
+    })
+  }
+
+  async publish (label, payload, options) {
+    const exchange = 'event.' + label
+
+    await this.#channel.assertExchange(exchange, 'fanout', EXCHANGE)
+
+    const message = pack(payload)
+
+    await this.#channel.publish(exchange, '', message, options)
+  }
+
+  async subscribe (label, id, callback) {
+    const exchange = 'event.' + label
+    const queue = exchange + '..' + id
+
+    await this.#channel.assertExchange(exchange, 'fanout', EXCHANGE)
+    await this.#channel.assertQueue(queue, QUEUE)
+    await this.#channel.bindQueue(queue, exchange, '')
+
+    await this.#channel.consume(queue, async (received) => {
+      const content = unpack(received.content)
+      await callback(content)
+      await this.#channel.ack(received)
+    })
+  }
+
+  async #bind (label) {
+    const queue = `reply.${label}.${this.#id}`
+    const exchange = 'reply.' + label
+
+    if (this.#bound[queue]) return
+
+    await this.#channel.assertQueue(queue, { exclusive: true, ...QUEUE })
+    await this.#channel.assertExchange(exchange, 'direct', EXCHANGE)
+    await this.#channel.bindQueue(queue, exchange, this.#id)
+    await this.#channel.consume(queue, (message) => this.#replies(message))
+
+    this.#bound[queue] = true
+  }
+
+  #reply (label, correlation) {
+    return new Promise((resolve) => (this.#expected[correlation] = resolve))
+  }
+
+  async #replies (message) {
+    const correlation = message.properties.correlationId
+    const resolve = this.#expected[correlation]
+
+    if (!resolve) {
+      console.warn(`Unexpected reply '${correlation}'. Possible message redelivery.`)
+      return
+    }
+
+    resolve(message)
+
+    delete this.#expected[correlation]
+    await this.#channel.ack(message)
+  }
+}
+
+const QUEUE = { durable: process.env.TOA_ENV !== 'dev' }
+const EXCHANGE = { durable: process.env.TOA_ENV !== 'dev' }
+
+exports.Channel = Channel

package/src/connection.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const amqp = require('amqplib')
+
+const { Connector } = require('@toa.io/core')
+const { console } = require('@toa.io/gears')
+
+class Connection extends Connector {
+  #url
+  #connection
+
+  constructor (host) {
+    super()
+
+    this.#url = Connection.#locate(host)
+  }
+
+  async connection () {
+    this.#connection = await amqp.connect(this.#url)
+    console.info(`AMQP Binding connected to ${this.#url}`)
+  }
+
+  async disconnection () {
+    // TODO: handle current operations
+    // http://www.squaremobius.net/amqp.node/channel_api.html#model_close
+    await this.#connection.close()
+    console.info(`AMQP Binding disconnected from ${this.#url}`)
+  }
+
+  async channel () {
+    return this.#connection.createChannel()
+  }
+
+  static #locate (host) {
+    // TODO: read ./deployments.js
+    const user = 'user'
+    const password = 'password'
+
+    return `amqp://${user}:${password}@${host}`
+  }
+}
+
+exports.Connection = Connection

package/src/consumer.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+
+const { name } = require('./queue')
+
+class Consumer extends Connector {
+  #channel
+  #queue
+
+  constructor (channel, locator, endpoint) {
+    super()
+
+    this.#channel = channel
+    this.#queue = name(locator, endpoint)
+
+    this.depends(channel)
+  }
+
+  async request (request) {
+    return this.#channel.request(this.#queue, request)
+  }
+}
+
+exports.Consumer = Consumer

package/src/deployments.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const deployments = () => {
+  const fullname = 'rabbitmq'
+
+  // TODO: provide passwords as secrets for component containers
+  const user = 'user'
+  const password = 'password'
+  const erlangCookie = 'cookie'
+
+  return [{
+    chart: {
+      name: 'rabbitmq',
+      version: '8.24.3',
+      repository: 'https://charts.bitnami.com/bitnami'
+    },
+    values: {
+      fullnameOverride: fullname,
+      auth: {
+        user,
+        password,
+        erlangCookie
+      }
+    }
+  }]
+}
+
+exports.deployments = deployments

package/src/emitter.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+const { name } = require('./queue')
+
+class Emitter extends Connector {
+  #channel
+  #locator
+  #label
+
+  constructor (channel, locator, label) {
+    super()
+
+    this.#channel = channel
+    this.#locator = locator
+    this.#label = label
+
+    this.depends(channel)
+  }
+
+  async emit (payload) {
+    const label = name(this.#locator, this.#label)
+
+    await this.#channel.publish(label, payload)
+  }
+}
+
+exports.Emitter = Emitter

package/src/factory.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const { Locator } = require('@toa.io/core')
+
+const { Channel } = require('./channel')
+const { Consumer } = require('./consumer')
+const { Producer } = require('./producer')
+const { Emitter } = require('./emitter')
+const { Receiver } = require('./receiver')
+const { Broadcast } = require('./broadcast')
+const { Connection } = require('./connection')
+
+class Factory {
+  #connections = {}
+
+  producer (locator, endpoints, producer) {
+    const channel = this.#channel(locator)
+
+    return new Producer(channel, locator, endpoints, producer)
+  }
+
+  consumer (locator, endpoint) {
+    const channel = this.#channel(locator)
+
+    return new Consumer(channel, locator, endpoint)
+  }
+
+  emitter (locator, label) {
+    const channel = this.#channel(locator)
+
+    return new Emitter(channel, locator, label)
+  }
+
+  receiver (locator, label, id, receiver) {
+    const channel = this.#channel(locator)
+
+    return new Receiver(channel, locator, label, id, receiver)
+  }
+
+  broadcast (name, group) {
+    const locator = new Locator()
+    const channel = this.#channel(locator)
+
+    return new Broadcast(channel, name, group)
+  }
+
+  #channel () {
+    const host = 'rabbitmq' // locator.host('rabbitmq')
+
+    if (this.#connections[host] === undefined) {
+      this.#connections[host] = new Connection(host)
+    }
+
+    return new Channel(this.#connections[host])
+  }
+}
+
+exports.Factory = Factory

package/src/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const { Factory } = require('./factory')
+const { deployments } = require('./deployments')
+
+exports.Factory = Factory
+exports.properties = { async: true }
+exports.deployments = deployments

package/src/message.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const pack = (content) => Buffer.from(JSON.stringify(content))
+const unpack = (content) => JSON.parse(content)
+
+exports.pack = pack
+exports.unpack = unpack

package/src/producer.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+
+const { name } = require('./queue')
+
+class Producer extends Connector {
+  #channel
+  #locator
+  #producer
+  #endpoints
+
+  constructor (channel, locator, endpoints, producer) {
+    super()
+
+    this.#channel = channel
+    this.#locator = locator
+    this.#endpoints = endpoints
+    this.#producer = producer
+
+    this.depends(channel)
+    this.depends(producer)
+  }
+
+  async connection () {
+    return Promise.all(this.#endpoints.map((endpoint) => this.#endpoint(endpoint)))
+  }
+
+  async #endpoint (endpoint) {
+    const queue = name(this.#locator, endpoint)
+
+    await this.#channel.reply(queue, async (request) => this.#producer.invoke(endpoint, request))
+  }
+}
+
+exports.Producer = Producer

package/src/queue.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { concat } = require('@toa.io/gears')
+
+const name = (locator, endpoint) => locator.domain + '.' + concat(locator.name, '.') + endpoint
+
+exports.name = name

package/src/receiver.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+
+const { name } = require('./queue')
+
+class Receiver extends Connector {
+  #channel
+  #receiver
+  #label
+  #id
+
+  constructor (channel, locator, label, id, receiver) {
+    super()
+
+    this.#channel = channel
+    this.#receiver = receiver
+    this.#label = name(locator, label)
+    this.#id = id
+
+    this.depends(channel)
+  }
+
+  async connection () {
+    await this.#channel.subscribe(this.#label, this.#id, (payload) => this.#receiver.receive(payload))
+  }
+}
+
+exports.Receiver = Receiver