message-driver 0.2.2 → 0.3.0

data/lib/message_driver/adapters/bunny_adapter.rb

@@ -1,5 +1,4 @@
 require 'bunny'
-require 'bunny/session_patch'
 
 module MessageDriver
   class Broker
@@ -15,8 +14,8 @@ module MessageDriver
       class Message < MessageDriver::Message::Base
         attr_reader :delivery_info
 
-        def initialize(delivery_info, properties, payload)
-          super(payload, properties[:headers]||{}, properties)
+        def initialize(ctx, delivery_info, properties, payload)
+          super(ctx, payload, properties[:headers]||{}, properties)
           @delivery_info = delivery_info
         end
 
@@ -80,13 +79,13 @@ module MessageDriver
         end
 
         def message_count
-          Client.current_adapter_context.with_channel(false) do |ch|
+          adapter.broker.client.current_adapter_context.with_channel(false) do |ch|
             ch.queue(@name, @dest_options.merge(passive: true)).message_count
           end
         end
 
         def purge
-          Client.current_adapter_context.with_channel(false) do |ch|
+          adapter.broker.client.current_adapter_context.with_channel(false) do |ch|
             bunny_queue(ch).purge
           end
         end
@@ -149,7 +148,7 @@ module MessageDriver
               ch.prefetch(options[:prefetch_size])
             end
             @bunny_consumer = queue.subscribe(options.merge(manual_ack: true)) do |delivery_info, properties, payload|
-              Client.with_adapter_context(@sub_ctx) do
+              adapter.broker.client.with_adapter_context(@sub_ctx) do
                 message = @sub_ctx.args_to_message(delivery_info, properties, payload)
                 handle_message(message)
               end
@@ -166,7 +165,7 @@ module MessageDriver
             when :manual
               consumer.call(message)
             when :transactional
-              Client.with_message_transaction do
+              adapter.broker.client.with_message_transaction do
                 consumer.call(message)
                 @sub_ctx.ack_message(message)
               end
@@ -190,20 +189,22 @@ module MessageDriver
         end
       end
 
-      def initialize(config)
+      def initialize(broker, config)
         validate_bunny_version
+        @broker = broker
         @config = config
-        @handle_connection_errors = config.fetch(:handle_connection_errors, true)
-        initialize_connection
       end
 
       def connection(ensure_started=true)
-        initialize_connection
         if ensure_started
           begin
+            @connection ||= Bunny::Session.new(@config)
             @connection.start
           rescue *NETWORK_ERRORS => e
             raise MessageDriver::ConnectionError.new(e.to_s, e)
+          rescue => e
+            stop
+            raise e
           end
         end
         @connection
@@ -212,13 +213,11 @@ module MessageDriver
       def stop
         begin
           super
-          @connection.close if !@connection.nil? && @connection.open?
-        rescue *NETWORK_ERRORS => e
+          @connection.close if !@connection.nil?
+        rescue => e
           logger.error "error while attempting connection close\n#{exception_to_str(e)}"
         ensure
-          conn = @connection
           @connection = nil
-          conn.cleanup_threads unless conn.nil?
         end
       end
 
@@ -263,12 +262,6 @@ module MessageDriver
 
         def begin_transaction(options={})
           raise MessageDriver::TransactionError, "you can't begin another transaction, you are already in one!" if in_transaction?
-          unless is_transactional?
-            with_channel(false) do |ch|
-              ch.tx_select
-            end
-            @is_transactional = true
-          end
           @in_transaction = true
         end
 
@@ -396,9 +389,13 @@ module MessageDriver
 
         def with_channel(require_commit=true)
           raise MessageDriver::TransactionRollbackOnly if @rollback_only
-          raise MessageDriver::Error, "oh nos!" if !valid?
+          raise MessageDriver::Error, "this adapter context is not valid!" if !valid?
           @channel = adapter.connection.create_channel if @channel.nil?
           reset_channel if @need_channel_reset
+          if in_transaction? && !is_transactional?
+            @channel.tx_select
+            @is_transactional = true
+          end
           handle_errors do
             result = yield @channel
             commit_transaction(true) if require_commit && is_transactional? && !in_transaction?
@@ -407,7 +404,7 @@ module MessageDriver
         end
 
         def args_to_message(delivery_info, properties, payload)
-          Message.new(delivery_info, properties, payload)
+          Message.new(self, delivery_info, properties, payload)
         end
 
         private
@@ -432,43 +429,11 @@ module MessageDriver
         end
       end
 
-      def initialize_connection
-        if @handle_connection_errors
-          if @connection_thread.nil?
-            #hi mom!
-            @connection_thread = Thread.new do
-              @connection = Bunny.new(@config)
-              begin
-                sleep
-              rescue *NETWORK_ERRORS => e
-                logger.error "error on connection\n#{exception_to_str(e)}"
-                if @connection.automatically_recover?
-                  sleep 0.1
-                  unless @connection.recovering_from_network_failure?
-                    stop
-                  end
-                else
-                  stop
-                end
-                retry
-              rescue => e
-                logger.error "unhandled error in connection thread! #{exception_to_str(e)}"
-              end
-            end
-            @connection_thread.abort_on_exception = true
-            sleep 0.1
-          end
-          sleep 0.1 while @connection_thread.status != 'sleep'
-        else
-          @connection ||= Bunny.new(@config)
-        end
-      end
-
       def validate_bunny_version
-        required = Gem::Requirement.create('>= 0.10.8')
+        required = Gem::Requirement.create('>= 1.1.3')
         current = Gem::Version.create(Bunny::VERSION)
         unless required.satisfied_by? current
-          raise MessageDriver::Error, "bunny 0.10.8 or later is required for the bunny adapter"
+          raise MessageDriver::Error, "bunny 1.1.3 or later is required for the bunny adapter"
         end
       end
     end

data/lib/message_driver/adapters/in_memory_adapter.rb

@@ -53,7 +53,7 @@ module MessageDriver
         end
 
         def publish(body, headers={}, properties={})
-          msg = Message.new(body, headers, properties)
+          msg = Message.new(nil, body, headers, properties)
           sub = subscription
           if sub.nil?
             message_queue << msg
@@ -68,7 +68,8 @@ module MessageDriver
         end
       end
 
-      def initialize(config={})
+      def initialize(broker, config={})
+        @broker = broker
         @destinations = {}
         @message_store = Hash.new { |h,k| h[k] = [] }
         @subscriptions = Hash.new

data/lib/message_driver/adapters/stomp_adapter.rb

@@ -13,9 +13,9 @@ module MessageDriver
 
       class Message < MessageDriver::Message::Base
         attr_reader :stomp_message
-        def initialize(stomp_message)
+        def initialize(ctx, stomp_message)
           @stomp_message = stomp_message
-          super(stomp_message.body, stomp_message.headers, {})
+          super(ctx, stomp_message.body, stomp_message.headers, {})
         end
       end
 
@@ -25,9 +25,10 @@ module MessageDriver
 
       attr_reader :config, :poll_timeout
 
-      def initialize(config)
+      def initialize(broker, config)
         validate_stomp_version
 
+        @broker = broker
         @config = config.symbolize_keys
         connect_headers = @config[:connect_headers] ||= {}
         connect_headers.symbolize_keys
@@ -52,7 +53,7 @@ module MessageDriver
           unless name.start_with?("/")
             name = "/queue/#{name}"
           end
-          Destination.new(self, name, dest_options, message_props)
+          Destination.new(adapter, name, dest_options, message_props)
         end
 
         def publish(destination, body, headers={}, properties={})
@@ -66,7 +67,6 @@ module MessageDriver
             sub_id = connection.uuid
             msg = nil
             count = 0
-            options[:id] = sub_id #this is a workaround for https://github.com/stompgem/stomp/issues/56
             connection.subscribe(destination.name, options, sub_id)
             while msg.nil? && count < max_poll_count
               msg = connection.poll
@@ -76,7 +76,7 @@ module MessageDriver
               end
             end
             connection.unsubscribe(destination.name, options, sub_id)
-            Message.new(msg) if msg
+            Message.new(self, msg) if msg
           end
         end
 

data/lib/message_driver/broker.rb

@@ -1,40 +1,101 @@
-require 'forwardable'
-require 'logger'
-
 module MessageDriver
   class Broker
-    extend Forwardable
+    include Logging
+
+    DEFAULT_BROKER_NAME = :default
 
-    attr_reader :adapter, :configuration, :destinations, :consumers, :logger
+    attr_reader :adapter, :configuration, :destinations, :consumers, :name
 
     class << self
-      def configure(options)
-        @instance = new(options)
+      def configure(name = DEFAULT_BROKER_NAME, options)
+        if brokers.keys.include? name
+          raise BrokerAlreadyConfigured, "there is already a broker named #{name} configured"
+        end
+        brokers[name] = new(name, options)
+      end
+
+      def define(name = DEFAULT_BROKER_NAME)
+        yield broker(name)
+      end
+
+      def broker(name = DEFAULT_BROKER_NAME)
+        result = brokers[name]
+        if result.nil?
+          raise BrokerNotConfigured, "There is no broker named #{name} configured. The configured brokers are #{brokers.keys}"
+        end
+        result
+      end
+
+      def client(name)
+        unless result = clients[name]
+          result = clients[name] = Client.for_broker(name)
+        end
+        result
+      end
+
+      def stop_all
+        each_broker do |brk|
+          brk.stop
+        end
       end
 
-      def method_missing(m, *args, &block)
-        @instance.send(m, *args, &block)
+      def restart_all
+        each_broker do |brk|
+          brk.restart
+        end
       end
 
-      def instance
-        @instance
+      def reset_after_tests
+        each_broker do |brk|
+          brk.adapter.reset_after_tests
+        end
       end
 
-      def define
-        yield @instance
+      def reset
+        each_broker do |brk|
+          begin
+            brk.stop
+          rescue => e
+            Logging.logger.warn Logging.message_with_exception("error stopping broker #{brk.name}", e)
+          end
+        end
+        brokers.clear
+      end
+
+      private
+      def brokers
+        @brokers ||= { }
+      end
+
+      def clients
+        @clients ||= { }
+      end
+
+      def each_broker
+        brokers.keys.each do |k|
+          yield brokers[k]
+        end
       end
     end
 
-    def initialize(options)
+    def initialize(name = DEFAULT_BROKER_NAME, options)
+      @name = name
       @adapter = resolve_adapter(options[:adapter], options)
       @stopped = false
       @configuration = options
       @destinations = {}
       @consumers = {}
-      @logger = options[:logger] || Logger.new(STDOUT).tap{|l| l.level = Logger::INFO}
       logger.debug "MessageDriver configured successfully!"
     end
 
+    def logger
+      MessageDriver.logger
+    end
+
+    def client
+      @client ||= self.class.client(name)
+    end
+
     def stop
       @adapter.stop
       @stopped = true
@@ -53,11 +114,11 @@ module MessageDriver
     end
 
     def dynamic_destination(dest_name, dest_options={}, message_props={})
-      Client.dynamic_destination(dest_name, dest_options, message_props)
+      client.dynamic_destination(dest_name, dest_options, message_props)
     end
 
     def destination(key, dest_name, dest_options={}, message_props={})
-      dest = Client.dynamic_destination(dest_name, dest_options, message_props)
+      dest = self.dynamic_destination(dest_name, dest_options, message_props)
       @destinations[key] = dest
     end
 
@@ -87,7 +148,7 @@ module MessageDriver
       when Symbol, String
         resolve_adapter(find_adapter_class(adapter), options)
       when Class
-        resolve_adapter(adapter.new(options), options)
+        resolve_adapter(adapter.new(self, options), options)
       when MessageDriver::Adapters::Base
         adapter
       else
@@ -101,7 +162,7 @@ module MessageDriver
       adapter_method = "#{adapter_name}_adapter"
 
       unless respond_to?(adapter_method)
-        raise "the adapter #{adapter_name} must provide MessageDriver::Broker.#{adapter_method} that returns the adapter class"
+        raise "the adapter #{adapter_name} must provide MessageDriver::Broker##{adapter_method} that returns the adapter class"
       end
 
       send(adapter_method)

data/lib/message_driver/client.rb

@@ -30,23 +30,30 @@ module MessageDriver
     end
 
     def ack_message(message, options={})
-      ctx = current_adapter_context
-      if ctx.supports_client_acks?
-        ctx.ack_message(message, options)
-      else
-        logger.debug("this adapter does not support client acks")
-      end
+      message.ack(options)
     end
 
     def nack_message(message, options={})
-      ctx = current_adapter_context
-      if ctx.supports_client_acks?
-        ctx.nack_message(message, options)
+      message.nack(options)
+    end
+
+    def consumer(key, &block)
+      broker.consumer(key, &block)
+    end
+
+    def find_destination(destination)
+      case destination
+      when Destination::Base
+        destination
       else
-        logger.debug("this adapter does not support client acks")
+        broker.find_destination(destination)
       end
     end
 
+    def find_consumer(consumer)
+      broker.find_consumer(consumer)
+    end
+
     def with_message_transaction(options={}, &block)
       wrapper = fetch_context_wrapper
       wrapper.increment_transaction_depth
@@ -83,7 +90,7 @@ module MessageDriver
     end
 
     def with_adapter_context(adapter_context, &block)
-      old_ctx, Thread.current[:adapter_context] = fetch_context_wrapper(false), build_context_wrapper(adapter_context)
+      old_ctx, Thread.current[adapter_context_key] = fetch_context_wrapper(false), build_context_wrapper(adapter_context)
       begin
         yield
       ensure
@@ -99,44 +106,59 @@ module MessageDriver
       end
     end
 
+    def broker
+      Broker.broker(broker_name)
+    end
+
+    def broker_name
+      Broker::DEFAULT_BROKER_NAME
+    end
+
+    def for_broker(_broker_name)
+      Module.new do |mod|
+        include Client
+        extend self
+
+        define_method :broker_name do
+          _broker_name
+        end
+      end
+    end
+    module_function :for_broker
+
+    def [](index)
+      Broker.client(index)
+    end
+
     private
 
     def fetch_context_wrapper(initialize=true)
-      wrapper = Thread.current[:adapter_context]
+      wrapper = Thread.current[adapter_context_key]
       if wrapper.nil? || !wrapper.valid?
         if initialize
           wrapper = build_context_wrapper
         else
           wrapper = nil
         end
-        Thread.current[:adapter_context] = wrapper
+        Thread.current[adapter_context_key] = wrapper
       end
       wrapper
     end
 
     def set_context_wrapper(wrapper)
-      Thread.current[:adapter_context] = wrapper
+      Thread.current[adapter_context_key] = wrapper
     end
 
-    def build_context_wrapper(ctx=Broker.adapter.new_context)
+    def build_context_wrapper(ctx=adapter.new_context)
       ContextWrapper.new(ctx)
     end
 
-    def find_destination(destination)
-      case destination
-      when Destination::Base
-        destination
-      else
-        Broker.find_destination(destination)
-      end
-    end
-
-    def find_consumer(consumer)
-      Broker.find_consumer(consumer)
+    def adapter
+      broker.adapter
     end
 
-    def adapter
-      Broker.adapter
+    def adapter_context_key
+      @__adapter_context_key ||= "#{broker_name}_adapter_context".to_sym
     end
 
     class ContextWrapper
@@ -161,5 +183,4 @@ module MessageDriver
       end
     end
   end
-
 end

data/lib/message_driver/destination.rb

@@ -11,11 +11,11 @@ module MessageDriver
       end
 
       def publish(body, headers={}, properties={})
-        Client.publish(self, body, headers, properties)
+        adapter.broker.client.publish(self, body, headers, properties)
       end
 
       def pop_message(options={})
-        Client.pop_message(self, options)
+        adapter.broker.client.pop_message(self, options)
       end
 
       def after_initialize(adapter_context)

data/lib/message_driver/errors.rb

@@ -5,6 +5,8 @@ require 'nesty'
 
 module MessageDriver
   class Error < StandardError; end
+  class BrokerNotConfigured < Error; end
+  class BrokerAlreadyConfigured < Error; end
   class TransactionError < Error; end
   class TransactionRollbackOnly < TransactionError; end
   class NoSuchDestinationError < Error; end

data/lib/message_driver/logging.rb

@@ -1,11 +1,17 @@
 module MessageDriver
   module Logging
+    extend self
+
     def logger
-      MessageDriver::Broker.logger
+      MessageDriver.logger
     end
 
     def exception_to_str(e)
       (["#{e.class}: #{e.to_s}"] + e.backtrace).join("\n  ")
     end
+
+    def message_with_exception(message, e)
+      [message, exception_to_str(e)].join("\n")
+    end
   end
 end

data/lib/message_driver/message.rb

@@ -1,20 +1,31 @@
 module MessageDriver
   module Message
     class Base
-      attr_reader :body, :headers, :properties
+      include Logging
 
-      def initialize(body, headers, properties)
+      attr_reader :ctx, :body, :headers, :properties
+
+      def initialize(ctx, body, headers, properties)
+        @ctx = ctx
         @body = body
         @headers = headers
         @properties = properties
       end
 
       def ack(options={})
-        Client.ack_message(self, options)
+        if ctx.supports_client_acks?
+          ctx.ack_message(self, options)
+        else
+          logger.debug("this adapter does not support client acks")
+        end
       end
 
       def nack(options={})
-        Client.nack_message(self, options)
+        if ctx.supports_client_acks?
+          ctx.nack_message(self, options)
+        else
+          logger.debug("this adapter does not support client acks")
+        end
       end
     end
   end

data/lib/message_driver/version.rb

@@ -1,5 +1,5 @@
 module Message
   module Driver
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end

data/lib/message_driver.rb

@@ -1,8 +1,9 @@
 require 'message_driver/version'
+require 'logger'
 
+require 'message_driver/logging'
 require 'message_driver/errors'
 require 'message_driver/broker'
-require 'message_driver/logging'
 require 'message_driver/message'
 require 'message_driver/destination'
 require 'message_driver/subscription'
@@ -10,11 +11,17 @@ require 'message_driver/adapters/base'
 require 'message_driver/client'
 
 module MessageDriver
-  def self.configure(options={})
-    Broker.configure(options)
+  module_function
+  def configure(broker_name = Broker::DEFAULT_BROKER_NAME, options)
+    Broker.configure(broker_name, options)
   end
 
-  def self.stop
-    Broker.stop
+  def logger
+    @__logger ||= Logger.new(STDOUT).tap{|l| l.level = Logger::INFO}
   end
+
+  def logger=(logger)
+    @__logger = logger
+  end
+
 end