cwyckoff-rosetta_queue 0.2.0 → 0.2.1

data/lib/rosetta_queue/adapter.rb

@@ -15,7 +15,6 @@ 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

@@ -1,20 +1,56 @@
-require 'mq'
+require 'carrot'
 
 module RosettaQueue
   module Gateway
 
-    class AmqpAdapter < AmqpBaseAdapter
+    # This AMQP adapter utilizes a forked version of the synchronous AMPQ client 'Carrot'
+    # by famoseagle (http://github.com/famoseagle)
+    class AmqpAdapter < 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
@@ -25,99 +61,75 @@ module RosettaQueue
           @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      
+        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
-        
-        def publish_message(dest, msg)
-          RosettaQueue.logger.info("Publishing to #{dest} :: #{msg}")
-          channel.queue(dest).publish(msg, @options)
-          channel.queue(dest).unsubscribe
+          @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, options).publish(message, options)
+        end      
+
         def receive(destination, message_handler)
-          channel.queue(destination).subscribe(@options) do |msg|
+          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 
         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
+        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 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        
+        
+        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)
-          EM.run do
-            queue = channel.queue("queue_#{self.object_id}")
-            exchange = channel.fanout(fanout_name_for(destination))
+        def receive_once(destination, options={})
+          queue = conn.queue("queue_#{self.object_id}", options)
+          exchange = conn.fanout(fanout_name_for(destination), options)
 
-            queue.bind(exchange).pop(@options) do |msg|
-              RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-              yield Filters.process_receiving(msg)
-            end
-          end
+          msg = queue.bind(exchange).pop(@options)
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          yield Filters.process_receiving(msg)
         end
 
-        protected
+        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 publish_message(dest, msg)
-          exchange = channel.fanout(fanout_name_for(dest))
-          exchange.publish(msg, @options)
-          RosettaQueue.logger.info("Publishing to fanout #{dest} :: #{msg}")
-        end
+        def receive(destination, message_handler)
+          queue = conn.queue("queue_#{self.object_id}", @options)
+          exchange = conn.fanout(fanout_name_for(destination), @options)
 
-        private
+          msg = queue.bind(exchange).subscribe(@options) do |msg|
 
-        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
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.on_message(Filters.process_receiving(msg))
+          end        
         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_managers/base.rb

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

data/lib/rosetta_queue/producer.rb

@@ -10,13 +10,5 @@ module RosettaQueue
         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 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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cwyckoff-rosetta_queue
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Ben Mabey
@@ -31,9 +31,7 @@ files:
 - lib/rosetta_queue
 - lib/rosetta_queue/adapter.rb
 - lib/rosetta_queue/adapters
-- 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_base.rb

@@ -1,36 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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