message-driver 0.1.0

data/features/support/firewall_helper.rb

@@ -0,0 +1,59 @@
+module FirewallHelper
+
+  COMMANDS = {
+    darwin: {
+      setup: [
+        "sudo ipfw add 02070 deny tcp from any to any 5672"
+      ],
+      teardown: [
+        "sudo ipfw delete 02070"
+      ]
+    },
+    linux: {
+      setup: [
+        "sudo iptables -N block-rabbit",
+        "sudo iptables -A block-rabbit -p tcp --dport 5672 -j DROP",
+        "sudo iptables -A block-rabbit -p tcp --sport 5672 -j DROP",
+        "sudo iptables -I INPUT -j block-rabbit",
+        "sudo iptables -I OUTPUT -j block-rabbit"
+      ],
+      teardown: [
+        "sudo iptables -D INPUT -j block-rabbit",
+        "sudo iptables -D OUTPUT -j block-rabbit",
+        "sudo iptables -F block-rabbit",
+        "sudo iptables -X block-rabbit"
+      ]
+    }
+  }
+
+  def block_broker_port
+    run_commands(:setup)
+    @firewall_rule_set = true
+  end
+
+  def unblock_broker_port
+    run_commands(:teardown) if @firewall_rule_set
+    @firewall_rule_set = false
+  end
+
+  def run_commands(step)
+    COMMANDS[os][step].each do |cmd|
+      result = system(cmd)
+      raise "command `#{cmd}` failed!" unless result
+    end
+  end
+
+  def os
+    if darwin?
+      :darwin
+    else
+      :linux
+    end
+  end
+
+  def darwin?
+    system("uname | grep Darwin")
+  end
+end
+
+World(FirewallHelper)

data/features/support/message_table_matcher.rb

@@ -0,0 +1,11 @@
+RSpec::Matchers.define :match_message_table do |expected|
+  match do |messages|
+    actual = messages.collect do |msg|
+      expected.headers.inject({}) do |memo, obj|
+        memo[obj] = msg.send(obj)
+        memo
+      end
+    end
+    actual == expected.hashes
+  end
+end

data/features/support/no_error_matcher.rb

@@ -0,0 +1,13 @@
+RSpec::Matchers.define :have_no_errors do
+  match do |test_runner|
+    test_runner.raised_error == nil
+  end
+
+  failure_message_for_should do |test_runner|
+    err = test_runner.raised_error
+    filtered = (err.backtrace || []).reject do |line|
+      Cucumber::Ast::StepInvocation::BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
+    end
+    (["#{err.class}: #{err.to_s}"]+filtered).join("\n  ")
+  end
+end

data/features/support/test_runner.rb

@@ -0,0 +1,50 @@
+require 'message_driver'
+
+class TestRunner
+  include MessageDriver::MessagePublisher
+  include RSpec::Matchers
+
+  attr_accessor :raised_error
+
+  def config_broker(src)
+    instance_eval(src)
+  end
+
+  def run_test_code(src)
+    begin
+      instance_eval(src)
+    rescue Exception => e
+      @raised_error = e
+    end
+  end
+
+  def fetch_messages(destination)
+    case destination
+    when String, Symbol
+      fetch_messages(MessageDriver::Broker.find_destination(destination))
+    when MessageDriver::Destination::Base
+      result = []
+      begin
+        msg = destination.pop_message
+        result << msg unless msg.nil?
+      end until msg.nil?
+      result
+    else
+      raise "didn't understand destination #{destination}"
+    end
+  end
+
+  def publish_table_to_destination(destination, table)
+    table.hashes.each do |msg|
+      destination.publish(msg[:body], msg[:headers]||{}, msg[:properties]||{})
+    end
+  end
+end
+
+module KnowsMyTestRunner
+  def test_runner
+    @test_runner ||= TestRunner.new
+  end
+end
+
+World(KnowsMyTestRunner)

data/features/support/transforms.rb

@@ -0,0 +1,17 @@
+NUMBER = Transform(/^\d+|no$/) do |num|
+  case num
+  when "no"
+    0
+  else
+    num.to_i
+  end
+end
+
+STRING_OR_SYM = Transform(/^:?\w+$/) do |str|
+  case str
+  when /^:/
+    str.slice(1, str.length-1).to_sym
+  else
+    str
+  end
+end

data/lib/message-driver.rb

@@ -0,0 +1 @@
+require "message_driver"

data/lib/message_driver/adapters/base.rb

@@ -0,0 +1,29 @@
+module MessageDriver
+  module Adapters
+    class Base
+      def initialize(configuration)
+        raise "Must be implemented in subclass"
+      end
+
+      def publish(destination, body, headers={}, properties={})
+        raise "Must be implemented in subclass"
+      end
+
+      def pop_message(destination, options={})
+        raise "Must be implemented in subclass"
+      end
+
+      def stop
+        raise "Must be implemented in subclass"
+      end
+
+      def create_destination(name, dest_options={}, message_props={})
+        raise "Must be implemented in subclass"
+      end
+
+      def with_transaction(options={}, &block)
+        yield
+      end
+    end
+  end
+end

data/lib/message_driver/adapters/bunny_adapter.rb

@@ -0,0 +1,270 @@
+require 'bunny'
+
+module MessageDriver
+  class Broker
+    def bunny_adapter
+      MessageDriver::Adapters::BunnyAdapter
+    end
+  end
+
+  module Adapters
+    class BunnyAdapter < Base
+
+      class Message < MessageDriver::Message::Base
+        attr_reader :delivery_info
+
+        def initialize(delivery_info, properties, payload)
+          super(payload, properties[:headers]||{}, properties)
+          @delivery_info = delivery_info
+        end
+      end
+
+      class Destination < MessageDriver::Destination::Base
+        def publish(body, headers={}, properties={})
+          props = @message_props.merge(properties)
+          props[:headers] = headers if headers
+          @adapter.publish(body, exchange_name, routing_key(properties), props)
+        end
+
+        def exchange_name
+          @name
+        end
+
+        def routing_key(properties)
+          properties[:routing_key]
+        end
+      end
+
+      class QueueDestination < Destination
+        def after_initialize
+          unless @dest_options[:no_declare]
+            @adapter.current_context.with_channel(false) do |ch|
+              queue = ch.queue(@name, @dest_options)
+              @name = queue.name
+              if bindings = @dest_options[:bindings]
+                bindings.each do |bnd|
+                  raise MessageDriver::Exception, "binding #{bnd.inspect} must provide a source!" unless bnd[:source]
+                  queue.bind(bnd[:source], bnd[:args]||{})
+                end
+              end
+            end
+          else
+            raise MessageDriver::Exception, "server-named queues must be declared, but you provided :no_declare => true" if @name.empty?
+            raise MessageDriver::Exception, "queues with bindings must be declared, but you provided :no_declare => true" if @dest_options[:bindings]
+          end
+        end
+
+        def exchange_name
+          ""
+        end
+
+        def routing_key(properties)
+          @name
+        end
+
+        def message_count
+          @adapter.current_context.with_channel(false) do |ch|
+            ch.queue(@name, @dest_options.merge(passive: true)).message_count
+          end
+        end
+      end
+
+      class ExchangeDestination < Destination
+        def pop_message(destination, options={})
+          raise MessageDriver::Exception, "You can't pop a message off an exchange"
+        end
+
+        def after_initialize
+          if declare = @dest_options[:declare]
+            @adapter.current_context.with_channel(false) do |ch|
+              type = declare.delete(:type)
+              raise MessageDriver::Exception, "you must provide a valid exchange type" unless type
+              ch.exchange_declare(@name, type, declare)
+            end
+          end
+          if bindings = @dest_options[:bindings]
+            @adapter.current_context.with_channel(false) do |ch|
+              bindings.each do |bnd|
+                raise MessageDriver::Exception, "binding #{bnd.inspect} must provide a source!" unless bnd[:source]
+                ch.exchange_bind(bnd[:source], @name, bnd[:args]||{})
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(config)
+        validate_bunny_version
+
+        @connection = Bunny.new(config.merge(threaded: false))
+      end
+
+      def connection(ensure_started=true)
+        if ensure_started && !@connection.open?
+          @connection.start
+        end
+        @connection
+      end
+
+      def publish(body, exchange, routing_key, properties)
+        current_context.with_channel(true) do |ch|
+          ch.basic_publish(body, exchange, routing_key, properties)
+        end
+      end
+
+      def pop_message(destination, options={})
+        current_context.with_channel do |ch|
+          queue = ch.queue(destination, passive: true)
+
+          message = queue.pop
+          if message.nil? || message[0].nil?
+            nil
+          else
+            Message.new(*message)
+          end
+        end
+      end
+
+      def create_destination(name, dest_options={}, message_props={})
+        case type = dest_options.delete(:type)
+        when :exchange
+          ExchangeDestination.new(self, name, dest_options, message_props)
+        when :queue, nil
+          QueueDestination.new(self, name, dest_options, message_props)
+        else
+          raise MessageDriver::Exception, "invalid destination type #{type}"
+        end
+      end
+
+      def with_transaction(options={}, &block)
+        current_context.with_transaction(&block)
+      end
+
+      def stop
+        @connection.close if @connection.open?
+        @context = nil
+      end
+
+      def current_context
+        if !@context.nil? && @context.need_new_context?
+          @context = nil
+        end
+        @context ||= ChannelContext.new(connection)
+      end
+
+      private
+
+      class ChannelContext
+        attr_reader :connection, :transaction_depth
+
+        def initialize(connection)
+          @connection = connection
+          @channel = connection.create_channel
+          @transaction_depth = 0
+          @is_transactional = false
+          @rollback_only = false
+          @need_channel_reset = false
+          @connection_failed = false
+        end
+
+        def is_transactional?
+          @is_transactional
+        end
+
+        def connection_failed?
+          @connection_failed
+        end
+
+        def with_transaction(&block)
+          if !is_transactional?
+            @channel.tx_select
+            @is_transactional = true
+          end
+
+          begin
+            @transaction_depth += 1
+            yield
+            commit_transaction
+          rescue
+            rollback_transaction
+            raise
+          ensure
+            @transaction_depth -= 1
+          end
+        end
+
+        def with_channel(require_commit=true)
+          raise MessageDriver::TransactionRollbackOnly if @rollback_only
+          raise MessageDriver::Exception, "oh shit!" if @connection_failed
+          reset_channel if @need_channel_reset
+          begin
+            result = yield @channel
+            commit_transaction(true) if require_commit
+            result
+          rescue Bunny::ChannelLevelException => e
+            @need_channel_reset = true
+            @rollback_only = true if is_transactional?
+            if e.kind_of? Bunny::NotFound
+              raise MessageDriver::QueueNotFound.new(e)
+            else
+              raise MessageDriver::WrappedException.new(e)
+            end
+          rescue Bunny::NetworkErrorWrapper, IOError => e
+            @connection_failed = true
+            @rollback_only = true if is_transactional?
+            raise MessageDriver::ConnectionException.new(e)
+          end
+        end
+
+        def within_transaction?
+          @transaction_depth > 0
+        end
+
+        def need_new_context?
+          if is_transactional?
+            !within_transaction? && connection_failed?
+          else
+            connection_failed?
+          end
+        end
+
+        private
+
+        def reset_channel
+          unless @channel.open?
+            @channel.open
+            @is_transactional = false
+          end
+          @need_channel_reset = false
+        end
+
+        def commit_transaction(from_channel=false)
+          threshold = from_channel ? 0 : 1
+          if is_transactional? && @transaction_depth <= threshold && !connection_failed?
+            unless @need_channel_reset
+              unless @rollback_only
+                @channel.tx_commit
+              else
+                @channel.tx_rollback
+              end
+            end
+            @rollback_only = false
+          end
+        end
+
+        def rollback_transaction
+          @rollback_only = true
+          commit_transaction
+        end
+      end
+
+      def validate_bunny_version
+        required = Gem::Requirement.create('~> 0.9.0.pre7')
+        current = Gem::Version.create(Bunny::VERSION)
+        unless required.satisfied_by? current
+          raise MessageDriver::Exception, "bunny 0.9.0.pre7 or later is required for the bunny adapter"
+        end
+      end
+    end
+  end
+end

data/lib/message_driver/adapters/in_memory_adapter.rb

@@ -0,0 +1,58 @@
+module MessageDriver
+  class Broker
+    def in_memory_adapter
+      MessageDriver::Adapters::InMemoryAdapter
+    end
+  end
+
+  module Adapters
+    class InMemoryAdapter < Base
+
+      class Message < MessageDriver::Message::Base
+
+      end
+
+      class Destination < MessageDriver::Destination::Base
+        def initialize(adapter, name, dest_options, message_props, message_store)
+          super(adapter, name, dest_options, message_props)
+          @message_store = message_store
+        end
+        def message_count
+          @message_store[@name].size
+        end
+      end
+
+      def initialize(config={})
+        #does nothing
+      end
+
+      def publish(destination, body, headers={}, properties={})
+        message_store[destination] << Message.new(body, headers, properties)
+      end
+
+      def pop_message(destination, options={})
+        message_store[destination].shift
+      end
+
+      def stop
+        message_store.clear
+      end
+
+      def create_destination(name, dest_options={}, message_props={})
+        Destination.new(self, name, dest_options, message_props, message_store)
+      end
+
+      def reset_after_tests
+        message_store.each do |destination, message_array|
+          message_array.replace([])
+        end
+      end
+
+      private
+
+      def message_store
+        @message_store ||= Hash.new { |h,k| h[k] = [] }
+      end
+    end
+  end
+end

data/lib/message_driver/broker.rb

@@ -0,0 +1,95 @@
+require 'forwardable'
+
+module MessageDriver
+  class Broker
+    extend Forwardable
+
+    attr_reader :adapter, :configuration, :destinations
+
+    def_delegators :@adapter, :stop
+
+    class << self
+      def configure(options)
+        @instance = new(options)
+      end
+
+      def method_missing(m, *args)
+        @instance.send(m, *args)
+      end
+
+      def with_transaction(options={}, &block)
+        @instance.with_transaction(options, &block)
+      end
+
+      def instance
+        @instance
+      end
+
+      def define
+        yield @instance
+      end
+    end
+
+    def initialize(options)
+      @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)
+    end
+
+    def dynamic_destination(dest_name, dest_options={}, message_props={})
+      adapter.create_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)
+      @destinations[key] = dest
+    end
+
+    def with_transaction(options={}, &block)
+      adapter.with_transaction(options, &block)
+    end
+
+    private
+
+    def find_destination(destination)
+      @destinations[destination]
+    end
+
+    def resolve_adapter(adapter, options)
+      case adapter
+      when nil
+        raise "you must specify an adapter"
+      when Symbol, String
+        resolve_adapter(find_adapter_class(adapter), options)
+      when Class
+        resolve_adapter(adapter.new(options), options)
+      when MessageDriver::Adapters::Base
+        adapter
+      else
+        raise "adapter must be a MessageDriver::Adapters::Base, but this object is a #{adapter.class}"
+      end
+    end
+
+    def find_adapter_class(adapter_name)
+      require "message_driver/adapters/#{adapter_name}_adapter"
+
+      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"
+      end
+
+      send(adapter_method)
+    end
+  end
+end

data/lib/message_driver/destination.rb

@@ -0,0 +1,31 @@
+module MessageDriver
+  module Destination
+    class Base
+      attr_reader :adapter, :name, :dest_options, :message_props
+
+      def initialize(adapter, name, dest_options, message_props)
+        @adapter = adapter
+        @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))
+      end
+
+      def pop_message(options={})
+        @adapter.pop_message(@name, options)
+      end
+
+      def after_initialize
+        #does nothing, feel free to override as needed
+      end
+
+      def message_count
+        raise "#message_count is not supported by #{self.class}"
+      end
+    end
+  end
+end

data/lib/message_driver/exceptions.rb

@@ -0,0 +1,18 @@
+module MessageDriver
+  class Exception < ::Exception; end
+
+  class WrappedException < Exception
+    attr_reader :other
+
+    def initialize(other, msg=nil)
+      super(msg || other.to_s)
+      @other = other
+    end
+  end
+
+  class QueueNotFound < WrappedException; end
+
+  class ConnectionException < WrappedException; end
+
+  class TransactionRollbackOnly < Exception; end
+end

data/lib/message_driver/message.rb

@@ -0,0 +1,13 @@
+module MessageDriver
+  module Message
+    class Base
+      attr_reader :body, :headers, :properties
+
+      def initialize(body, headers, properties)
+        @body = body
+        @headers = headers
+        @properties = properties
+      end
+    end
+  end
+end

data/lib/message_driver/message_publisher.rb

@@ -0,0 +1,15 @@
+module MessageDriver
+  module MessagePublisher
+    def publish(destination, body, headers={}, properties={})
+      Broker.publish(destination, body, headers, properties)
+    end
+
+    def pop_message(destination, options={})
+      Broker.pop_message(destination, options)
+    end
+
+    def with_message_transaction(options={}, &block)
+      Broker.with_transaction(options, &block)
+    end
+  end
+end

data/lib/message_driver/version.rb

@@ -0,0 +1,5 @@
+module Message
+  module Driver
+    VERSION = "0.1.0"
+  end
+end