cwyckoff-rosetta_queue 0.3.0 → 0.3.3

data/lib/rosetta_queue/adapters/beanstalk.rb

@@ -0,0 +1,56 @@
+require 'beanstalk-client'
+
+module RosettaQueue
+  module Gateway
+  
+    class BeanstalkAdapter < BaseAdapter
+
+      def ack(msg)
+        @conn.ack(msg.headers["message-id"])
+      end
+
+      def initialize(adapter_settings = {})
+        @host, @port = adapter_settings[:host], adapter_settings[:port]
+        @conn = Beanstalk::Pool.new(["#{@host}:#{@port}"])
+      end
+
+      def disconnect; end
+
+      # TODO: support options[:timeout] ?
+      def receive(options=nil)
+        msg = @conn.reserve
+        msg.delete
+        msg
+      end
+      
+      def receive_once(destination=nil, opts={})
+        receive.body
+      end
+
+      def receive_with(message_handler)
+        # Note that, while we call destination_for (to comply with
+        # Rosetta's generic specs), beanstalk doesn't actually support
+        # destinations. This is just for compatibility.
+        destination = destination_for(message_handler)
+
+        running do
+          msg = receive.body
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          message_handler.on_message(filter_receiving(msg))
+        end
+      end
+      
+      def send_message(destination, message, options)
+        RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")        
+        @conn.put(message)
+      end
+
+      private
+      
+        def running(&block)
+          loop(&block)
+        end
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/stomp.rb

@@ -6,11 +6,12 @@ module RosettaQueue
     class StompAdapter < BaseAdapter
 
       def ack(msg)
+        raise AdapterException, "Unable to ack client because message-id is blank.  Are your message handler options correct? (i.e., :ack => 'client')" if msg.headers["message-id"].nil?
         @conn.ack(msg.headers["message-id"])
       end
 
       def initialize(adapter_settings = {})
-        raise "Missing adapter settings" if adapter_settings.empty?
+        raise AdapterException, "Missing adapter settings" if adapter_settings.empty?
         @conn = Stomp::Connection.open(adapter_settings[:user], 
                                        adapter_settings[:password], 
                                        adapter_settings[:host], 
@@ -44,8 +45,10 @@ module RosettaQueue
 
         running do
           msg = receive(options).body
+          Thread.current[:processing] = true
           RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
           message_handler.on_message(filter_receiving(msg))
+          Thread.current[:processing] = false
         end
       end
       
@@ -69,5 +72,17 @@ module RosettaQueue
         end
 
     end
+
+    class StompAdapterProxy
+        
+      def initialize(adapter, msg)
+        @adapter, @msg = adapter, msg
+      end
+
+      def ack
+        @adapter.ack(@msg)
+      end 
+    end 
+
   end
 end

data/lib/rosetta_queue/consumer_managers/base.rb

@@ -5,7 +5,9 @@ module RosettaQueue
 
     class << self
       def create
-        yield self.new
+        manager = self.new
+        yield manager
+        manager
       end
     end
     

data/lib/rosetta_queue/consumer_managers/threaded.rb

@@ -6,6 +6,7 @@ module RosettaQueue
     def initialize
       @threads    = {}
       @running    = true
+      @processing = true
       super
     end
 
@@ -24,12 +25,24 @@ module RosettaQueue
     def join_threads
       @threads.each { |thread| thread.join }
     end
+    
+    def shutdown_requested
+      RosettaQueue.logger.error "Shutdown requested, starting to prune threads..."
+      
+      while @threads.any? { |n, t| t.alive? }
+        RosettaQueue.logger.info "Calling stop_threads"
+        stop_threads
+        sleep 5
+      end
+    end
 
     def monitor_threads
       while @running
-        trap("TERM", "EXIT")
+        trap("TERM") { shutdown_requested }
+        trap("INT")  { shutdown_requested }
         living = false
         @threads.each { |name, thread| living ||= thread.alive? }
+        @processing = @threads.any? { |name, thread| thread[:processing] }
         @running = living
         sleep 1
       end
@@ -64,11 +77,17 @@ module RosettaQueue
     end
 
     def stop_threads
+      RosettaQueue.logger.debug("Attempting to stop all threads...")
       @running = false
-      @threads.each do |key, thread|
-        RosettaQueue.logger.info("Stopping thread and disconnecting from #{key}...")
-        @consumers[key].disconnect
+      @threads.select { |key, thread| thread.alive? }.each do |key, thread|
+        if thread[:processing]
+          RosettaQueue.logger.debug("#{key} Skipping thread #{thread} because the consumer is processing")
+          @running = true
+          next
+        end
+        RosettaQueue.logger.debug("#{key} Stopping thread #{thread} and disconnecting the consumer")
         thread.kill
+        @consumers[key].disconnect
       end
     end
   end

data/lib/rosetta_queue/core_ext/string.rb

@@ -0,0 +1,22 @@
+# Taken from ActiveSupport
+class String
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self.first.downcase + camelize(self)[1..-1]
+    end
+  end
+  
+  def classify
+    camelize(self.sub(/.*\./, ''))
+  end
+  
+  def underscore
+    self.gsub(/::/, '/').
+         gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+         gsub(/([a-z\d])([A-Z])/,'\1_\2').
+         tr("-", "_").
+         downcase
+  end
+end

data/lib/rosetta_queue/core_ext/time.rb

@@ -0,0 +1,20 @@
+require 'time'
+
+class Time
+
+  DATE_FORMATS = {
+    :db           => "%Y-%m-%d %H:%M:%S",
+    :number       => "%Y%m%d%H%M%S",
+    :time         => "%H:%M",
+    :short        => "%d %b %H:%M",
+    :long         => "%B %d, %Y %H:%M",
+    :long_ordinal => lambda { |time| time.strftime("%B #{time.day.ordinalize}, %Y %H:%M") },
+    :rfc822       => lambda { |time| time.strftime("%a, %d %b %Y %H:%M:%S #{time.formatted_offset(false)}") }
+  }
+
+  def to_formatted_s(format = :default)
+    return to_default_s unless formatter = DATE_FORMATS[format]
+    formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+  end
+
+end 

data/lib/rosetta_queue/filters.rb

@@ -1,6 +1,6 @@
 # Example:
 # RosettaQueue::Filters.define do |filter_for|
-#   filter_for.receiving { |message| ActiveSupport::JSON.decode(message) }
+#   filter_for.receiving { |message| JSON.parse(message) }
 #   filter_for.sending { |hash| hash.to_json }
 # end
 

data/lib/rosetta_queue/logger.rb

@@ -19,7 +19,7 @@ module RosettaQueue
   class Logger < ::Logger
 
     def format_message(severity, timestamp, progname, msg)
-      "[#{timestamp.to_formatted_s(:db)}] #{severity} #{msg}\n"
+      "[#{timestamp.to_formatted_s(:db)}] #{severity} -- : #{msg}\n"
     end
 
   end

data/lib/rosetta_queue/message_handler.rb

@@ -20,6 +20,7 @@ module RosettaQueue
     
     def self.included(receiver)
       receiver.extend(ClassMethods)
+      attr_accessor :adapter_proxy
 
       def destination
         self.class.destination  
@@ -28,6 +29,11 @@ module RosettaQueue
       def options_hash
         self.class.options_hash
       end
+
+      def ack
+        adapter_proxy.ack unless adapter_proxy.nil?
+      end 
+
     end
   end
 end

data/spec/rosetta_queue/adapter_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module RosettaQueue
+  
+  describe Adapter do
+
+    before(:each) do
+      @stomp_adapter = mock("Gateway::StompAdapter")
+      Adapter.reset
+    end
+    
+    describe ".reset" do
+      it "should clear all definitions" do
+        Adapter.define { |a| a.type = "null"  }
+        Adapter.instance.should be_instance_of(RosettaQueue::Gateway::NullAdapter)
+        Adapter.reset
+        running { Adapter.instance }.should raise_error(AdapterException)
+      end
+    end
+    
+    describe ".type=" do
+      
+      it "should raise error when adapter does not exist" do
+        running { 
+          Adapter.define do |a|
+            a.type = "foo"
+          end
+          }.should raise_error(AdapterException)
+      end
+      
+    end
+    
+    describe "adapter not type set" do
+      it "should raise an error when .instance is called" do
+        # given
+        Adapter.define { |a|  }
+        # then & when
+        running { Adapter.instance }.should raise_error(AdapterException)        
+      end
+    end
+
+    describe "adapter type set" do
+    
+      before(:each) do
+        Adapter.define { |a| a.type = "null" }
+      end
+    
+      it "should return adapter instance" do
+        Adapter.instance.class.should == RosettaQueue::Gateway::NullAdapter
+      end
+          
+    end
+
+    describe "adapter instantiation" do
+
+      before(:each) do
+        Adapter.define do |a|
+          a.user = "foo"
+          a.password = "bar"
+          a.host = "localhost"
+          a.port = "9000"
+          a.type = "fake"
+        end
+      end 
+      
+      def do_process
+        Adapter.instance
+      end
+
+      it "should set opts as an empty has unless variable is set" do
+        during_process { 
+          RosettaQueue::Gateway::FakeAdapter.should_receive(:new).with({:user => "foo", :password => "bar", :host => "localhost", :port => "9000", :opts => {}})
+        }
+      end 
+
+      describe "when setting options" do
+        before(:each) do
+          Adapter.define { |a| a.options = {:vhost => "baz"} }
+        end 
+        
+        it "should map adapter_settings to a hash" do
+          during_process { 
+            RosettaQueue::Gateway::FakeAdapter.should_receive(:new).with({:user => "foo", :password => "bar", :host => "localhost", :port => "9000", :opts => {:vhost => "baz"}})
+          }
+        end 
+      end 
+
+      describe "setting options incorrectly (options should always be set as a Hash)" do
+        
+        before(:each) do
+          Adapter.define { |a| a.options = "baz" }
+        end 
+        
+        it "should raise an adapter exception" do
+          running { Adapter.instance }.should raise_error("Adapter options should be a hash")
+        end 
+      end 
+      
+    end 
+  end
+end

data/spec/rosetta_queue/adapters/amqp_synchronous_spec.rb

@@ -0,0 +1,278 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/shared_adapter_behavior'
+require File.dirname(__FILE__) + '/shared_fanout_behavior'
+
+begin
+  require 'rosetta_queue/adapters/amqp_synch'
+rescue LoadError => ex
+  if ex.message =~ /bunny/i
+    warn "--WARNING-- Skipping all of tha AmqpSynchAdapter code examples since bunny is not present. Install bunny if you need to be testing this adapter!"
+  else
+    raise ex
+  end
+end
+
+if defined? Bunny
+
+module RosettaQueue::Gateway
+
+  describe "an exchange", :shared => true do
+
+    describe "#do_exchange" do
+
+      it "should filter the message and forward it to the handler" do
+        when_receiving_exchange {
+          ::RosettaQueue::Filters.should_receive(:process_receiving).with(@msg).and_return("Filtered Message")
+          @handler.should_receive(:on_message).with("Filtered Message")
+        }
+      end
+    end
+  end
+
+  describe "AmqpSynch adapter and components" do
+
+    before(:each) do
+      RosettaQueue.logger.stub!(:info)
+      @msg = "Hello World!"
+      @adapter = AmqpSynchAdapter.new({:user => "foo", :password => "bar", :host => "localhost"})
+      @handler = mock("handler", :on_message => true, :destination => :foo, :options_hash => {:durable => true})
+    end
+
+    describe AmqpSynchAdapter do
+
+      before(:each) do
+        @exchange_strategy = mock('DirectExchange', :receive_once => @msg, :receive => @msg, :send_message => true)
+        SynchExchange::DirectExchange.stub!(:new).and_return(@exchange_strategy)
+      end
+
+      it_should_behave_like "an adapter"
+
+      describe "#receive_once" do
+
+        def do_receiving_once
+          @adapter.receive_once("queue.foo", {:durable => false})
+        end
+
+        it "should pass destination and options to exchange strategy" do
+          when_receiving_once {
+            @exchange_strategy.should_receive(:receive_once).with("queue.foo")
+          }
+        end
+
+      end
+
+      describe "#receive_with" do
+
+        def do_receiving_with_handler
+          @adapter.receive_with(@handler)
+        end
+
+        before(:each) do
+          @handler = mock("handler", :on_message => true, :destination => :foo, :options_hash => {:durable => true })
+        end
+
+        it "should pass message handler to exchange strategy" do
+          when_receiving_with_handler {
+            @exchange_strategy.should_receive(:receive).with("foo", @handler)
+          }
+        end
+
+      end
+
+      describe "#send_message" do
+
+        it "should pass message handler to exchange strategy" do
+          when_publishing {
+            @exchange_strategy.should_receive(:publish).with('queue', 'message')
+          }
+        end
+
+      end
+    end
+
+
+    describe SynchExchange::DirectExchange do
+
+      before(:each) do
+        @queue = mock("Bunny::Queue", :pop => @msg, :publish => true, :unsubscribe => true)
+        Bunny.stub!(:new).and_return(@conn = mock("Bunny::Client", :queue => @queue, :exchange => @exchange, :status => :connected, :stop => nil))
+        @queue.stub!(:subscribe).and_yield(@msg)
+        @handler = mock("handler", :on_message => true, :destination => :foo)
+        @exchange = SynchExchange::DirectExchange.new({:user => 'user', :password => 'pass', :host => 'host', :opts => {:vhost => "foo"}})
+      end
+
+
+      def do_receiving_exchange
+        @exchange.receive("queue.foo", @handler)
+      end
+
+      it_should_behave_like "an exchange"
+
+      describe "#receive_once" do
+
+        def do_receiving_single_exchange
+          @exchange.receive_once("queue.foo") { |msg| }
+
+        end
+
+        it "should return the message from the connection" do
+          @exchange.receive_once("queue.foo") do |msg|
+              msg.should == @msg
+          end
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_single_exchange {
+            @queue.should_receive(:pop)
+          }
+        end
+
+      end
+
+      describe "#receive" do
+
+        it "should subscribe to queue" do
+          when_receiving_exchange {
+            @queue.should_receive(:subscribe).and_yield(@msg)
+          }
+        end
+
+      end
+
+
+      describe "#publish" do
+
+        def do_publishing
+          @exchange.publish('queue.foo', 'message')
+        end
+
+        it "should instantiate queue" do
+          when_publishing {
+            @conn.should_receive(:queue).and_return(@queue)
+          }
+        end
+
+        it "should publish message to queue" do
+          when_publishing {
+            @conn.queue.should_receive(:publish).with("message", {})
+          }
+        end
+
+      end
+
+    end
+
+
+    describe SynchExchange::FanoutExchange do
+
+      before(:each) do
+        @exchange = SynchExchange::FanoutExchange.new({:user => 'user', :password => 'pass', :host => 'host', :opts => {:vhost => 'foo'}})
+        @queue = mock("Bunny::Queue", :pop => @msg, :bind => @bound_queue = mock("Bunny::Queue", :pop => @msg), :publish => true, :unbind => true)
+        Bunny.stub!(:new).and_return(@conn = mock("Bunny::Client", :queue => @queue, :exchange => @exchange, :status => :connected))
+        @queue.stub!(:subscribe).and_yield(@msg)
+        @handler = mock("handler", :on_message => true, :destination => :foo, :options => {:durable => false})
+      end
+
+      def do_receiving_exchange
+        @exchange.receive("topic.foo", @handler)
+      end
+
+      it_should_behave_like "an exchange"
+
+      describe "#receive_once" do
+
+        def do_receiving_exchange
+          @exchange.receive_once("topic.foo") { |msg| }
+        end
+
+        it_should_behave_like "a fanout exchange adapter"
+
+        it "should return the message from the connection" do
+          @exchange.receive_once("topic.foo") do |msg|
+            msg.should == @msg
+          end
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_exchange {
+            @queue.should_receive(:pop)
+          }
+        end
+
+        it "should unbind queue from exchange" do
+          pending
+          when_receiving_single_exchange {
+            @queue.should_receive(:unbind)
+          }
+        end
+
+      end
+
+      describe "#receive" do
+
+        it_should_behave_like "a fanout exchange adapter"
+
+        it "should forward the message body onto the handler" do
+          when_receiving_exchange {
+            @handler.should_receive(:on_message).with("Hello World!")
+          }
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_exchange {
+            @queue.should_receive(:subscribe).and_yield(@msg)
+          }
+        end
+
+      end
+
+      # describe "#publish_to_exchange" do
+      #
+      #   def do_publishing
+      #     @exchange.publish_to_exchange('/queue/foo', 'message', {:durable => false})
+      #   end
+      #
+      #   it "should instantiate queue" do
+      #     when_publishing {
+      #       @channel.should_receive(:queue).and_return(@queue)
+      #     }
+      #   end
+      #
+      #   it "should publish message to queue" do
+      #     when_publishing {
+      #       @channel.queue.should_receive(:publish).with('message')
+      #     }
+      #   end
+      #
+      #   it "should stop event loop" do
+      #     when_publishing {
+      #       EM.should_receive(:stop_event_loop)
+      #     }
+      #   end
+      # end
+
+#       describe SynchExchange::AmqpAdapterProxy do
+
+#         before(:each) do
+#           @queue = mock("Queue", :ack => nil)
+#           @proxy = SynchExchange::AmqpAdapterProxy.new(@queue)
+#         end
+
+#         context "#ack" do
+          
+#           it "should delegate to AMQP queue object" do
+#             # expect
+#             @queue.should_receive(:ack)
+
+#             # when
+#             @proxy.ack
+#           end
+          
+#         end
+#       end
+
+    end
+  end
+end
+
+end # for Guard up top to prevent this spec from running if Bunny not loaded from amqp_synch