bmabey-rosetta_queue 0.2.0 → 0.3.3

data/features/step_definitions/common_messaging_steps.rb

@@ -1,3 +1,44 @@
+def eval_consumer_class(queue, log_file="point-to-point.log", klass_name=nil)
+  klass_name = "#{queue.to_s.capitalize}Consumer" if klass_name.nil?
+  return if Object.const_defined?(klass_name)
+  options = {}
+  unless @adapter_type == "stomp"
+    options = ":ack => true"
+  else
+    options = ":ack => 'client'"
+  end
+
+  str = <<-EOC
+    class #{klass_name}
+      include RosettaQueue::MessageHandler
+      subscribes_to :#{queue}
+      options #{options}
+
+      def on_message(msg)
+        begin
+          file_path = "#{CONSUMER_LOG_DIR}/#{log_file}"
+          File.open(file_path, "w+") do |f|
+            f << msg + " from #{klass_name}"
+          end
+        rescue Exception => e
+          puts e.message
+        end
+      end
+    end
+  EOC
+
+  eval(str)
+  Object.const_get(klass_name)
+end
+
+Given /^consumer logs have been cleared$/ do
+    %w[point-to-point pub-sub fooconsumer barconsumer].each do |file_name|
+      file_path = "#{CONSUMER_LOG_DIR}/#{file_name}.log"
+      File.delete(file_path) if File.exists?(file_path)
+      File.open(file_path, "a+")
+    end
+end
+
 Given /^RosettaQueue is configured for '(\w+)'$/ do |adapter_type|
   @adapter_type = adapter_type
   RosettaQueue::Adapter.define do |a|
@@ -16,30 +57,26 @@ Given /^RosettaQueue is configured for '(\w+)'$/ do |adapter_type|
   end
 end
 
-Given /^a point-to-point destination is set$/ do
+Given /^a destination is set with queue '(.*)' and queue address '(.*)'$/ do |key, queue|
   RosettaQueue::Destinations.define do |dest|
-    dest.map :foo, "/queue/bar"
-  end  
+    dest.map key.to_sym, queue
+  end
+end
+
+Given /^the message '(.+)' is published to queue '(.+)'$/ do |message, queue_name|
+  publish_message(message, {:to => queue_name})
 end
 
-Given /^a '(.*)' destination is set$/ do |pub_sub|
-  case pub_sub
-  when /fanout/
-    RosettaQueue::Destinations.define do |dest|
-      dest.map :foobar, "/fanout/foobar"
-    end  
-  when /topic/
-    RosettaQueue::Destinations.define do |dest|
-      dest.map :foobar, "/topic/foobar"
-    end  
-  end 
+When /^a message is published to '(\w+)'$/ do |q|
+  RosettaQueue::Producer.publish(q.to_sym, "Hello World!")
+#  publish_message("Hello World!", {:options => {:to => q}})
 end
 
 When /^the queue '(.*)' is deleted$/ do |queue|
-  system("rabbitmqctl list_queues | grep bar").should be_true
+  system("rabbitmqctl list_queues | grep #{queue}").should be_true
   RosettaQueue::Consumer.delete(queue.to_sym)
 end
 
-Then /^the queue 'foo' should no longer exist$/ do
-  system("rabbitmqctl list_queues | grep bar").should be_false
+Then /^the queue '(.*)' should no longer exist$/ do |queue|
+  system("rabbitmqctl list_queues | grep #{queue}").should be_false
 end

data/features/step_definitions/filtering_steps.rb

@@ -5,9 +5,9 @@ Then /^a (receiving|sending) filter is defined to prepend 'Foo' to all messages$
   end
 end
 
-When /^the message on "(.+)" is consumed$/ do |queue_name|
+When /^the message on '(.+)' is consumed$/ do |queue_name|
   # TODO
-  # @consumed_message = queue(:foo_queue).pop  
+  # @consumed_message = queue(:foo_queue).pop
   @consumed_message = consume_once(queue_name.to_sym)
 end
 

data/features/step_definitions/point_to_point_steps.rb

@@ -1,12 +1,22 @@
-Given /^the message "(.+)" is published to queue "(.+)"$/ do |message, queue_name|
-  publish_message(message, {:options => {:ack => "client"}}.merge(:to => queue_name))
+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
 
-When /^a message is published to queue '(\w+)'$/ do |q|
-  publish_message("Hello World!", {:options => {:ack => "client"}}.merge(:to => q))
-end
-
-Then /^the message should be consumed$/ do
-  RosettaQueue::Consumer.receive(:foo).should =~ /Hello World!/
-  # consume_once_with(SampleConsumer).should =~ /Hello World!/
+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

@@ -1,11 +1,25 @@
-When /^a message is published to '(\w+)'$/ do |topic|
-  RosettaQueue::Producer.publish(topic.to_sym, "Hello World!", {:durable => true})
-  # publish_message("Hello World!", {:options => {:ack => "client"}}.merge(:to => topic))
+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 the topic$/ do
-  sleep 1
-  RosettaQueue::Consumer.receive(:foobar).should =~ /Hello World!/
-  # RosettaQueue::Consumer.receive(:bar).should =~ /Hello World!/
-  # consume_once_with(SampleConsumer).should == "Hello World!"
+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

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

data/features/support/sample_consumers.rb

@@ -4,14 +4,14 @@ 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
 
 
@@ -19,11 +19,11 @@ 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,6 +1,7 @@
 $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'

data/lib/rosetta_queue/adapter.rb

@@ -5,15 +5,15 @@ module RosettaQueue
 
     class << self
       attr_writer :user, :password, :host, :port, :options
-      
+
       def define
         yield self
       end
-            
+
       def reset
         @user, @password, @host, @port, @options, @adapter_class = nil, nil, nil, nil, nil, nil
       end
-      
+
       def type=(adapter_prefix)
         require "rosetta_queue/adapters/#{adapter_prefix}"
         @adapter_class = RosettaQueue::Gateway.const_get("#{adapter_prefix.to_s.classify}Adapter")
@@ -28,12 +28,12 @@ module RosettaQueue
       end
 
       private
-      
+
       def opts
         raise AdapterException, "Adapter options should be a hash" unless @options.nil? || @options.is_a?(Hash)
         @options ||= {}
       end
-      
+
     end
-  end  
+  end
 end

data/lib/rosetta_queue/adapters/amqp.rb

@@ -7,7 +7,7 @@ module RosettaQueue
         raise AdapterException, "Unable to discover fanout exchange. Cannot bind queue to exchange!" unless fanout_name
         fanout_name
       end
-    end 
+    end
 
     class Amqp < BaseAdapter
 
@@ -18,9 +18,12 @@ module RosettaQueue
 
       def delete(destination, opts={})
         exchange_strategy_for(destination, opts).delete(destination)
-      end 
+      end
 
-      def disconnect(message_handler); 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|

data/lib/rosetta_queue/adapters/amqp_evented.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + "/amqp.rb")
 
 module RosettaQueue
   module Gateway
- 
+
     class AmqpEventedAdapter < Amqp
       private
 
@@ -21,35 +21,35 @@ module RosettaQueue
         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 
+        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 = @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={})
@@ -60,7 +60,7 @@ module RosettaQueue
           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?
 
@@ -75,7 +75,7 @@ module RosettaQueue
 
         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|
@@ -85,8 +85,8 @@ module RosettaQueue
           end
         end
       end
-      
-      
+
+
       class FanoutExchange < BaseExchange
         include Fanout
 
@@ -97,36 +97,36 @@ module RosettaQueue
           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
 end

data/lib/rosetta_queue/adapters/amqp_synch.rb

@@ -9,7 +9,7 @@ module RosettaQueue
     class AmqpSynchAdapter < Amqp
       private
 
-      def exchange_strategy_for(destination, options)
+      def exchange_strategy_for(destination, options={})
         case destination
         when /^fanout\./
           @exchange ||= SynchExchange::FanoutExchange.new(@adapter_settings, options)
@@ -21,7 +21,7 @@ module RosettaQueue
           @exchange ||= SynchExchange::DirectExchange.new(@adapter_settings, options)
         end
       end
-    end 
+    end
 
     module SynchExchange
 
@@ -31,21 +31,27 @@ module RosettaQueue
           @adapter_settings, @options = adapter_settings, options
         end
 
-        def delete(destination)
-          conn.queue(destination).delete(@options)
-        end 
+        def delete(destination, options={})
+          conn.queue(destination).delete(options)
+        end
+
+        def unsubscribe
+          @queue.unsubscribe
+          conn.stop
+        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 = @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
@@ -54,25 +60,25 @@ module RosettaQueue
           RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
           queue = conn.queue(destination, options)
           queue.publish(message, options)
-          queue.unsubscribe
-        end      
+          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
-          end 
+            @queue.ack if ack
+          end
         end
 
-        def receive_once(destination)
-          queue = conn.queue(destination, @options)
-          ack = @options[:ack]
-          msg = queue.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}")
-          queue.ack if ack
+          @queue.ack if ack
           yield Filters.process_receiving(msg)
         end
 
@@ -80,38 +86,38 @@ module RosettaQueue
 
       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      
+        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|
+          @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        
+            @queue.ack if ack
+          end
         end
 
         def receive_once(destination, options={})
-          queue = conn.queue("queue_#{self.object_id}", 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)
-          ack = @options[:ack]
-          msg = queue.pop(@options)
+          @queue.bind(exchange)
+          msg = @queue.pop(options)
           RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
-          queue.ack if ack
+          @queue.ack if ack
           yield Filters.process_receiving(msg)
         end
 
-      end 
-    end 
+      end
+
+    end
   end
 end