bmabey-rosetta_queue 0.1.3 → 0.2.0

data/lib/rosetta_queue/adapters/amqp.rb

@@ -1,166 +1,45 @@
-require 'mq'
-
-# AMQP
-# connections:
-# - unlike stomp, we can share one connection across multiple channels
-# - set host and authorization options on AMQP.connect
-# 
-# MQ
-# create new channel for an AMQP connection
-# options for queue and exchange objects include:
-# - :durable => true
-# - :ack => "client" ????
-
 module RosettaQueue
   module Gateway
 
-    class AmqpAdapter < BaseAdapter
+    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(user, pass, host, port=nil)
-        @user, @pass, @host, @port = user, pass, host, port
+      def initialize(adapter_settings = {})
+        raise AdapterException, "Missing adapter settings" if adapter_settings.empty?
+        @adapter_settings = adapter_settings
       end
 
-      def disconnect; 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).do_single_exchange(destination, opts) do |msg|
+        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).do_exchange(destination, message_handler)
+        exchange_strategy_for(destination, options).receive(destination, message_handler)
       end
 
       def send_message(destination, message, options=nil)
-        exchange_strategy_for(destination).publish_to_exchange(destination, message, options)
+        exchange_strategy_for(destination, options).publish(destination, message)
       end
 
       def unsubscribe; end
-        
-        def exchange_strategy_for(destination)
-          case destination
-          when /(topic|fanout)/
-            @exchange ||= FanoutExchange.new(@user, @pass, @host)
-          when /queue/
-            @exchange ||= DirectExchange.new(@user, @pass, @host)
-          else
-            @exchange ||= DirectExchange.new(@user, @pass, @host)
-          end
-        end
-    end
-
-
-    class BaseExchange
-
-      def initialize(user, pass, host)
-        @user, @pass, @host = user, pass, host
-      end
-
-      def publish_to_exchange(destination, message, options={})
-        unless EM.reactor_running?
-          EM.run do
-            publish_message(destination, message, options)
-            EM.add_timer(1) { EM.stop_event_loop }
-          end
-        else
-          publish_message(destination, message, options)
-        end
-      end      
-
-      protected
-
-        def channel
-          @channel ||= MQ.new(conn)
-        end
-
-        def conn
-          # AmqpConnect.connection(@user, @pass, @host)
-          @conn ||= AMQP.connect(:user => @user, :pass => @pass, :host => @host)
-        end
-        
-        def publish_message(dest, msg, opts)
-          RosettaQueue.logger.info("Publishing to #{dest} :: #{msg}")
-          channel.queue(dest).publish(msg, opts)
-          channel.queue(dest).unsubscribe
-        end
-    end
-
-
-    class DirectExchange < BaseExchange
-
-      def do_exchange(destination, message_handler)
-        channel.queue(destination).subscribe do |msg|
-          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-          message_handler.on_message(Filters.process_receiving(msg))
-        end
-      end
-
-      def do_single_exchange(destination, opts={})
-        EM.run do
-          channel.queue(destination).pop do |msg|
-            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-            yield Filters.process_receiving(msg)
-          end
-        end
-      end
-    end
-
-
-    class FanoutExchange < BaseExchange
-
-      def do_exchange(destination, message_handler)
-        queue     = channel.queue("queue_#{self.object_id}")
-        exchange  = channel.fanout(fanout_name_for(destination))
-
-        queue.bind(exchange).subscribe do |msg|
-        # channel.queue("queue_#{rand}").bind(channel.fanout(fanout_name_for(destination))).subscribe do |msg|
-          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-          message_handler.on_message(Filters.process_receiving(msg))
-        end        
-      end
-
-      def do_single_exchange(destination, opts={})
-        EM.run do
-          queue     = channel.queue("queue_#{self.object_id}")
-          exchange  = channel.fanout(fanout_name_for(destination))
-
-          queue.bind(exchange).pop do |msg|
-          # channel.queue("queue_#{rand}").bind(channel.fanout(fanout_name_for(destination)), opts).pop do |msg|
-            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-            yield Filters.process_receiving(msg)
-          end
-        end
-      end
-
-      protected
-
-        def publish_message(dest, msg, opts)
-          exchange = channel.fanout(fanout_name_for(dest))
-          exchange.publish(msg, opts)
-          # channel.fanout(fanout_name_for(dest), :durable => true).publish(msg, opts)
-          RosettaQueue.logger.info("Publishing to fanout #{dest} :: #{msg}")
-        end
-
-      private
 
-        def fanout_name_for(destination)
-          fanout_name = destination.gsub(/(topic|fanout)\/(.*)/, '\2')
-          raise "Unable to discover fanout exchange.  Cannot bind queue to exchange!" unless fanout_name
-          fanout_name
-        end
-    end
-
-    class AmqpConnect
-
-      class << self
-        
-        def connection(user, pass, host, port=nil)
-          @conn ||= AMQP.connect(:user => user, :pass => pass, :host => host)
-        end
-        
-      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

@@ -0,0 +1,117 @@
+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 < Amqp
+      private
+
+      def exchange_strategy_for(destination, options)
+        case destination
+        when /^fanout\./
+          @exchange ||= SynchExchange::FanoutExchange.new(@adapter_settings, options)
+        when /^topic\./
+          raise "Sorry.  RosettaQueue can not process AMQP topics yet"
+        when /^queue\./
+          @exchange ||= SynchExchange::DirectExchange.new(@adapter_settings, options)
+        else
+          @exchange ||= SynchExchange::DirectExchange.new(@adapter_settings, options)
+        end
+      end
+    end 
+
+    module SynchExchange
+
+      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 conn
+          vhost = @adapter_settings[:opts][:vhost] || "/" 
+          @conn ||= Bunny.new( :user => @adapter_settings[:user], 
+                               :pass => @adapter_settings[:password], 
+                               :host => @adapter_settings[:host], 
+                               :vhost => vhost)
+          @conn.start unless @conn.status == :connected
+          @conn
+        end
+      end
+
+      class DirectExchange < BaseExchange
+
+        def publish(destination, message, options={})
+          RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
+          queue = conn.queue(destination, options)
+          queue.publish(message, options)
+          queue.unsubscribe
+        end      
+
+        def receive(destination, message_handler)
+          queue = conn.queue(destination, @options)
+          ack = @options[:ack]
+          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)
+          queue = conn.queue(destination, @options)
+          ack = @options[:ack]
+          msg = queue.pop(@options)
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          queue.ack if ack
+          yield Filters.process_receiving(msg)
+        end
+
+      end
+
+      class FanoutExchange < BaseExchange
+        include Fanout
+        
+        def publish(destination, message, 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.exchange(fanout_name_for(destination), @options.merge({:type => :fanout}))
+          queue.bind(exchange)
+          ack = @options[:ack]
+
+          msg = 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={})
+          queue = conn.queue("queue_#{self.object_id}", options)
+          exchange = conn.exchange(fanout_name_for(destination), options.merge({:type => :fanout}))
+          queue.bind(exchange)
+          ack = @options[:ack]
+          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

data/lib/rosetta_queue/adapters/base.rb

@@ -24,4 +24,4 @@ module RosettaQueue
   
     end
   end
-end
+end

data/lib/rosetta_queue/adapters/beanstalk.rb

@@ -9,9 +9,9 @@ module RosettaQueue
         @conn.ack(msg.headers["message-id"])
       end
 
-      def initialize(user=nil, password=nil, host="localhost", port=11300)
-        @host, @port = host, port
-        @conn = Beanstalk::Pool.new(["#{host}:#{port}"])
+      def initialize(adapter_settings = {})
+        @host, @port = adapter_settings[:host], adapter_settings[:port]
+        @conn = Beanstalk::Pool.new(["#{@host}:#{@port}"])
       end
 
       def disconnect; end

data/lib/rosetta_queue/adapters/null.rb

@@ -23,7 +23,7 @@ module RosettaQueue
     # to set ENV["RUNNING_STORIES"] = "true" in your helper.rb or env.rb file)
     class NullAdapter
                     
-      def initialize(user, password, host, port)
+      def initialize(adapter_settings)
         # no-op
       end
 
@@ -54,4 +54,4 @@ module RosettaQueue
 
     end
   end
-end
+end

data/lib/rosetta_queue/adapters/stomp.rb

@@ -9,8 +9,13 @@ module RosettaQueue
         @conn.ack(msg.headers["message-id"])
       end
 
-      def initialize(user, password, host, port)
-        @conn = Stomp::Connection.open(user, password, host, port, true)
+      def initialize(adapter_settings = {})
+        raise "Missing adapter settings" if adapter_settings.empty?
+        @conn = Stomp::Connection.open(adapter_settings[:user], 
+                                       adapter_settings[:password], 
+                                       adapter_settings[:host], 
+                                       adapter_settings[:port], 
+                                       true)
       end
 
       def disconnect(message_handler)

data/lib/rosetta_queue/consumer.rb

@@ -5,9 +5,16 @@ module RosettaQueue
       RosettaQueue::Adapter.instance.receive_once(Destinations.lookup(destination), options)
       
       rescue Exception=>e
-        RosettaQueue.logger.error("Caught exception in Consumer#receive: #{$!}\n" + e.backtrace.join("\n\t"))
+        RosettaQueue.logger.error("Caught exception in Consumer.receive: #{$!}\n" + e.backtrace.join("\n\t"))
     end
 
+    def self.delete(destination, options={})
+      RosettaQueue::Adapter.instance.delete(Destinations.lookup(destination), options)
+      
+      rescue Exception=>e
+        RosettaQueue.logger.error("Caught exception in Consumer.delete: #{$!}\n" + e.backtrace.join("\n\t"))
+    end 
+
     def initialize(message_handler)
       @message_handler = message_handler
     end

data/lib/rosetta_queue/consumer_managers/base.rb

@@ -19,4 +19,4 @@ module RosettaQueue
     end
     
   end  
-end
+end

data/lib/rosetta_queue/filters.rb

@@ -38,7 +38,5 @@ module RosettaQueue
       end
       
     end
-    
-    
   end
-end
+end

data/lib/rosetta_queue/logger.rb

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

data/lib/rosetta_queue/producer.rb

@@ -7,16 +7,8 @@ module RosettaQueue
       RosettaQueue::Adapter.instance.send_message(Destinations.lookup(destination), Filters.process_sending(message), options)
 
       rescue Exception=>e
-        RosettaQueue.logger.error("Caught exception in Consumer#receive: #{$!}\n" + e.backtrace.join("\n\t"))
+        RosettaQueue.logger.error("Caught exception in Consumer.publish: #{$!}\n" + e.backtrace.join("\n\t"))
     end
 
-    # def publish(message)
-    #   begin
-    #     connection.send_message(publish_destination, message, options)
-    #   rescue Exception=>e
-    #     RosettaQueue.logger.error("Caught exception in Producer#publish: #{$!}\n" + e.backtrace.join("\n\t"))
-    #   end
-    # end
-
   end
-end
+end

data/lib/rosetta_queue/spec_helpers/helpers.rb

@@ -1,6 +1,6 @@
 module RosettaQueue
   # Adds helpful methods when doing application level testing.
-  # If you are using cucumber just include it in your Wolrd in the env.rb file:
+  # If you are using cucumber just include it in your World in the env.rb file:
   # World {|world| world.extend RosettaQueue::SpecHelpers }
   module SpecHelpers
     require 'open-uri'

data/lib/rosetta_queue.rb

@@ -1,6 +1,6 @@
 $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'
+require('rosetta_queue/core_ext/string') unless defined? ActiveSupport
 
 require 'rosetta_queue/adapter'
 require 'rosetta_queue/base'
@@ -11,8 +11,11 @@ require 'rosetta_queue/filters'
 require 'rosetta_queue/logger'
 require 'rosetta_queue/message_handler'
 require 'rosetta_queue/producer'
+require 'rosetta_queue/consumer_managers/base'
+require 'rosetta_queue/consumer_managers/threaded'
 
 if defined?(Rails)
   RosettaQueue.logger = RosettaQueue::Logger.new(File.join(Rails.root, 'log', 'rosetta_queue.log'))
   require('rosetta_queue/spec_helpers') if Rails.env == "test"
 end
+

data/spec/rosetta_queue/adapter_spec.rb

@@ -51,5 +51,51 @@ module RosettaQueue
           
     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