rabbitmq-actors 2.0.0

data/lib/rabbitmq/actors/patterns/headers/headers_producer.rb

@@ -0,0 +1,64 @@
+require_relative '../../base/producer'
+
+module RabbitMQ
+  module Actors
+    # A producer of messages routed to certain queues bound based on message headers matching.
+    #
+    # @example
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   publisher = RabbitMQ::Actors::HeadersProducer.new(headers_name: 'reports', logger: Rails.logger)
+    #   message = 'A report about USA economy'
+    #   publisher.publish(message, message_id: '1234837633', headers: { 'type' => :economy, 'area' => 'USA'})
+    #
+    class HeadersProducer < Base::Producer
+      # @!attribute [r] headers_name
+      #   @return [Bunny::Exchange] the headers exchange where to publish messages.
+      attr_reader :headers_name
+
+      # @param :headers_name [String] name of the headers exchange where to publish messages.
+      # @option opts [String] :reply_queue_name the name of the queue where a consumer should reply.
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      def initialize(headers_name:, **opts)
+        super(opts.merge(headers_name: headers_name))
+      end
+
+      # Send a message to the RabbitMQ server.
+      # @param message [String] the message body to be sent.
+      # @param :message_id [String] user-defined id for replies to refer to this message using :correlation_id
+      # @param :headers [Hash] send the message only to queues bound to this exchange and matching any/all of these headers.
+      # @see Bunny::Exchange#publish for extra options:
+      # @option opts [Boolean] :persistent Should the message be persisted to disk?. Default true.
+      # @option opts [Boolean] :mandatory Should the message be returned if it cannot be routed to any queue?
+      # @option opts [Integer] :timestamp A timestamp associated with this message
+      # @option opts [Integer] :expiration Expiration time after which the message will be deleted
+      # @option opts [String]  :type Message type, e.g. what type of event or command this message represents. Can be any string
+      # @option opts [String]  :reply_to Queue name other apps should send the response to. Default to
+      #   replay_queue_name if it was defined at creation time.
+      # @option opts [String]  :content_type Message content type (e.g. application/json)
+      # @option opts [String]  :content_encoding Message content encoding (e.g. gzip)
+      # @option opts [String]  :correlation_id Message correlated to this one, e.g. what request this message is a reply for
+      # @option opts [Integer] :priority Message priority, 0 to 9. Not used by RabbitMQ, only applications
+      # @option opts [String]  :user_id Optional user ID. Verified by RabbitMQ against the actual connection username
+      # @option opts [String]  :app_id Optional application ID
+      def publish(message, message_id:, headers:, **opts)
+        super(message, opts.merge(message_id: message_id, headers: headers))
+      end
+
+      private
+
+      # Sets the exchange name to connect to.
+      # @see #initialize for the list of options that can be received.
+      def pre_initialize(**opts)
+        @headers_name = opts[:headers_name]
+        super
+      end
+
+      # The durable RabbitMQ headers exchange where to publish messages.
+      # @return [Bunny::Exchange]
+      def exchange
+        @exchange ||= channel.headers(headers_name, durable: true)
+      end
+    end
+  end
+end

data/lib/rabbitmq/actors/patterns/master_workers/master_producer.rb

@@ -0,0 +1,61 @@
+require_relative '../../base/producer'
+
+module RabbitMQ
+  module Actors
+
+    # A producer of messages routed (via a default exchange) to a given queue.
+    # Used to distribute tasks among several worker processes listening a shared queue.
+    #
+    # @example
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   master = RabbitMQ::Actors::MasterProducer.new(
+    #     queue_name:       'purchases',
+    #     auto_delete:      false,
+    #     reply_queue_name: 'confirmations',
+    #     logger:           Rails.logger)
+    #
+    #   message = { stock: 'Apple', number: 1000 }.to_json
+    #   master.publish(message, message_id: '1234837325', content_type: "application/json")
+    #
+    class MasterProducer < Base::Producer
+      # @param :queue_name [String] name of the durable queue where to publish messages.
+      # @option opts [Boolean] :auto_delete (true) if the queue will be deleted when
+      #   there are no more consumers subscribed to it.
+      # @option opts [String] :reply_queue_name the name of the queue where a consumer should reply.
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      def initialize(queue_name:, **opts)
+        super(opts.merge(queue_name: queue_name, exclusive: false))
+      end
+
+      # Send a message to the RabbitMQ server.
+      # @param message [String] the message body to be sent.
+      # @param :message_id [String] user-defined id for replies to refer to this message using :correlation_id
+      # @see Bunny::Exchange#publish for extra options:
+      # @option opts [Boolean] :persistent Should the message be persisted to disk?. Default true.
+      # @option opts [Boolean] :mandatory Should the message be returned if it cannot be routed to any queue?
+      # @option opts [Integer] :timestamp A timestamp associated with this message
+      # @option opts [Integer] :expiration Expiration time after which the message will be deleted
+      # @option opts [String]  :type Message type, e.g. what type of event or command this message represents. Can be any string
+      # @option opts [String]  :reply_to Queue name other apps should send the response to. Default to
+      #   replay_queue_name if it was defined at creation time.
+      # @option opts [String]  :content_type Message content type (e.g. application/json)
+      # @option opts [String]  :content_encoding Message content encoding (e.g. gzip)
+      # @option opts [String]  :correlation_id Message correlated to this one, e.g. what request this message is a reply for
+      # @option opts [Integer] :priority Message priority, 0 to 9. Not used by RabbitMQ, only applications
+      # @option opts [String]  :user_id Optional user ID. Verified by RabbitMQ against the actual connection username
+      # @option opts [String]  :app_id Optional application ID
+      def publish(message, message_id:, **opts)
+        super(message, opts.merge(message_id: message_id, routing_key: queue.name))
+      end
+
+      private
+
+      # The default RabbitMQ exchange where to publish messages
+      # @return [Bunny::Exchange]
+      def exchange
+        @exchange ||= channel.default_exchange
+      end
+    end
+  end
+end

data/lib/rabbitmq/actors/patterns/master_workers/worker.rb

@@ -0,0 +1,63 @@
+require_relative '../../base/consumer'
+
+module RabbitMQ
+  module Actors
+    # A consumer of messages from RabbitMQ based on queue name.
+    # @abstract Subclass and override #perform to define your customized worker class.
+    #
+    # @example
+    #   class MyListener < RabbitMQ::Actors::Worker
+    #     class_attribute :queue_name, instance_writer: false
+    #
+    #     def initialize
+    #       super(queue_name:      queue_name,
+    #             manual_ack:      true
+    #             logger:          Rails.logger,
+    #             on_cancellation: ->{ ActiveRecord::Base.connection.close }
+    #     end
+    #
+    #   private
+    #
+    #     def perform(**task)
+    #       answer, transaction_guid = JSON.parse(task[:body]), task[:properties][:correlation_id]
+    #       transaction = referred_transaction(transaction_guid: transaction_guid, tid: answer['tid'])
+    #       return _no_transaction!(message_id: transaction_guid, transaction: transaction) if transaction.errors.present?
+    #       update_transaction(transaction, answer.symbolize_keys)
+    #     end
+    #
+    #     def referred_transaction(transaction_guid:, tid:)
+    #       ...
+    #     end
+    #
+    #     def update_transaction(purchase, **attrs)
+    #       ...
+    #     end
+    #
+    #     def _no_transaction!(message_id:, transaction:)
+    #       log_event(type:        'Transaction',
+    #                 message_id:  message_id,
+    #                 description: 'ERROR: answer does not identify any transaction',
+    #                 payload:     { errors: transaction.errors.full_messages },
+    #                 severity:    :high)
+    #       transaction
+    #     end
+    #   end
+    #
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   MyListener.queue_name = "transactions"
+    #   MyListener.new.start!
+    #
+    class Worker < Base::Consumer
+      # @param :queue_name [String] name of the durable queue where to receive messages from.
+      # @option opts [Boolean] :manual_ack to acknowledge messages to the RabbitMQ server
+      #   once executed.
+      # @option opts [Proc] :on_cancellation to be executed before the worker is terminated
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      # Rest of options required by your subclass.
+      def initialize(queue_name:, **opts)
+        super(opts.merge(queue_name: queue_name, exclusive: false))
+      end
+    end
+  end
+end

data/lib/rabbitmq/actors/patterns/publish_subscribe/publisher.rb

@@ -0,0 +1,72 @@
+require_relative '../../base/producer'
+
+module RabbitMQ
+  module Actors
+    # A producer of messages routed to all the consumers bound to the exchange.
+    #
+    # @example
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   publisher = RabbitMQ::Actors::Publisher.new(exchange_name: 'sports', logger: Rails.logger)
+    #
+    #   message = {
+    #     championship: 'Premier League',
+    #     match: {
+    #       team_1: 'Chelsea',
+    #       team_2: 'Manchester City',
+    #       date:   '03-Sep-2016',
+    #       score:  '2-2'
+    #     } }.to_json
+    #
+    #   publisher.publish(message, message_id: '1234837633', content_type: "application/json")
+    #
+    class Publisher < Base::Producer
+      # @!attribute [r] exchange_name
+      #   @return [Bunny::Exchange] the fanout exchange where to publish messages.
+      attr_reader :exchange_name
+
+      # @param :exchange_name [String] name of the exchange where to publish messages.
+      # @option opts [String] :reply_queue_name the name of the queue where a consumer should reply.
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      def initialize(exchange_name:, **opts)
+        super(opts.merge(exchange_name: exchange_name))
+      end
+
+      # Send a message to the RabbitMQ server.
+      # @param message [String] the message body to be sent.
+      # @param :message_id [String] user-defined id for replies to refer to this message using :correlation_id
+      # @see Bunny::Exchange#publish for extra options:
+      # @option opts [Boolean] :persistent Should the message be persisted to disk?. Default true.
+      # @option opts [Boolean] :mandatory Should the message be returned if it cannot be routed to any queue?
+      # @option opts [Integer] :timestamp A timestamp associated with this message
+      # @option opts [Integer] :expiration Expiration time after which the message will be deleted
+      # @option opts [String]  :type Message type, e.g. what type of event or command this message represents. Can be any string
+      # @option opts [String]  :reply_to Queue name other apps should send the response to. Default to
+      #   replay_queue_name if it was defined at creation time.
+      # @option opts [String]  :content_type Message content type (e.g. application/json)
+      # @option opts [String]  :content_encoding Message content encoding (e.g. gzip)
+      # @option opts [String]  :correlation_id Message correlated to this one, e.g. what request this message is a reply for
+      # @option opts [Integer] :priority Message priority, 0 to 9. Not used by RabbitMQ, only applications
+      # @option opts [String]  :user_id Optional user ID. Verified by RabbitMQ against the actual connection username
+      # @option opts [String]  :app_id Optional application ID
+      def publish(message, message_id:, **opts)
+        super(message, opts.merge(message_id: message_id))
+      end
+
+      private
+
+      # Sets the exchange name to connect to.
+      # @see #initialize for the list of options that can be received.
+      def pre_initialize(**opts)
+        @exchange_name = opts[:exchange_name]
+        super
+      end
+
+      # The durable RabbitMQ fanout exchange where to publish messages.
+      # @return [Bunny::Exchange]
+      def exchange
+        @exchange ||= channel.fanout(exchange_name, durable: true)
+      end
+    end
+  end
+end

data/lib/rabbitmq/actors/patterns/publish_subscribe/subscriber.rb

@@ -0,0 +1,70 @@
+require_relative '../../base/consumer'
+
+module RabbitMQ
+  module Actors
+    # A consumer of all messages produced by a fanout RabbitMQ exchange.
+    # @abstract Subclass and override #perform to define your customized subscriber class.
+    #
+    # @example
+    #   class ScoresListener < RabbitMQ::Actors::Subscriber
+    #     def initialize
+    #       super(exchange_name:   'scores',
+    #             logger:          Rails.logger,
+    #             on_cancellation: ->{ ActiveRecord::Base.connection.close })
+    #     end
+    #
+    #     private
+    #
+    #     def perform(**task)
+    #       match_data = JSON.parse(task[:body])
+    #       process_match(match_data)
+    #     end
+    #     ...
+    #   end
+    #
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   ScoresListener.new.start!
+    #
+    class Subscriber < Base::Consumer
+      # @!attribute [r] exchange_name
+      #   @return [Bunny::Exchange] the exchange where to get messages from.
+      attr_reader :exchange_name
+
+      # @param :exchange_name [String] name of the exchange where to consume messages from.
+      # @option opts [Proc]   :on_cancellation to be executed before the worker is terminated
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      # Rest of options required by your subclass.
+      def initialize(exchange_name:, **opts)
+        super(opts.merge(exchange_name: exchange_name))
+      end
+
+      private
+
+      # Set exchange_name this worker is bound to.
+      # @see #initialize for the list of options that can be received.
+      def pre_initialize(**opts)
+        @exchange_name = opts[:exchange_name]
+        super
+      end
+
+      # Bind this worker's queue to the exchange
+      # @see #initialize for the list of options that can be received.
+      def post_initialize(**opts)
+        bind_queue_to_exchange
+        super
+      end
+
+      # The durable fanout RabbitMQ exchange from where messages are received
+      # @return [Bunny::Exchange]
+      def exchange
+        @exchange ||= channel.fanout(exchange_name, durable: true)
+      end
+
+      # Bind this worker's listening queue to the exchange to receive all messages produced.
+      def bind_queue_to_exchange
+        queue.bind(exchange)
+      end
+    end
+  end
+end

data/lib/rabbitmq/actors/patterns/routing/routing_consumer.rb

@@ -0,0 +1,99 @@
+require_relative '../../base/consumer'
+
+module RabbitMQ
+  module Actors
+    # A consumer of messages from RabbitMQ based on routing keys.
+    # @abstract Subclass and override #perform to define your customized routing worker class.
+    #
+    # @example
+    #   class TennisListener < RabbitMQ::Actors::RoutingConsumer
+    #     def initialize
+    #       super(exchange_name:   'sports',
+    #             binding_keys:    ['tennis'],
+    #             logger:          Rails.logger,
+    #             on_cancellation: ->{ ActiveRecord::Base.connection.close })
+    #     end
+    #
+    #     private
+    #
+    #     def perform(**task)
+    #       match_data = JSON.parse(task[:body])
+    #       process_tennis_match(match_data)
+    #     end
+    #     ...
+    #   end
+    #
+    #   class FootballListener < RabbitMQ::Actors::RoutingConsumer
+    #     def initialize
+    #       super(exchange_name:   'sports',
+    #             binding_keys:    ['football', 'soccer'],
+    #             logger:          Rails.logger,
+    #             on_cancellation: ->{ ActiveRecord::Base.connection.close })
+    #     end
+    #
+    #     private
+    #
+    #     def perform(**task)
+    #       match_data = JSON.parse(task[:body])
+    #       process_footbal_match(match_data)
+    #     end
+    #     ...
+    #   end
+    #
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   TennisListener.new.start!
+    #   FootballListener.new.start!
+    #
+    class RoutingConsumer < Base::Consumer
+      # @!attribute [r] exchange_name
+      #   @return [Bunny::Exchange] the exchange where to get messages from.
+      attr_reader :exchange_name
+
+      # @!attribute [r] binding_keys
+      #   @return [String, Array] the routing keys this worker is interested in.
+      attr_reader :binding_keys
+
+      # @param :exchange_name [String] name of the exchange where to consume messages from.
+      # @param :binding_keys  [String, Array] list of routing keys this worker is interested in.
+      #   Default to all: '#'
+      # @option opts [Proc] :on_cancellation to be executed before the worker is terminated
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      # Rest of options required by your subclass.
+      def initialize(exchange_name:, binding_keys: '#', **opts)
+        super(opts.merge(exchange_name: exchange_name, binding_keys: binding_keys))
+      end
+
+      private
+
+      # Set exchange_name and binding_keys this worker is bound to.
+      # @see #initialize for the list of options that can be received.
+      def pre_initialize(**opts)
+        @exchange_name = opts[:exchange_name]
+        @binding_keys  = Array(opts[:binding_keys])
+        super
+      end
+
+      # Bind this worker's queue to the exchange and to the given binding_keys
+      # @see #initialize for the list of options that can be received.
+      def post_initialize(**opts)
+        bind_queue_to_exchange_routing_keys
+        super
+      end
+
+      # The durable direct RabbitMQ exchange from where messages are received
+      # @return [Bunny::Exchange]
+      def exchange
+        @exchange ||= channel.direct(exchange_name, durable: true)
+      end
+
+      # Bind this worker's listening queue to the exchange and receive only messages with routing key
+      # one of the given binding_keys.
+      def bind_queue_to_exchange_routing_keys
+        binding_keys.each do |key|
+          queue.bind(exchange, routing_key: key)
+        end
+      end
+    end
+  end
+end

data/lib/rabbitmq/actors/patterns/routing/routing_producer.rb

@@ -0,0 +1,75 @@
+require_relative '../../base/producer'
+
+module RabbitMQ
+  module Actors
+    # A producer of messages routed to all the queues bound to the message's routing_key
+    #
+    # @example
+    #   RabbitMQ::Server.url = 'amqp://localhost'
+    #
+    #   publisher = RabbitMQ::Actors::RoutingProducer.new(
+    #     exchange_name:     'sports',
+    #     replay_queue_name: 'scores',
+    #     logger:            Rails.logger)
+    #
+    #   message = {
+    #     championship: 'Wimbledon',
+    #     match: {
+    #       player_1: 'Rafa Nadal',
+    #       player_2: 'Roger Federed',
+    #       date:     '01-Jul-2016'
+    #     } }.to_json
+    #
+    #   publisher.publish(message, message_id: '1234837633', content_type: "application/json", routing_key: 'tennis')
+    #
+    class RoutingProducer < Base::Producer
+      # @!attribute [r] exchange_name
+      #   @return [Bunny::Exchange] the routing exchange where to publish messages.
+      attr_reader :exchange_name
+
+      # @param :exchange_name [String] name of the exchange where to publish messages.
+      # @option opts [String] :reply_queue_name the name of the queue where a consumer should reply.
+      # @option opts [Logger] :logger the logger where to output info about this agent's activity.
+      def initialize(exchange_name:, **opts)
+        super(opts.merge(exchange_name: exchange_name))
+      end
+
+      # Send a message to the RabbitMQ server.
+      # @param message [String] the message body to be sent.
+      # @param :message_id [String] user-defined id for replies to refer to this message using :correlation_id
+      # @param :routing_key [String] send the message only to queues bound to this exchange and this routing_key
+      # @see Bunny::Exchange#publish for extra options:
+      # @option opts [Boolean] :persistent Should the message be persisted to disk?. Default true.
+      # @option opts [Boolean] :mandatory Should the message be returned if it cannot be routed to any queue?
+      # @option opts [Integer] :timestamp A timestamp associated with this message
+      # @option opts [Integer] :expiration Expiration time after which the message will be deleted
+      # @option opts [String]  :type Message type, e.g. what type of event or command this message represents. Can be any string
+      # @option opts [String]  :reply_to Queue name other apps should send the response to. Default to
+      #   replay_queue_name if it was defined at creation time.
+      # @option opts [String]  :content_type Message content type (e.g. application/json)
+      # @option opts [String]  :content_encoding Message content encoding (e.g. gzip)
+      # @option opts [String]  :correlation_id Message correlated to this one, e.g. what request this message is a reply for
+      # @option opts [Integer] :priority Message priority, 0 to 9. Not used by RabbitMQ, only applications
+      # @option opts [String]  :user_id Optional user ID. Verified by RabbitMQ against the actual connection username
+      # @option opts [String]  :app_id Optional application ID
+      def publish(message, message_id:, routing_key:, **opts)
+        super(message, opts.merge(message_id: message_id, routing_key: routing_key))
+      end
+
+      private
+
+      # Sets the exchange name to connect to.
+      # @see #initialize for the list of options that can be received.
+      def pre_initialize(**opts)
+        @exchange_name = opts[:exchange_name]
+        super
+      end
+
+      # The durable RabbitMQ direct exchange where to publish messages.
+      # @return [Bunny::Exchange]
+      def exchange
+        @exchange ||= channel.direct(exchange_name, durable: true)
+      end
+    end
+  end
+end