basquiat 1.2.0 → 1.3.0.pre.1

data/lib/basquiat/adapters/rabbitmq/connection.rb

@@ -1,88 +1,65 @@
 module Basquiat
   module Adapters
     class RabbitMq
+      # Control the connection to the RabitMQ server. Delegates calls to {Bunny::Connection}
       class Connection < SimpleDelegator
-        def initialize(servers:, failover: {}, auth: {})
-          @servers  = Array(servers)
-          @failover = { default_timeout: 5, max_retries: 5 }.merge(failover)
-          @auth     = { user: 'guest', password: 'guest' }.merge(auth)
+        # @param hosts: [Array<String>] IPs or FQDN of the RabbitMQ instances
+        # @param port: [Fixnum] Port that the RabbitMQ instances run
+        # @param failover: [Hash]
+        # @option failover: [Fixnum] :max_retries (5) Maximum number of reconnection retries
+        # @option failover: [Fixnum] :default_timeout (5) Interval between to reconnect attempts
+        # @option failover: [Fixnum] :connection_timeout (5) Allowed time before a connection attempt timeouts
+        # @param auth: [Hash]
+        # @option auth: [String] :user ('guest')
+        # @option auth: [String] :password ('guest')
+        def initialize(hosts:, port: 5672, failover: {}, auth: {})
+          @hosts    = hosts
+          @port     = port
+          @failover = failover
+          @auth     = auth
         end
 
+        # Creates a channel
+        # @return [Bunny::Channel]
+        def create_channel
+          connection.start
+          connection.create_channel
+        end
+
+        # Starts the connection if needed
         def start
-          with_network_failure_handler do
-            connection.start
-            current_server[:retries] = 0
-          end
+          connection.start unless connection.connected?
         end
 
         def connected?
           connection.status == :started
         end
 
+        # Closes the channels and the connection.
         def disconnect
           connection.close_all_channels
           connection.close
           reset
         end
 
-        def current_server_uri
-          "amqp://#{current_server[:host]}:#{current_server[:port]}#{current_server[:vhost]}"
-        end
-
-        def with_network_failure_handler
-          yield if block_given?
-        rescue Bunny::ConnectionForced, Bunny::TCPConnectionFailed, Bunny::NetworkFailure => error
-          if current_server.fetch(:retries, 0) <= @failover.fetch(:max_retries)
-            handle_network_failures
-            retry
-          else
-            raise(error)
-          end
-        end
-
         private
 
         def reset
           @connection = nil
         end
 
-        def handle_network_failures
-          Basquiat.logger.warn "Failed to connect to #{current_server_uri}"
-          retries                  = current_server.fetch(:retries, 0)
-          current_server[:retries] = retries + 1
-          if retries < @failover.fetch(:max_retries)
-            Basquiat.logger.warn("Retrying connection to #{current_server_uri} in #{@failover.fetch(:default_timeout)} seconds")
-            sleep(@failover.fetch(:default_timeout))
-          else
-            Basquiat.logger.warn("Total number of retries exceeded for #{current_server_uri}")
-            rotate
-          end
-          reset
-        end
-
         def connection
-          Basquiat.logger.info("Connecting to #{current_server_uri}")
           @connection ||= Bunny.new(
-              current_server_uri,
-              user:     auth[:user],
-              password: auth[:password],
-              automatic_recovery: false,
-              threaded: @failover.fetch(:threaded, true),
-              logger: Basquiat.logger)
+            hosts:                     @hosts,
+            port:                      @port,
+            username:                  @auth.fetch(:user, 'guest'),
+            password:                  @auth.fetch(:password, 'guest'),
+            recovery_attempts:         @failover.fetch(:max_retries, 5),
+            network_recovery_interval: @failover.fetch(:default_timeout, 5),
+            connection_timeout:        @failover.fetch(:connection_timeout, 5),
+            logger:                    Basquiat.logger)
           __setobj__(@connection)
         end
-
-        def current_server
-          @servers.first
-        end
-
-        def auth
-          current_server[:auth] || @auth
-        end
-
-        def rotate
-          @servers.rotate!
-        end
       end
     end
   end

data/lib/basquiat/adapters/rabbitmq/events.rb

@@ -27,10 +27,10 @@ module Basquiat
           raise KeyError, "No event handler found for #{key}"
         end
 
-        # event.for.the.win, event.for.everyone, event.for.*
         private
 
         def set_pattern_key(key, value)
+          key            = key.gsub('.', '\.')
           key            = if key =~ /\*/
                              /^#{key.gsub('*', '[^.]+')}$/
                            else

data/lib/basquiat/adapters/rabbitmq/message.rb

@@ -4,6 +4,10 @@ module Basquiat
       class Message < Basquiat::Adapters::BaseMessage
         attr_reader :delivery_info, :props
         alias_method :di, :delivery_info
+        # @!attribute [r] delivery_info
+        #   @return [Hash] RabbitMQ delivery_info.
+        # @!attribute [r] props
+        #   @return [Hash] RabbitMQ message properties, such as headers.
 
         def initialize(message, delivery_info = {}, props = {})
           super(message)
@@ -12,21 +16,18 @@ module Basquiat
           @action        = :ack
         end
 
+        # @!attribute [rw] routing_key
+        #   It overrides (but not overwrites) the delivery_info routing_key
+        #   @return [String] returns either the set routing_key or the delivery_info routing_key
+        attr_writer :routing_key
         def routing_key
-          delivery_info.routing_key
+          @routing_key || delivery_info.routing_key
         end
 
+        # Shorthand for delivery_info.delivery_tag
         def delivery_tag
           delivery_info.delivery_tag
         end
-
-        def ack
-          @action = :ack
-        end
-
-        def unack
-          @action = :unack
-        end
       end
     end
   end

data/lib/basquiat/adapters/rabbitmq/requeue_strategies/auto_acknowledge.rb

@@ -0,0 +1,15 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class AutoAcknowledge < BaseStrategy
+        def self.session_options
+          { consumer: { manual_ack: false } }
+        end
+
+        def run(*)
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/basquiat/adapters/rabbitmq/requeue_strategies/base_strategy.rb

@@ -20,13 +20,17 @@ module Basquiat
           fail Basquiat::Errors::SubclassResponsibility
         end
 
-        def ack(delivery_tag)
-          @session.channel.ack(delivery_tag)
+        def ack(message)
+          @session.channel.ack(message.delivery_tag)
         end
 
-        def unack(delivery_tag)
-          @session.channel.nack(delivery_tag, false)
+        def nack(message)
+          @session.channel.nack(message.delivery_tag, false)
         end
+
+        private
+
+        attr_reader :session
       end
     end
   end

data/lib/basquiat/adapters/rabbitmq/requeue_strategies/basic_acknowledge.rb

@@ -4,7 +4,7 @@ module Basquiat
       class BasicAcknowledge < BaseStrategy
         def run(message)
           yield
-          send(message.action, message.di.delivery_tag)
+          public_send(message.action, message)
         end
       end
     end

data/lib/basquiat/adapters/rabbitmq/requeue_strategies/dead_lettering.rb

@@ -7,10 +7,11 @@ module Basquiat
 
           def setup(opts)
             @options = {
-                session: { queue: {
-                    options: { 'x-dead-letter-exchange' => opts.fetch(:exchange, 'basquiat.dlx') }
-                } },
-                dlx:     { ttl: opts.fetch(:ttl, 1_000) } }
+              session: {
+                queue: {
+                  options: {
+                    'x-dead-letter-exchange' => opts.fetch(:exchange, 'basquiat.dlx') } } },
+              dlx: { ttl: opts.fetch(:ttl, 1_000) } }
           end
 
           def session_options
@@ -27,18 +28,18 @@ module Basquiat
 
         def run(message)
           catch :skip_processing do
-            check_incoming_messages(message)
+            check_incoming_messages(message.props.headers)
             yield
           end
-          public_send(message.action, message.delivery_tag)
+          public_send(message.action, message)
         end
 
         private
 
-        def check_incoming_messages(message)
-          message.props.headers and
-              message.props.headers['x-death'][1]['queue'] != @session.queue.name and
-              throw(:skip_processing)
+        def check_incoming_messages(headers)
+          headers &&
+            headers['x-death'][1]['queue'] != session.queue.name &&
+            throw(:skip_processing)
         end
 
         def options
@@ -46,11 +47,11 @@ module Basquiat
         end
 
         def setup_dead_lettering
-          dlx   = @session.channel.topic('basquiat.dlx')
-          queue = @session.channel.queue('basquiat.dlq',
-                                         arguments: { 'x-dead-letter-exchange' => @session.exchange.name,
-                                                      'x-message-ttl'          => options[:dlx][:ttl] })
-          queue.bind(dlx, routing_key: '*.#')
+          dlx   = session.channel.topic('basquiat.dlx')
+          queue = session.channel.queue('basquiat.dlq',
+                                        arguments: { 'x-dead-letter-exchange' => session.exchange.name,
+                                                     'x-message-ttl'          => options[:dlx][:ttl] })
+          queue.bind(dlx, routing_key: '#')
         end
       end
     end

data/lib/basquiat/adapters/rabbitmq/requeue_strategies/delayed_delivery.rb

@@ -1,24 +1,88 @@
 module Basquiat
   module Adapters
     class RabbitMq
-      module Strategies
-        class DelayedDeliveryWIP
-          def initialize(channel, message)
-            @channel = channel
-            @message = message
+      class DelayedDelivery < BaseStrategy
+        class << self
+          using HashRefinements
+          attr_reader :options
+
+          def setup(opts)
+            @options = { ddl: { retries:            5,
+                                exchange_name:      'basquiat.dlx',
+                                queue_name_preffix: 'basquiat.ddlq' } }.deep_merge(opts)
+          end
+        end
+
+        def initialize(session)
+          super
+          setup_delayed_delivery
+        end
+
+        def run(message)
+          message.routing_key = extract_event_info(message.routing_key)[0]
+          yield
+          public_send(message.action, message)
+        end
+
+        # @param [Message] message the, well, message to be requeued
+        def requeue(message)
+          @exchange.publish(Basquiat::Json.encode(message), routing_key: requeue_route_for(message.di.routing_key))
+          ack(message)
+        end
+
+        private
+
+        # @param [#match] key the current routing key of the message
+        # @return [String] the calculated routing key for a republish / requeue
+        def requeue_route_for(key)
+          event_name, timeout = extract_event_info(key)
+          if timeout == 2**options[:retries] * 1_000
+            "rejected.#{session.queue.name}.#{event_name}"
+          else
+            "#{timeout * 2}.#{session.queue.name}.#{event_name}"
           end
+        end
+
+        # @param [#match] key the current routing key of the message
+        # @return [Array<String, Integer>] a 2 item array composed of the event.name (aka original routing_key) and
+        #   the current timeout
+        def extract_event_info(key)
+          md = key.match(/^(\d+)\.#{session.queue.name}\.(.+)$/)
+          if md
+            [md.captures[1], md.captures[0].to_i]
+          else
+            # So timeout can turn into 1 second, weird but spares some checking
+            [key, 500]
+          end
+        end
+
+        def options
+          self.class.options[:ddl]
+        end
+
+        def setup_delayed_delivery
+          @exchange = session.channel.topic(options[:exchange_name], durable: true)
+          session.bind_queue("*.#{session.queue.name}.#")
+          prepare_timeout_queues
+          queue = session.channel.queue("#{options[:queue_name_preffix]}_rejected", durable: true)
+          queue.bind(@exchange, routing_key: 'rejected.#')
+        end
+
+        def prepare_timeout_queues
+          queues = (0..options[:retries] - 1).map do |iteration|
+            timeout = 2**iteration
+            session.channel.queue("#{options[:queue_name_preffix]}_#{timeout}", durable: true,
+                                                                                arguments: {
+                                                                                  'x-dead-letter-exchange' => session.exchange.name,
+                                                                                  'x-message-ttl'          => timeout * 1_000 })
+          end
+          bind_timeout_queues(queues)
+        end
 
-          # Criar um exchange
-          # Criar o queue (ou redeclara-lo)
-          # O queue tem que ter um dlx para o exchange padrão
-          # Publicar a mensagem no exchange com um ttl igual ao anterior **2
-          # dar um unack caso o tempo estoure o maximo.
-          def message_handler
-            delay    = message[:headers][0][:expiration]**2
-            exchange = channel.topic('basquiat.dd')
-            queue    = channel.queue('delay', ttl: delay * 2)
-            queue.bind(exchange, 'original_queue.delay.message_name')
-            exchange.publish('original_queue.delay.message_name', message, ttl: delay, dlx: default_exchange)
+        def bind_timeout_queues(queues)
+          queues.each do |queue|
+            timeout = queue.arguments['x-message-ttl'].to_i
+            queue.bind(@exchange, routing_key: "#{timeout}.#")
           end
         end
       end

data/lib/basquiat/adapters/rabbitmq/requeue_strategies.rb

@@ -1,3 +1,10 @@
 require 'basquiat/adapters/rabbitmq/requeue_strategies/base_strategy'
+require 'basquiat/adapters/rabbitmq/requeue_strategies/auto_acknowledge'
 require 'basquiat/adapters/rabbitmq/requeue_strategies/basic_acknowledge'
 require 'basquiat/adapters/rabbitmq/requeue_strategies/dead_lettering'
+require 'basquiat/adapters/rabbitmq/requeue_strategies/delayed_delivery'
+
+Basquiat::Adapters::RabbitMq.register_strategy(:auto_ack, Basquiat::Adapters::RabbitMq::AutoAcknowledge)
+Basquiat::Adapters::RabbitMq.register_strategy(:basic_ack, Basquiat::Adapters::RabbitMq::BasicAcknowledge)
+Basquiat::Adapters::RabbitMq.register_strategy(:dead_lettering, Basquiat::Adapters::RabbitMq::DeadLettering)
+Basquiat::Adapters::RabbitMq.register_strategy(:delayed_delivery, Basquiat::Adapters::RabbitMq::DelayedDelivery)

data/lib/basquiat/adapters/rabbitmq/session.rb

@@ -2,9 +2,11 @@ module Basquiat
   module Adapters
     class RabbitMq
       class Session
-        def initialize(connection, session_options = {})
-          @connection = connection
-          @options    = session_options
+        attr_reader :channel
+
+        def initialize(channel, session_options = {})
+          @channel = channel
+          @options = session_options
         end
 
         def bind_queue(routing_key)
@@ -15,30 +17,26 @@ module Basquiat
           channel.confirm_select if @options[:publisher][:confirm]
           exchange.publish(Basquiat::Json.encode(message),
                            { routing_key: routing_key,
+                             persistent:  true,
                              timestamp:   Time.now.to_i }.merge(props))
         end
 
-        def subscribe(lock, &_block)
-          queue.subscribe(block: lock, manual_ack: true) do |di, props, msg|
-            message = Basquiat::Adapters::RabbitMq::Message.new(msg, di, props)
-            yield message
+        def subscribe(block: true, manual_ack: @options[:consumer][:manual_ack])
+          channel.prefetch(@options[:consumer][:prefetch])
+          queue.subscribe(block: block, manual_ack: manual_ack) do |di, props, msg|
+            yield Basquiat::Adapters::RabbitMq::Message.new(msg, di, props)
           end
         end
 
-        def channel
-          @connection.start unless @connection.connected?
-          @channel ||= @connection.create_channel
-        end
-
         def queue
           @queue ||= channel.queue(@options[:queue][:name],
-                                   durable:   true,
+                                   durable:   @options[:queue][:durable],
                                    arguments: (@options[:queue][:options] || {}))
         end
 
         def exchange
           @exchange ||= channel.topic(@options[:exchange][:name],
-                                      durable:   true,
+                                      durable:   @options[:exchange][:durable],
                                       arguments: (@options[:exchange][:options] || {}))
         end
       end

data/lib/basquiat/adapters/rabbitmq_adapter.rb

@@ -7,7 +7,6 @@ module Basquiat
     class RabbitMq < Basquiat::Adapters::Base
       using Basquiat::HashRefinements
 
-
       # Avoid superclass mismatch errors
       require 'basquiat/adapters/rabbitmq/events'
       require 'basquiat/adapters/rabbitmq/message'
@@ -16,56 +15,76 @@ module Basquiat
       require 'basquiat/adapters/rabbitmq/session'
       require 'basquiat/adapters/rabbitmq/requeue_strategies'
 
+      # Initializes the superclass using a {Events} object as the procs instance variable
       def initialize
-        super
-        @procs = Events.new
+        super(procs: Events.new)
       end
 
+      # Since the RabbitMQ configuration options are quite vast and it's interations with the requeue strategies a bit
+      # convoluted it uses a {Configuration} object to handle it all
       def base_options
         @configuration ||= Configuration.new
         @configuration.merge_user_options(Basquiat.configuration.adapter_options)
       end
 
+      # Adds the subscription and register the proc to the event.
+      # @param event_name [String] routing key to be matched (and bound to) when listening
+      # @param proc [#call] callable object to be run when a message with the said routing_key is received
       def subscribe_to(event_name, proc)
         procs[event_name] = proc
       end
 
-      def publish(event, message, persistent: options[:publisher][:persistent], props: {})
-        connection.with_network_failure_handler do
-          session.publish(event, message, props)
-          disconnect unless persistent
-        end
+      # Publishes the event to the exchange configured.
+      # @param event [String] routing key to be used
+      # @param message [Hash] the message to be publish
+      # @param props [Hash] other properties you wish to publish with the message, such as custom headers etc.
+      def publish(event, message, props: {})
+        session.publish(event, message, props)
+        disconnect unless options[:publisher][:persistent]
       end
 
-      def listen(block: true)
-        connection.with_network_failure_handler do
-          procs.keys.each { |key| session.bind_queue(key) }
-          session.subscribe(block) do |message|
-            strategy.run(message) do
-              procs[message.routing_key].call(message)
-            end
+      # Binds the queues and start the event lopp.
+      # @param block [Boolean] block the thread
+      def listen(block: true, rescue_proc: Basquiat.configuration.rescue_proc)
+        procs.keys.each { |key| session.bind_queue(key) }
+        session.subscribe(block: block) do |message|
+          strategy.run(message) do
+            process_message(message, rescue_proc)
           end
         end
       end
 
+      def process_message(message, rescue_proc)
+        procs[message.routing_key].call(message)
+      rescue => ex
+        rescue_proc.call(ex, message)
+      end
+
+      # Reset the connection to RabbitMQ.
       def reset_connection
         connection.disconnect
         @connection = nil
         @session    = nil
+        @strategy   = nil
       end
 
       alias_method :disconnect, :reset_connection
 
+      # Lazy initializes the requeue strategy configured for the adapter
+      # @return [BaseStrategy]
       def strategy
         @strategy ||= @configuration.strategy.new(session)
       end
 
+      # Lazy initializes and return the session
+      # @return [Session]
       def session
-        @session ||= Session.new(connection, @configuration.session_options)
+        @session ||= Session.new(connection.create_channel, @configuration.session_options)
       end
 
       private
 
+      # Lazy initializes the connection
       def connection
         @connection ||= Connection.new(@configuration.connection_options)
       end

data/lib/basquiat/adapters/test_adapter.rb

@@ -2,9 +2,6 @@ module Basquiat
   module Adapters
     # An adapter to be used in testing
     class Test < Basquiat::Adapters::Base
-      class Message < BaseMessage
-      end
-
       class << self
         def events
           @events ||= Hash.new { |hash, key| hash[key] = [] }
@@ -17,7 +14,7 @@ module Basquiat
 
       attr_reader :options
 
-      def default_options
+      def base_options
         @event_names = []
         { host: '127.0.0.1', port: 123_456, durable: true }
       end
@@ -38,7 +35,7 @@ module Basquiat
       def listen(*)
         event = subscribed_event
         msg   = self.class.events[event].shift
-        msg ? procs[event].call(Message.new(msg)) : nil
+        msg ? procs[event].call(BaseMessage.new(msg)) : nil
       end
 
       private

data/lib/basquiat/errors/strategy_not_registered.rb

@@ -1,14 +1,6 @@
 module Basquiat
   module Errors
-    class StrategyNotRegistered < StandardError
-      def initialize(symbol)
-        super()
-        @symbol = symbol
-      end
-
-      def message
-        "No matching requeue strategy registered as :#{@symbol}"
-      end
+    class StrategyNotRegistered < KeyError
     end
   end
 end