basquiat 1.1.1 → 1.2.0

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

@@ -0,0 +1,49 @@
+require 'set'
+
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class Events
+        attr_reader :keys
+
+        def initialize
+          @keys     = []
+          @exact    = {}
+          @patterns = {}
+        end
+
+        def []=(key, value)
+          if key =~ /\*|\#/
+            set_pattern_key(key, value)
+          else
+            @exact[key] = value
+          end
+          @keys.push key
+        end
+
+        def [](key)
+          @exact.fetch(key) { simple_pattern_match(key) }
+        rescue KeyError
+          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            = if key =~ /\*/
+                             /^#{key.gsub('*', '[^.]+')}$/
+                           else
+                             /^#{key.gsub(/\#/, '.*')}$/
+                           end
+          @patterns[key] = value
+        end
+
+        def simple_pattern_match(key)
+          match = @patterns.keys.detect(nil) { |pattern| key =~ pattern }
+          @patterns.fetch match
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class Message < Basquiat::Adapters::BaseMessage
+        attr_reader :delivery_info, :props
+        alias_method :di, :delivery_info
+
+        def initialize(message, delivery_info = {}, props = {})
+          super(message)
+          @delivery_info = delivery_info
+          @props         = props
+          @action        = :ack
+        end
+
+        def routing_key
+          delivery_info.routing_key
+        end
+
+        def delivery_tag
+          delivery_info.delivery_tag
+        end
+
+        def ack
+          @action = :ack
+        end
+
+        def unack
+          @action = :unack
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+require 'basquiat/adapters/rabbitmq/requeue_strategies/base_strategy'
+require 'basquiat/adapters/rabbitmq/requeue_strategies/basic_acknowledge'
+require 'basquiat/adapters/rabbitmq/requeue_strategies/dead_lettering'

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

@@ -0,0 +1,33 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class BaseStrategy
+        class << self
+          def session_options
+            {}
+          end
+
+          def setup(options = {})
+            @options = options
+          end
+        end
+
+        def initialize(session)
+          @session = session
+        end
+
+        def run(_message)
+          fail Basquiat::Errors::SubclassResponsibility
+        end
+
+        def ack(delivery_tag)
+          @session.channel.ack(delivery_tag)
+        end
+
+        def unack(delivery_tag)
+          @session.channel.nack(delivery_tag, false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class BasicAcknowledge < BaseStrategy
+        def run(message)
+          yield
+          send(message.action, message.di.delivery_tag)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class DeadLettering < BaseStrategy
+        class << self
+          attr_reader :options
+
+          def setup(opts)
+            @options = {
+                session: { queue: {
+                    options: { 'x-dead-letter-exchange' => opts.fetch(:exchange, 'basquiat.dlx') }
+                } },
+                dlx:     { ttl: opts.fetch(:ttl, 1_000) } }
+          end
+
+          def session_options
+            options.fetch :session
+          rescue KeyError
+            raise 'You have to setup the strategy first'
+          end
+        end
+
+        def initialize(session)
+          super
+          setup_dead_lettering
+        end
+
+        def run(message)
+          catch :skip_processing do
+            check_incoming_messages(message)
+            yield
+          end
+          public_send(message.action, message.delivery_tag)
+        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)
+        end
+
+        def options
+          self.class.options
+        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: '*.#')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      module Strategies
+        class DelayedDeliveryWIP
+          def initialize(channel, message)
+            @channel = channel
+            @message = message
+          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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Basquiat
+  module Adapters
+    class RabbitMq
+      class Session
+        def initialize(connection, session_options = {})
+          @connection = connection
+          @options    = session_options
+        end
+
+        def bind_queue(routing_key)
+          queue.bind(exchange, routing_key: routing_key)
+        end
+
+        def publish(routing_key, message, props = {})
+          channel.confirm_select if @options[:publisher][:confirm]
+          exchange.publish(Basquiat::Json.encode(message),
+                           { routing_key: routing_key,
+                             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
+          end
+        end
+
+        def channel
+          @connection.start unless @connection.connected?
+          @channel ||= @connection.create_channel
+        end
+
+        def queue
+          @queue ||= channel.queue(@options[:queue][:name],
+                                   durable:   true,
+                                   arguments: (@options[:queue][:options] || {}))
+        end
+
+        def exchange
+          @exchange ||= channel.topic(@options[:exchange][:name],
+                                      durable:   true,
+                                      arguments: (@options[:exchange][:options] || {}))
+        end
+      end
+    end
+  end
+end

data/lib/basquiat/adapters/rabbitmq_adapter.rb

@@ -1,129 +1,73 @@
 require 'bunny'
+require 'delegate'
 
 module Basquiat
   module Adapters
     # The RabbitMQ adapter for Basquiat
-    class RabbitMq
-      include Basquiat::Adapters::Base
+    class RabbitMq < Basquiat::Adapters::Base
+      using Basquiat::HashRefinements
 
-      def default_options
-        { failover:  { default_timeout: 5, max_retries: 5 },
-          servers:   [{ host: 'localhost', port: 5672 }],
-          queue:     { name: Basquiat.configuration.queue_name, options: { durable: true } },
-          exchange:  { name: Basquiat.configuration.exchange_name, options: { durable: true } },
-          publisher: { confirm: true, persistent: false },
-          auth:      { user: 'guest', password: 'guest' } }
+
+      # Avoid superclass mismatch errors
+      require 'basquiat/adapters/rabbitmq/events'
+      require 'basquiat/adapters/rabbitmq/message'
+      require 'basquiat/adapters/rabbitmq/configuration'
+      require 'basquiat/adapters/rabbitmq/connection'
+      require 'basquiat/adapters/rabbitmq/session'
+      require 'basquiat/adapters/rabbitmq/requeue_strategies'
+
+      def initialize
+        super
+        @procs = Events.new
+      end
+
+      def base_options
+        @configuration ||= Configuration.new
+        @configuration.merge_user_options(Basquiat.configuration.adapter_options)
       end
 
       def subscribe_to(event_name, proc)
         procs[event_name] = proc
       end
 
-      def publish(event, message, persistent: options[:publisher][:persistent])
-        with_network_failure_handler do
-          channel.confirm_select if options[:publisher][:confirm]
-          exchange.publish(Basquiat::Json.encode(message), routing_key: event)
+      def publish(event, message, persistent: options[:publisher][:persistent], props: {})
+        connection.with_network_failure_handler do
+          session.publish(event, message, props)
           disconnect unless persistent
         end
       end
 
       def listen(block: true)
-        with_network_failure_handler do
-          procs.keys.each { |key| bind_queue(key) }
-          queue.subscribe(block: block) do |di, _, msg|
-            message = Basquiat::Json.decode(msg)
-            procs[di.routing_key].call(message)
+        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
           end
         end
       end
 
-      def connect
-        with_network_failure_handler do
-          connection.start
-          current_server[:retries] = 0
-        end
+      def reset_connection
+        connection.disconnect
+        @connection = nil
+        @session    = nil
       end
 
-      def connection_uri
-        current_server_uri
-      end
+      alias_method :disconnect, :reset_connection
 
-      def disconnect
-        connection.close_all_channels
-        connection.close
-        reset_connection
+      def strategy
+        @strategy ||= @configuration.strategy.new(session)
       end
 
-      def connected?
-        @connection
+      def session
+        @session ||= Session.new(connection, @configuration.session_options)
       end
 
       private
-      def with_network_failure_handler
-        yield if block_given?
-      rescue Bunny::ConnectionForced, Bunny::TCPConnectionFailed, Bunny::NetworkFailure => error
-        if current_server.fetch(:retries, 0) <= failover_opts[:max_retries]
-          handle_network_failures
-          retry
-        else
-          raise(error)
-        end
-      end
-
-      def failover_opts
-        options[:failover]
-      end
-
-      def bind_queue(event_name)
-        queue.bind(exchange, routing_key: event_name)
-      end
-
-      def reset_connection
-        @connection, @channel, @exchange, @queue = nil, nil, nil, nil
-      end
-
-      def rotate_servers
-        return unless options[:servers].any? { |server| server.fetch(:retries, 0) < failover_opts[:max_retries] }
-        options[:servers].rotate!
-      end
-
-      def handle_network_failures
-        logger.warn "[WARN] Handling connection to #{current_server_uri}"
-        retries                  = current_server.fetch(:retries, 0)
-        current_server[:retries] = retries + 1
-        if retries < failover_opts[:max_retries]
-          logger.warn("[WARN] Connection failed retrying in #{failover_opts[:default_timeout]} seconds")
-          sleep(failover_opts[:default_timeout])
-        else
-          rotate_servers
-        end
-        reset_connection
-      end
 
       def connection
-        @connection ||= Bunny.new(current_server_uri)
-      end
-
-      def channel
-        connect
-        @channel ||= connection.create_channel
-      end
-
-      def queue
-        @queue ||= channel.queue(options[:queue][:name], options[:queue][:options])
-      end
-
-      def exchange
-        @exchange ||= channel.topic(options[:exchange][:name], options[:exchange][:options])
-      end
-
-      def current_server
-        options[:servers].first
-      end
-
-      def current_server_uri
-        auth = current_server[:auth] || options[:auth]
-        "amqp://#{auth[:user]}:#{auth[:password]}@#{current_server[:host]}:#{current_server[:port]}"
+        @connection ||= Connection.new(@configuration.connection_options)
       end
     end
   end

data/lib/basquiat/adapters/test_adapter.rb

@@ -1,8 +1,9 @@
 module Basquiat
   module Adapters
     # An adapter to be used in testing
-    class Test
-      include Basquiat::Adapters::Base
+    class Test < Basquiat::Adapters::Base
+      class Message < BaseMessage
+      end
 
       class << self
         def events
@@ -37,7 +38,7 @@ module Basquiat
       def listen(*)
         event = subscribed_event
         msg   = self.class.events[event].shift
-        msg ? procs[event].call(Basquiat::Json.decode(msg)) : nil
+        msg ? procs[event].call(Message.new(msg)) : nil
       end
 
       private