cwyckoff-rosetta_queue 0.1.4 → 0.2.0

data/Rakefile

@@ -18,8 +18,8 @@ begin
     s.name = "rosetta_queue"
     s.rubyforge_project = "rosetta-queue"
     s.summary = %Q{Messaging gateway API with adapters for many messaging systems available in Ruby.}
-    s.email = "cbwyckoff@gmail.com"
-    s.homepage = "http://github.com/cwyckoff/rosetta_queue"
+    s.email = "ben@benmabey.com"
+    s.homepage = "http://github.com/bmabey/rosetta_queue"
     s.description = %Q{Messaging gateway API with adapters for many messaging systems available in Ruby. Messaging systems can be easily switched out with a small configuration change. Code for testing on the object and application level is also provided.}
     s.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE.txt"]
     s.files = FileList["[A-Z]*.*", "{bin,generators,lib,features,spec}/**/*", "Rakefile", "cucumber.yml"]

data/lib/rosetta_queue/adapter.rb

@@ -15,6 +15,7 @@ module RosettaQueue
       end
       
       def type=(adapter_prefix)
+        require "rosetta_queue/adapters/amqp_base" if adapter_prefix =~ /amqp/
         require "rosetta_queue/adapters/#{adapter_prefix}"
         @adapter_class = RosettaQueue::Gateway.const_get("#{adapter_prefix.to_s.classify}Adapter")
 

data/lib/rosetta_queue/adapters/amqp.rb

@@ -0,0 +1,123 @@
+require 'mq'
+
+module RosettaQueue
+  module Gateway
+
+    class AmqpAdapter < AmqpBaseAdapter
+
+      def exchange_strategy_for(destination, options)
+        case destination
+        when /fanout/
+          @exchange ||= AmqpExchangeStrategies::FanoutExchange.new(@adapter_settings, options)
+        when /queue/
+          @exchange ||= AmqpExchangeStrategies::DirectExchange.new(@adapter_settings, options)
+        else
+          @exchange ||= AmqpExchangeStrategies::DirectExchange.new(@adapter_settings, options)
+        end
+      end
+    end 
+
+    module AmqpExchangeStrategies
+
+      class BaseExchange
+
+        def initialize(adapter_settings, options={})
+          @adapter_settings, @options = adapter_settings, options
+        end
+
+        def publish(destination, message)
+          unless EM.reactor_running?
+            EM.run do
+              publish_message(destination, message)
+              EM.add_timer(1) { EM.stop_event_loop }
+            end
+          else
+            publish_message(destination, message)
+          end
+        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
+        
+        def publish_message(dest, msg)
+          RosettaQueue.logger.info("Publishing to #{dest} :: #{msg}")
+          channel.queue(dest).publish(msg, @options)
+          channel.queue(dest).unsubscribe
+        end
+      end
+
+
+      class DirectExchange < BaseExchange
+
+        def receive(destination, message_handler)
+          channel.queue(destination).subscribe(@options) do |msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+          end
+        end
+
+        def receive_once(destination)
+          EM.run do
+            channel.queue(destination).pop(@options) do |msg|
+              RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+              yield Filters.process_receiving(msg)
+            end
+          end
+        end
+      end
+
+
+      class FanoutExchange < BaseExchange
+
+        def receive(destination, message_handler)
+          queue = channel.queue("queue_#{self.object_id}")
+          exchange = channel.fanout(fanout_name_for(destination))
+          
+          queue.bind(exchange).subscribe(@options) do |msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+          end        
+        end
+
+        def receive_once(destination)
+          EM.run do
+            queue = channel.queue("queue_#{self.object_id}")
+            exchange = channel.fanout(fanout_name_for(destination))
+
+            queue.bind(exchange).pop(@options) do |msg|
+              RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+              yield Filters.process_receiving(msg)
+            end
+          end
+        end
+
+        protected
+
+        def publish_message(dest, msg)
+          exchange = channel.fanout(fanout_name_for(dest))
+          exchange.publish(msg, @options)
+          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
+    end 
+  end
+end

data/lib/rosetta_queue/adapters/amqp_base.rb

@@ -0,0 +1,36 @@
+module RosettaQueue
+  module Gateway
+
+    class AmqpBaseAdapter < 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
+    end
+  end 
+end 

data/lib/rosetta_queue/adapters/amqp_carrot.rb

@@ -0,0 +1,100 @@
+require 'carrot'
+
+module RosettaQueue
+  module Gateway
+
+    class AmqpCarrotAdapter < AmqpBaseAdapter
+
+      def exchange_strategy_for(destination, options)
+        case destination
+        when /fanout/
+          @exchange ||= CarrotExchangeStrategies::FanoutExchange.new(@adapter_settings, options)
+        when /queue/
+          @exchange ||= CarrotExchangeStrategies::DirectExchange.new(@adapter_settings, options)
+        else
+          @exchange ||= CarrotExchangeStrategies::DirectExchange.new(@adapter_settings, options)
+        end
+      end
+
+    end 
+
+    module CarrotExchangeStrategies
+
+      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 ||= Carrot.new(:user => @adapter_settings[:user], 
+                               :pass => @adapter_settings[:password], 
+                               :host => @adapter_settings[:host], 
+                               :vhost => vhost)
+        end
+      end
+
+      class DirectExchange < BaseExchange
+
+        def publish(destination, message, options={})
+          RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
+          conn.queue(destination).publish(message, options)
+        end      
+
+        def receive(destination, message_handler)
+          conn.queue(destination).subscribe(@options) do |msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+          end 
+        end
+
+        def receive_once(destination)
+          msg = conn.queue(destination).pop(@options)
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          yield Filters.process_receiving(msg)
+        end
+      end
+
+      class FanoutExchange < BaseExchange
+        
+        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)
+          queue = conn.queue("queue_#{self.object_id}")
+          exchange = conn.fanout(fanout_name_for(destination))
+
+          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))
+          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}")
+          exchange = conn.fanout(fanout_name_for(destination))
+
+          msg = queue.bind(exchange).subscribe(@options) do |msg|
+
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+          end        
+        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/consumer.rb

@@ -5,14 +5,14 @@ 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"))
+        RosettaQueue.logger.error("Caught exception in Consumer#delete: #{$!}\n" + e.backtrace.join("\n\t"))
     end 
 
     def initialize(message_handler)

data/lib/rosetta_queue/consumer_managers/base.rb

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

data/lib/rosetta_queue/producer.rb

@@ -7,8 +7,16 @@ 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.publish: #{$!}\n" + e.backtrace.join("\n\t"))
+        RosettaQueue.logger.error("Caught exception in Consumer#receive: #{$!}\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 World in the env.rb file:
+  # If you are using cucumber just include it in your Wolrd in the env.rb file:
   # World {|world| world.extend RosettaQueue::SpecHelpers }
   module SpecHelpers
     require 'open-uri'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cwyckoff-rosetta_queue
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Ben Mabey
@@ -31,7 +31,9 @@ files:
 - lib/rosetta_queue
 - lib/rosetta_queue/adapter.rb
 - lib/rosetta_queue/adapters
-- lib/rosetta_queue/adapters/amqp_bunny.rb
+- lib/rosetta_queue/adapters/amqp_base.rb
+- lib/rosetta_queue/adapters/amqp.rb
+- lib/rosetta_queue/adapters/amqp_carrot.rb
 - lib/rosetta_queue/adapters/base.rb
 - lib/rosetta_queue/adapters/fake.rb
 - lib/rosetta_queue/adapters/null.rb

data/lib/rosetta_queue/adapters/amqp_bunny.rb

@@ -1,138 +0,0 @@
-require 'bunny'
-
-module RosettaQueue
-  module Gateway
-
-    # This AMQP adapter utilizes a forked version of the synchronous AMPQ client 'Bunny'
-    # by bunny (http://github.com/celldee/bunny)
-    class AmqpBunnyAdapter < 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
-
-      private
-
-      def exchange_strategy_for(destination, options)
-        case destination
-        when /^fanout\./
-          @exchange ||= AmqpExchangeStrategies::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)
-        else
-          @exchange ||= AmqpExchangeStrategies::DirectExchange.new(@adapter_settings, options)
-        end
-      end
-
-    end 
-
-    module AmqpExchangeStrategies
-
-      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}")
-          conn.queue(destination, options).publish(message, options)
-        end      
-
-        def receive(destination, message_handler)
-          conn.queue(destination, @options).subscribe(@options) do |msg|
-            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-            message_handler.on_message(Filters.process_receiving(msg))
-          end 
-        end
-
-        def receive_once(destination, options={})
-          msg = conn.queue(destination, options).pop(options)
-          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-          yield Filters.process_receiving(msg)
-        end
-      end
-
-      class FanoutExchange < BaseExchange
-        
-        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.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|
-
-            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-            message_handler.on_message(Filters.process_receiving(msg))
-          end        
-        end
-      end 
-    end 
-  end
-end