rosetta_queue 0.4.0

data/features/step_definitions/point_to_point_steps.rb

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

@@ -0,0 +1,25 @@
+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 '(\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

@@ -0,0 +1,25 @@
+require 'rubygems'
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'rosetta_queue'
+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
+  Kernel.warn "No log directory setup at the root of rosetta_queue. Using the null logger instead."
+  class NullLogger
+    def info(*args);  end
+    def debug(*args); end
+    def fatal(*args); end
+    def error(*args); end
+    def warn(*args);  end
+  end
+
+  RosettaQueue.logger = NullLogger.new
+end
+
+World(RosettaQueue::SpecHelpers)

data/features/support/sample_consumers.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/env.rb')
+
+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
+
+
+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

@@ -0,0 +1,23 @@
+$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'
+require 'rosetta_queue/consumer'
+require 'rosetta_queue/destinations'
+require 'rosetta_queue/exceptions'
+require 'rosetta_queue/filters'
+require 'rosetta_queue/logger'
+require 'rosetta_queue/message_handler'
+require 'rosetta_queue/exception_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/lib/rosetta_queue/adapter.rb

@@ -0,0 +1,39 @@
+require 'rosetta_queue/adapters/base'
+
+module RosettaQueue
+  class Adapter
+
+    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")
+
+        rescue LoadError
+          raise AdapterException, "Adapter type '#{adapter_prefix}' does not match existing adapters!"
+      end
+
+      def instance
+        raise AdapterException, "Adapter type was never defined!" unless @adapter_class
+        @adapter_class.new({:user => @user, :password => @password, :host => @host, :port => @port, :opts => opts})
+      end
+
+      private
+
+      def opts
+        raise AdapterException, "Adapter options should be a hash" unless @options.nil? || @options.is_a?(Hash)
+        @options ||= {}
+      end
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/amqp.rb

@@ -0,0 +1,48 @@
+module RosettaQueue
+  module Gateway
+
+    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(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)
+        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|
+          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_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.handle_message(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.handle_message(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,123 @@
+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, 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 => 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)
+          conn.stop
+        end
+
+        def receive(destination, message_handler)
+          ack = @options[:ack]
+          @queue = conn.queue(destination, @options)
+          @queue.subscribe(@options) do |msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.handle_message(msg)
+            @queue.ack if ack
+          end
+        end
+
+        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
+          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)
+          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)
+          @queue.subscribe(@options) do |msg|
+            RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+            message_handler.handle_message(msg)
+            @queue.ack if ack
+          end
+        end
+
+        def receive_once(destination, 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)
+          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