message-driver 0.1.0 → 0.2.0.rc1

data/lib/message_driver/adapters/stomp_adapter.rb

@@ -0,0 +1,127 @@
+require 'stomp'
+require 'forwardable'
+
+module MessageDriver
+  class Broker
+    def stomp_adapter
+      MessageDriver::Adapters::StompAdapter
+    end
+  end
+
+  module Adapters
+    class StompAdapter < Base
+
+      class Message < MessageDriver::Message::Base
+        attr_reader :stomp_message
+        def initialize(stomp_message)
+          @stomp_message = stomp_message
+          super(stomp_message.body, stomp_message.headers, {})
+        end
+      end
+
+      class Destination < MessageDriver::Destination::Base
+
+      end
+
+      attr_reader :config, :poll_timeout
+
+      def initialize(config)
+        validate_stomp_version
+
+        @config = config.symbolize_keys
+        connect_headers = @config[:connect_headers] ||= {}
+        connect_headers.symbolize_keys
+        connect_headers[:"accept-version"] = "1.1,1.2"
+
+        vhost = @config.delete(:vhost)
+        connect_headers[:host] = vhost if vhost
+
+        @poll_timeout = 1
+      end
+
+      class StompContext < ContextBase
+        extend Forwardable
+
+        def_delegators :adapter, :with_connection, :poll_timeout
+
+        #def subscribe(destination, consumer)
+        #destination.subscribe(&consumer)
+        #end
+
+        def create_destination(name, dest_options={}, message_props={})
+          unless name.start_with?("/")
+            name = "/queue/#{name}"
+          end
+          Destination.new(self, name, dest_options, message_props)
+        end
+
+        def publish(destination, body, headers={}, properties={})
+          with_connection do |connection|
+            connection.publish(destination.name, body, headers)
+          end
+        end
+
+        def pop_message(destination, options={})
+          with_connection do |connection|
+            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
+              if msg.nil?
+                count += 1
+                sleep 0.1
+              end
+            end
+            connection.unsubscribe(destination.name, options, sub_id)
+            Message.new(msg) if msg
+          end
+        end
+
+        private
+
+        def max_poll_count
+          (poll_timeout / 0.1).to_i
+        end
+      end
+
+      def build_context
+        StompContext.new(self)
+      end
+
+      def with_connection
+        begin
+          @connection ||= open_connection
+          yield @connection
+        rescue SystemCallError, IOError => e
+          raise MessageDriver::ConnectionError.new(e)
+        end
+      end
+
+      def stop
+        super
+        if @connection
+          @connection.disconnect
+        end
+      end
+
+      private
+
+      def open_connection
+        conn = Stomp::Connection.new(@config)
+        raise MessageDriver::ConnectionError, conn.connection_frame.to_s unless conn.open?
+        conn
+      end
+
+      def validate_stomp_version
+        required = Gem::Requirement.create('~> 1.2.10')
+        current = Gem::Version.create(Stomp::Version::STRING)
+        unless required.satisfied_by? current
+          raise MessageDriver::Error, "stomp 1.2.10 or a later version of the 1.2.x series is required for the stomp adapter"
+        end
+      end
+    end
+  end
+end

data/lib/message_driver/broker.rb

@@ -1,10 +1,11 @@
 require 'forwardable'
+require 'logger'
 
 module MessageDriver
   class Broker
     extend Forwardable
 
-    attr_reader :adapter, :configuration, :destinations
+    attr_reader :adapter, :configuration, :destinations, :consumers, :logger
 
     def_delegators :@adapter, :stop
 
@@ -13,12 +14,8 @@ module MessageDriver
         @instance = new(options)
       end
 
-      def method_missing(m, *args)
-        @instance.send(m, *args)
-      end
-
-      def with_transaction(options={}, &block)
-        @instance.with_transaction(options, &block)
+      def method_missing(m, *args, &block)
+        @instance.send(m, *args, &block)
       end
 
       def instance
@@ -34,37 +31,39 @@ module MessageDriver
       @adapter = resolve_adapter(options[:adapter], options)
       @configuration = options
       @destinations = {}
-    end
-
-    def publish(destination, body, headers={}, properties={})
-      dest = find_destination(destination)
-      dest.publish(body, headers, properties)
-    end
-
-    def pop_message(destination, options={})
-      dest = find_destination(destination)
-      dest.pop_message(options)
+      @consumers = {}
+      @logger = options[:logger] || Logger.new(STDOUT).tap{|l| l.level = Logger::INFO}
+      logger.debug "MessageDriver configured successfully!"
     end
 
     def dynamic_destination(dest_name, dest_options={}, message_props={})
-      adapter.create_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 = dynamic_destination(dest_name, dest_options, message_props)
+      dest = Client.dynamic_destination(dest_name, dest_options, message_props)
       @destinations[key] = dest
     end
 
-    def with_transaction(options={}, &block)
-      adapter.with_transaction(options, &block)
+    def consumer(key, &block)
+      raise MessageDriver::Error, "you must provide a block" unless block_given?
+      @consumers[key] = block
     end
 
-    private
+    def find_destination(destination_name)
+      destination = @destinations[destination_name]
+      raise MessageDriver::NoSuchDestinationError, "no destination #{destination_name} has been configured" if destination.nil?
+      destination
+    end
 
-    def find_destination(destination)
-      @destinations[destination]
+    def find_consumer(consumer_name)
+      consumer = @consumers[consumer_name]
+      raise MessageDriver::NoSuchConsumerError, "no consumer #{consumer_name} has been configured" if consumer.nil?
+      consumer
     end
 
+    private
+
     def resolve_adapter(adapter, options)
       case adapter
       when nil

data/lib/message_driver/client.rb

@@ -0,0 +1,157 @@
+require 'forwardable'
+
+module MessageDriver
+  module Client
+    include Logging
+    extend self
+
+    def publish(destination, body, headers={}, properties={})
+      dest = find_destination(destination)
+      current_adapter_context.publish(dest, body, headers, properties)
+    end
+
+    def pop_message(destination, options={})
+      dest = find_destination(destination)
+      current_adapter_context.pop_message(dest, options)
+    end
+
+    def subscribe(destination_name, consumer_name, options={})
+      destination = find_destination(destination_name)
+      consumer =  find_consumer(consumer_name)
+      current_adapter_context.subscribe(destination, options, &consumer)
+    end
+
+    def dynamic_destination(dest_name, dest_options={}, message_props={})
+      current_adapter_context.create_destination(dest_name, dest_options, message_props)
+    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
+    end
+
+    def nack_message(message, options={})
+      ctx = current_adapter_context
+      if ctx.supports_client_acks?
+        ctx.nack_message(message, options)
+      else
+        logger.debug("this adapter does not support client acks")
+      end
+    end
+
+    def with_message_transaction(options={}, &block)
+      wrapper = fetch_context_wrapper
+      wrapper.increment_transaction_depth
+      begin
+        if wrapper.transaction_depth == 1 && wrapper.ctx.supports_transactions?
+          wrapper.ctx.begin_transaction(options)
+          begin
+            yield
+            wrapper.ctx.commit_transaction
+          rescue
+            begin
+              wrapper.ctx.rollback_transaction
+            rescue => e
+              logger.error exception_to_str(e)
+            end
+            raise
+          end
+        else
+          logger.debug("this adapter does not support transactions")
+          yield
+        end
+      ensure
+        wrapper.decrement_transaction_depth
+      end
+    end
+
+    def current_adapter_context(initialize=true)
+      ctx = fetch_context_wrapper(initialize)
+      ctx.nil? ? nil : ctx.ctx
+    end
+
+    def with_adapter_context(adapter_context, &block)
+      old_ctx, Thread.current[:adapter_context] = fetch_context_wrapper(false), build_context_wrapper(adapter_context)
+      begin
+        yield
+      ensure
+        set_context_wrapper(old_ctx)
+      end
+    end
+
+    def clear_context
+      wrapper = fetch_context_wrapper(false)
+      unless wrapper.nil?
+        wrapper.invalidate
+        set_context_wrapper(nil)
+      end
+    end
+
+    private
+
+    def fetch_context_wrapper(initialize=true)
+      wrapper = Thread.current[:adapter_context]
+      if wrapper.nil? || !wrapper.valid?
+        if initialize
+          wrapper = build_context_wrapper
+        else
+          wrapper = nil
+        end
+        Thread.current[:adapter_context] = wrapper
+      end
+      wrapper
+    end
+
+    def set_context_wrapper(wrapper)
+      Thread.current[:adapter_context] = wrapper
+    end
+
+    def build_context_wrapper(ctx=Broker.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)
+    end
+
+    def adapter
+      Broker.adapter
+    end
+
+    class ContextWrapper
+      extend Forwardable
+
+      def_delegators :@ctx, :valid?, :invalidate
+
+      attr_reader :ctx
+      attr_reader :transaction_depth
+
+      def initialize(ctx)
+        @ctx = ctx
+        @transaction_depth = 0
+      end
+
+      def increment_transaction_depth
+        @transaction_depth += 1
+      end
+
+      def decrement_transaction_depth
+        @transaction_depth -= 1
+      end
+    end
+  end
+
+end

data/lib/message_driver/destination.rb

@@ -8,24 +8,27 @@ module MessageDriver
         @name = name
         @dest_options = dest_options
         @message_props = message_props
-        after_initialize
       end
 
       def publish(body, headers={}, properties={})
-        @adapter.publish(@name, body, headers, @message_props.merge(properties))
+        Client.publish(self, body, headers, properties)
       end
 
       def pop_message(options={})
-        @adapter.pop_message(@name, options)
+        Client.pop_message(self, options)
       end
 
-      def after_initialize
+      def after_initialize(adapter_context)
         #does nothing, feel free to override as needed
       end
 
       def message_count
         raise "#message_count is not supported by #{self.class}"
       end
+
+      def subscribe(&consumer)
+        raise "#subscribe is not supported by #{self.class}"
+      end
     end
   end
 end

data/lib/message_driver/errors.rb

@@ -0,0 +1,27 @@
+vendor = File.expand_path('../vendor', __FILE__)
+$:.unshift(vendor) unless $:.include?(vendor)
+
+require 'nesty'
+
+module MessageDriver
+  class Error < StandardError; end
+  class TransactionError < Error; end
+  class TransactionRollbackOnly < TransactionError; end
+  class NoSuchDestinationError < Error; end
+  class NoSuchConsumerError < Error; end
+
+  class WrappedError < Error
+    include Nesty::NestedError
+  end
+  class QueueNotFound < WrappedError; end
+  class ConnectionError < WrappedError; end
+
+  module DontRequeue; end
+  class DontRequeueError < Error
+    include DontRequeue
+  end
+
+  class WrappedDontRequeueError < WrappedError
+    include DontRequeue
+  end
+end

data/lib/message_driver/logging.rb

@@ -0,0 +1,11 @@
+module MessageDriver
+  module Logging
+    def logger
+      MessageDriver::Broker.logger
+    end
+
+    def exception_to_str(e)
+      ([e.to_s] + e.backtrace).join("  \n")
+    end
+  end
+end

data/lib/message_driver/message.rb

@@ -8,6 +8,14 @@ module MessageDriver
         @headers = headers
         @properties = properties
       end
+
+      def ack(options={})
+        Client.ack_message(self, options)
+      end
+
+      def nack(options={})
+        Client.nack_message(self, options)
+      end
     end
   end
 end

data/lib/message_driver/subscription.rb

@@ -0,0 +1,18 @@
+module MessageDriver
+  module Subscription
+    class Base
+      attr_reader :adapter, :destination, :consumer, :options
+
+      def initialize(adapter, destination, consumer, options={})
+        @adapter = adapter
+        @destination = destination
+        @consumer = consumer
+        @options = options
+      end
+
+      def unsubscribe
+        raise "must be implemented in subclass"
+      end
+    end
+  end
+end

data/lib/message_driver/vendor/nesty/nested_error.rb

@@ -0,0 +1,26 @@
+module Nesty
+  module NestedError
+    attr_reader :nested, :raw_backtrace
+
+    def initialize(msg = nil, nested)
+      super(msg)
+      @nested = nested
+    end
+
+    def set_backtrace(backtrace)
+      @raw_backtrace = backtrace
+      if nested
+        backtrace = backtrace - nested_raw_backtrace
+        backtrace += ["#{nested.backtrace.first}: #{nested.message} (#{nested.class.name})"]
+        backtrace += nested.backtrace[1..-1] || []
+      end
+      super(backtrace)
+    end
+
+    private
+
+    def nested_raw_backtrace
+      nested.respond_to?(:raw_backtrace) ? nested.raw_backtrace : nested.backtrace
+    end
+  end
+end

data/lib/message_driver/vendor/nesty.rb

@@ -0,0 +1 @@
+require "nesty/nested_error"

data/lib/message_driver/version.rb

@@ -1,5 +1,5 @@
 module Message
   module Driver
-    VERSION = "0.1.0"
+    VERSION = "0.2.0.rc1"
   end
 end

data/lib/message_driver.rb

@@ -1,11 +1,13 @@
 require 'message_driver/version'
 
-require 'message_driver/exceptions'
+require 'message_driver/errors'
 require 'message_driver/broker'
+require 'message_driver/logging'
 require 'message_driver/message'
 require 'message_driver/destination'
+require 'message_driver/subscription'
 require 'message_driver/adapters/base'
-require 'message_driver/message_publisher'
+require 'message_driver/client'
 
 module MessageDriver
   def self.configure(options={})

data/message-driver.gemspec

@@ -7,10 +7,10 @@ Gem::Specification.new do |gem|
   gem.name          = "message-driver"
   gem.version       = Message::Driver::VERSION
   gem.authors       = ["Matt Campbell"]
-  gem.email         = ["matt@soupmatt.com"]
+  gem.email         = ["message-driver@soupmatt.com"]
   gem.description   = %q{Easy message queues for ruby using AMQ, STOMP and others}
   gem.summary       = %q{Easy message queues for ruby}
-  gem.homepage      = "https://github.com/soupmatt/message_driver"
+  gem.homepage      = "https://github.com/message-driver/message-driver"
   gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)
@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 1.9.2'
 
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec", "~> 2.13.0"
+  gem.add_development_dependency "rspec", "~> 2.14.0"
   gem.add_development_dependency "cucumber"
-  gem.add_development_dependency "bunny", "~> 0.9.0.pre7"
+  gem.add_development_dependency "aruba"
 end