cwyckoff-rosetta_queue 0.3.0 → 0.3.3

data/features/step_definitions/filtering_steps.rb

@@ -0,0 +1,17 @@
+Then /^a (receiving|sending) filter is defined to prepend 'Foo' to all messages$/ do |filter_type|
+  RosettaQueue::Filters.reset
+  RosettaQueue::Filters.define do |f|
+    f.send(filter_type) { |message| "Foo #{message}" }
+  end
+end
+
+When /^the message on '(.+)' is consumed$/ do |queue_name|
+  # TODO
+  # @consumed_message = queue(:foo_queue).pop  
+  @consumed_message = consume_once(queue_name.to_sym)
+end
+
+Then /^the consumed message should equal "(.+)"$/ do |consumed_message|
+  @consumed_message.should == consumed_message
+end
+

data/features/step_definitions/point_to_point_steps.rb

@@ -0,0 +1,22 @@
+Given /^a consumer is listening to queue '(.*)'$/ do |queue|
+  klass = eval_consumer_class(queue)
+  @thread = Thread.new do
+    cons = klass.new
+    case @adapter_type
+    when /evented/
+      EM.run do
+        RosettaQueue::Consumer.new(cons).receive
+      end 
+    else
+      RosettaQueue::Consumer.new(cons).receive
+    end 
+  end 
+end
+
+Then /^the message should be consumed from '(.*)'$/ do |queue|
+  sleep 1
+  file_path = "#{CONSUMER_LOG_DIR}/point-to-point.log"
+#  sleep 1 unless File.exists?(file_path)
+  File.readlines(file_path).last.should =~ /Hello World! from #{queue.capitalize}Consumer/
+  @thread.kill
+end

data/features/step_definitions/publish_subscribe_steps.rb

@@ -0,0 +1,25 @@
+Given /^multiple consumers are listening to queue '(.*)'$/ do |queue|
+  @managers = []
+  Thread.new do
+    @managers << RosettaQueue::ThreadedManager.create do |m|
+      m.add(eval_consumer_class(queue, "fooconsumer.log", "FooConsumer").new)
+      m.start
+    end 
+  end 
+
+  Thread.new do
+    @managers << RosettaQueue::ThreadedManager.create do |m|
+      m.add(eval_consumer_class(queue, "barconsumer.log", "BarConsumer").new)
+      m.start
+    end 
+  end 
+  sleep 5
+end
+
+Then /^multiple messages should be consumed from '(\w+)'$/ do |queue|
+  ["FooConsumer", "BarConsumer"].each do |class_name, value|
+     file_path = "#{CONSUMER_LOG_DIR}/#{class_name.downcase}.log"
+     File.readlines(file_path).last.should =~ /Hello World! from #{class_name}/
+  end 
+  @managers.each {|m| m.stop_threads }
+end

data/features/support/env.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'rosetta_queue'
+require 'rosetta_queue/spec_helpers'
+require 'spec/expectations'
+require 'rosetta_queue/spec_helpers'
+
+CONSUMER_LOG_DIR = File.expand_path(File.dirname(__FILE__) + "/../support/tmp")
+
+begin
+  RosettaQueue.logger = RosettaQueue::Logger.new(File.join(File.dirname(__FILE__), '../../../log', 'rosetta_queue.log'))
+rescue Errno::ENOENT
+  Kernel.warn "No log directory setup at the root of rosetta_queue. Using the null logger instead."
+  class NullLogger
+    def info(*args);  end
+    def debug(*args); end
+    def fatal(*args); end
+    def error(*args); end
+    def warn(*args);  end
+  end
+
+  RosettaQueue.logger = NullLogger.new
+end
+
+World(RosettaQueue::SpecHelpers)

data/features/support/sample_consumers.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/env.rb')
+
+class SampleConsumer
+  include ::RosettaQueue::MessageHandler
+  subscribes_to :foo
+  options :durable => true
+  
+  attr_reader :msg
+  
+  def on_message(msg)
+    @msg = msg
+    puts "MESSAGE #{msg}"
+  end
+  
+end
+
+
+class SampleConsumerTwo
+  include ::RosettaQueue::MessageHandler
+  subscribes_to :foo
+  options :durable => true
+  
+  attr_reader :msg
+  
+  def on_message(msg)
+    @msg = msg
+  end
+  
+end

data/lib/rosetta_queue.rb

@@ -1,7 +1,8 @@
-require 'activesupport' # TODO: remove dependency
-
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 
+require('rosetta_queue/core_ext/string') unless defined? ActiveSupport
+require('rosetta_queue/core_ext/time') unless defined? ActiveSupport
+
 require 'rosetta_queue/adapter'
 require 'rosetta_queue/base'
 require 'rosetta_queue/consumer'

data/lib/rosetta_queue/adapter.rb

@@ -18,7 +18,7 @@ module RosettaQueue
         require "rosetta_queue/adapters/#{adapter_prefix}"
         @adapter_class = RosettaQueue::Gateway.const_get("#{adapter_prefix.to_s.classify}Adapter")
 
-        rescue MissingSourceFile
+        rescue LoadError
           raise AdapterException, "Adapter type '#{adapter_prefix}' does not match existing adapters!"
       end
 

data/lib/rosetta_queue/adapters/amqp.rb

@@ -0,0 +1,48 @@
+module RosettaQueue
+  module Gateway
+
+    module Fanout
+      def fanout_name_for(destination)
+        fanout_name = destination.gsub(/(topic|fanout)\/(.*)/, '\2')
+        raise AdapterException, "Unable to discover fanout exchange. Cannot bind queue to exchange!" unless fanout_name
+        fanout_name
+      end
+    end 
+
+    class Amqp < BaseAdapter
+
+      def initialize(adapter_settings = {})
+        raise AdapterException, "Missing adapter settings" if adapter_settings.empty?
+        @adapter_settings = adapter_settings
+      end
+
+      def delete(destination, opts={})
+        exchange_strategy_for(destination, opts).delete(destination)
+      end 
+
+      def disconnect(message_handler)
+        destination = destination_for(message_handler)
+        exchange_strategy_for(destination).unsubscribe
+      end
+
+      def receive_once(destination, opts={})
+        exchange_strategy_for(destination, opts).receive_once(destination) do |msg|
+          return msg
+        end
+      end
+
+      def receive_with(message_handler)
+        options = options_for(message_handler)
+        destination = destination_for(message_handler)
+        exchange_strategy_for(destination, options).receive(destination, message_handler)
+      end
+
+      def send_message(destination, message, options=nil)
+        exchange_strategy_for(destination, options).publish(destination, message)
+      end
+
+      def unsubscribe; end
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/amqp_evented.rb

@@ -0,0 +1,132 @@
+require 'eventmachine'
+require 'mq'
+require File.expand_path(File.dirname(__FILE__) + "/amqp.rb")
+
+module RosettaQueue
+  module Gateway
+ 
+    class AmqpEventedAdapter < Amqp
+      private
+
+      def exchange_strategy_for(destination, options)
+        case destination
+        when /^fanout\./
+          @exchange ||= EventedExchange::FanoutExchange.new(@adapter_settings, options)
+        when /^topic\./
+          raise "Sorry.  RosettaQueue can not process AMQP topics yet"
+        when /^queue\./
+          @exchange ||= EventedExchange::DirectExchange.new(@adapter_settings, options)
+        else
+          @exchange ||= EventedExchange::DirectExchange.new(@adapter_settings, options)
+        end
+      end
+    end
+ 
+    module EventedExchange
+
+      class BaseExchange
+        
+        def initialize(adapter_settings, options={})
+          @adapter_settings, @options = adapter_settings, options
+        end
+
+        def delete(destination)
+          conn.queue(destination).delete(@options)
+        end 
+
+        protected
+        
+        def channel
+          @channel ||=  MQ.new(conn)
+        end
+        
+        def conn
+          vhost = @adapter_settings[:opts][:vhost] || "/" 
+          @conn ||= AMQP.connect(:user => @adapter_settings[:user], 
+                                 :pass => @adapter_settings[:password], 
+                                 :host => @adapter_settings[:host], 
+                                 :vhost => vhost)
+        end
+      end
+      
+      
+      class DirectExchange < BaseExchange
+
+        def publish(destination, message, options={})
+          raise AdapterException, "Messages need to be published in an EventMachine run block (e.g., EM.run { RosettaQueue::Producer.publish(:foo, msg) } " unless EM.reactor_running?
+
+          queue = channel.queue(destination, options)
+          queue.publish(message, options)
+          RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
+          queue.unsubscribe
+        end
+        
+        def receive(destination, message_handler)
+          raise AdapterException, "Consumers need to run in an EventMachine 'run' block.  Try wrapping them inside the evented consumer manager." unless EM.reactor_running?
+
+          queue = channel.queue(destination, @options)
+          ack = @options[:ack]
+          queue.subscribe(@options) do |header, msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+            header.ack if ack
+          end
+        end
+
+        def receive_once(destination, options={})
+          raise AdapterException, "Consumers need to run in an EventMachine 'run' block. (e.g., EM.run { RosettaQueue::Consumer.receive }" unless EM.reactor_running?
+          
+          queue = channel.queue(destination, @options)
+          ack = @options[:ack]
+          queue.pop(@options) do |header, msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            header.ack if ack
+            yield Filters.process_receiving(msg)
+          end
+        end
+      end
+      
+      
+      class FanoutExchange < BaseExchange
+        include Fanout
+
+        def publish(dest, msg, opts)
+          raise AdapterException, "Messages need to be published in an EventMachine run block (e.g., EM.run { RosettaQueue::Producer.publish(:foo, msg) } " unless EM.reactor_running?
+
+          exchange = channel.fanout(fanout_name_for(dest), opts)
+          exchange.publish(msg, opts)
+          RosettaQueue.logger.info("Publishing to fanout #{dest} :: #{msg}")
+        end
+        
+        def receive(destination, message_handler)
+          raise AdapterException, "Consumers need to run in an EventMachine 'run' block.  Try wrapping them inside the evented consumer manager." unless EM.reactor_running?
+
+          queue = channel.queue("queue_#{self.object_id}")
+          exchange = channel.fanout(fanout_name_for(destination), @options)
+          ack = @options[:ack]
+          
+          queue.bind(exchange).subscribe(@options) do |header, msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+            header.ack if ack
+          end
+        end
+        
+        def receive_once(destination, opts={})
+          raise AdapterException, "Consumers need to run in an EventMachine 'run' block. (e.g., EM.run { RosettaQueue::Consumer.receive }" unless EM.reactor_running?
+
+          queue = channel.queue("queue_#{self.object_id}")
+          exchange = channel.fanout(fanout_name_for(destination), opts)
+          ack = @options[:ack]
+          
+          queue.bind(exchange).pop(opts) do |header, msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            header.ack if ack
+            yield Filters.process_receiving(msg)
+          end
+        end
+        
+      end
+    end
+  end 
+end

data/lib/rosetta_queue/adapters/amqp_synch.rb

@@ -1,59 +1,29 @@
 require 'bunny'
+require File.expand_path(File.dirname(__FILE__) + "/amqp.rb")
 
 module RosettaQueue
   module Gateway
 
     # This AMQP adapter utilizes the synchronous AMPQ client 'Bunny'
     # by celldee (http://github.com/celldee/bunny)
-    class AmqpSynchAdapter < BaseAdapter
-
-      def initialize(adapter_settings = {})
-        raise AdapterException, "Missing adapter settings" if adapter_settings.empty?
-        @adapter_settings = adapter_settings
-      end
-
-      def delete(destination, opts={})
-        exchange_strategy_for(destination, opts).delete(destination)
-      end 
-
-      def disconnect(message_handler); end
-
-      def receive_once(destination, opts={})
-        exchange_strategy_for(destination, opts).receive_once(destination) do |msg|
-          return msg
-        end
-      end
-
-      def receive_with(message_handler)
-        options = options_for(message_handler)
-        destination = destination_for(message_handler)
-        exchange_strategy_for(destination, options).receive(destination, message_handler)
-      end
-
-      def send_message(destination, message, options=nil)
-        exchange_strategy_for(destination, options).publish(destination, message)
-      end
-
-      def unsubscribe; end
-
+    class AmqpSynchAdapter < Amqp
       private
 
-      def exchange_strategy_for(destination, options)
+      def exchange_strategy_for(destination, options={})
         case destination
         when /^fanout\./
-          @exchange ||= AmqpExchangeStrategies::FanoutExchange.new(@adapter_settings, options)
+          @exchange ||= SynchExchange::FanoutExchange.new(@adapter_settings, options)
         when /^topic\./
           raise "Sorry.  RosettaQueue can not process AMQP topics yet"
         when /^queue\./
-          @exchange ||= AmqpExchangeStrategies::DirectExchange.new(@adapter_settings, options)
+          @exchange ||= SynchExchange::DirectExchange.new(@adapter_settings, options)
         else
-          @exchange ||= AmqpExchangeStrategies::DirectExchange.new(@adapter_settings, options)
+          @exchange ||= SynchExchange::DirectExchange.new(@adapter_settings, options)
         end
       end
-
     end 
 
-    module AmqpExchangeStrategies
+    module SynchExchange
 
       class BaseExchange
 
@@ -61,10 +31,15 @@ module RosettaQueue
           @adapter_settings, @options = adapter_settings, options
         end
 
-        def delete(destination)
-          conn.queue(destination).delete(@options)
+        def delete(destination, options={})
+          conn.queue(destination).delete(options)
         end 
 
+        def unsubscribe
+          @queue.unsubscribe
+          conn.stop
+        end
+
         protected
 
         def conn
@@ -76,69 +51,73 @@ module RosettaQueue
           @conn.start unless @conn.status == :connected
           @conn
         end
+
       end
 
       class DirectExchange < BaseExchange
 
         def publish(destination, message, options={})
           RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
-          conn.queue(destination, options).publish(message, options)
+          queue = conn.queue(destination, options)
+          queue.publish(message, options)
+          conn.stop
         end      
 
         def receive(destination, message_handler)
-          queue = conn.queue(destination, @options)
           ack = @options[:ack]
-          queue.subscribe(@options) do |msg|
+          @queue = conn.queue(destination, @options)
+          @queue.subscribe(@options) do |msg|
             RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
             message_handler.on_message(Filters.process_receiving(msg))
-            queue.ack if ack
+            @queue.ack if ack
           end 
         end
 
-        def receive_once(destination, options={})
-          q = conn.queue(destination, @options)
-          ack = @options[:ack]
-          msg = q.pop(options)
+        def receive_once(destination, options = {})
+          ack = options[:ack]
+          @queue = conn.queue(destination, options)
+          msg = @queue.pop(options)
           RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-          q.ack if ack
+          @queue.ack if ack
           yield Filters.process_receiving(msg)
         end
+
       end
 
       class FanoutExchange < BaseExchange
+        include Fanout
         
-        def fanout_name_for(destination)
-          fanout_name = destination.gsub(/fanout\/(.*)/, '\1')
-          raise "Unable to discover fanout exchange.  Cannot bind queue to exchange!" unless fanout_name
-          fanout_name
-        end
-
-        def receive_once(destination, options={})
-          queue = conn.queue("queue_#{self.object_id}", options)
-          exchange = conn.fanout(fanout_name_for(destination), options)
-
-          msg = queue.bind(exchange).pop(@options)
-          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-          yield Filters.process_receiving(msg)
-        end
-
         def publish(destination, message, options={})
-          exchange = conn.fanout(fanout_name_for(destination), options)
+          exchange = conn.exchange(fanout_name_for(destination), options.merge({:type => :fanout}))
           exchange.publish(message, options)
           RosettaQueue.logger.info("Publishing to fanout #{destination} :: #{message}")
         end      
 
         def receive(destination, message_handler)
-          queue = conn.queue("queue_#{self.object_id}", @options)
-          exchange = conn.fanout(fanout_name_for(destination), @options)
-
-          msg = queue.bind(exchange).subscribe(@options) do |msg|
-
+          ack = @options[:ack]
+          @queue = conn.queue("queue_#{self.object_id}", @options)
+          exchange = conn.exchange(fanout_name_for(destination), @options.merge({:type => :fanout}))
+          @queue.bind(exchange)
+          @queue.subscribe(@options) do |msg|
             RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
             message_handler.on_message(Filters.process_receiving(msg))
+            @queue.ack if ack
           end        
         end
+
+        def receive_once(destination, options={})
+          ack = options[:ack]
+          @queue = conn.queue("queue_#{self.object_id}", options)
+          exchange = conn.exchange(fanout_name_for(destination), options.merge({:type => :fanout}))
+          @queue.bind(exchange)
+          msg = @queue.pop(options)
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          @queue.ack if ack
+          yield Filters.process_receiving(msg)
+        end
+
       end 
+
     end 
   end
 end