cwyckoff-rosetta_queue 0.1.4

data/History.txt

@@ -0,0 +1,9 @@
+== 0.1.x (git)
+
+ === New features
+  * Beanstalk Adaper (David Brady)
+    * Still needs some work to have it take advantage of beanstalk's subscribe funtionality.
+ === Bufixes
+
+== 0.1.0 / 2008-01-28 - Initial Release
+RosettaQueue was realased in the wild! RQ's initial development was primarily sponsored by Alliance Health Networks (thanks!!).  The original authors were Chris Wyckoff and Ben Mabey.The initial release included adapters for stomp and amqp, in addition to a null and fake adapters for testing.

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008-2009 Chris Wyckoff, Ben Mabey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,131 @@
+= Rosetta Queue
+
+Rosetta Queue is a 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.
+
+The adapters provided currently are for stomp, amqp, and beanstalk.  We would like to add adapters for other messaging gateways.  The stomp adapter has been used in production along side with Apache's ActiveMQ.  The amqp adapter currently works along side RabbitMQ and passes the acceptance tests but as of yet has not been used in production.
+
+== Quick Tutorial
+Note: The API will most likely change until we reach 1.0.  We will be moving to a more concise API (i.e. queue(:test_queue) << message, etc...)  We will also be changing how exceptions are handled.
+
+When using Rosetta Queue in an application you will need to configure the queues, adapters, and filters (optional).  These configurations should be placed in a file that gets loaded once when your program starts.  If you are using Rails then a good place for this is config/initializers/rosetta_queue.rb.
+
+To set up destinations to produce messages to and consume messages from:
+
+RosettaQueue::Destinations.define do |queue|
+  queue.map :test_queue, '/queue/my_test_queue'
+end
+
+Defining your adapter:
+
+  RosettaQueue::Adapter.define do |a|
+    a.user = ""
+    a.password = ""
+    a.host = "localhost"
+    a.port = 61613
+    a.type = "stomp"
+  end
+
+Define a logger for Rosetta Queue to use.  The logger should be a standard ruby logger:
+
+  RosettaQueue.logger = Logger.new('/my_project/rosetta_queue.log')
+
+
+You can optionally set up filters that are applied to all messages that are sent and received.  For example, if you want to use hashes as messages and serialize them as JSON the following filters (along with ActiveSupport) would accomplish this:
+
+  RosettaQueue::Filters.define do |filter_for|
+    filter_for.receiving { |message| ActiveSupport::JSON.decode(message) }
+    filter_for.sending { |hash| hash.to_json }
+  end
+
+
+To publish a message:
+
+  message = {"hello" => "world!"}  # Assuming you have a filter setup
+  RosettaQueue::Producer.publish(:test_queue, message)
+
+When consuming messages from a queue you will generally want to create a consumer to handle the messages:
+
+  class TestConsumer
+    include RosettaQueue::MessageHandler
+
+    subscribes_to :vendor_status
+    options :persistent => true
+
+    def on_message(message)
+      puts "We consumed a message: #{message.inspect}"
+    end
+
+  end
+
+To fire the consumers up you will want to run a separate process create a manager with all of your consumers.
+
+  require 'rosetta_queue'
+  require 'rosetta_queue/consumer_managers/threaded'
+  require 'test_consumer'
+
+  RosettaQueue::ThreadedManager.create do |m|
+    m.add(TestConsumer.new)
+    m.start
+  end
+
+
+It is recommended that you set your adapter to the 'null' adapter for your specs and then include RosettaQueue::Matchers in any example group you are needing to specify behaviour with RosettaQueue.  The matchers currently switch out the null adapter for the fake adapter to verify the behaviour.  All the matchers for the unit tests are lambda based, like so:
+
+  lambda { model.save }.should publish("foo", :to => :test_queue).
+
+Please look at the publishing matchers for more information.  For examples on how to write acceptance tests for your Rosetta Queue's code please see RosettaQueue's own Cucumber features and read this {blog post}[http://www.benmabey.com/2009/02/17/using-cucumber-to-integrate-distributed-systems-and-test-messaging/].
+
+
+
+== How to contribute
+----------------------------------------------------------------
+Gems you will need:
+cucumber, rspec, yaml, stomp, tmm1-amqp, beanstalk-client
+
+You should be able to run the rspec code examples (specs) without any brokers running with autospec or 'rake spec'.
+
+To run the cucumber features you will need the a messaging system setup that can speak stomp and AMQP.  We have been using the following brokers in testing:
+
+=== Apache ActiveMQ (for the stomp adapter)
+Go to http://activemq.apache.org/download.html to download the latest version, and see http://activemq.apache.org/getting-started.html for installation and configuration instructions.
+The stomp client and features should work with ApacheMQ out of the box.  If you are running any ApacheMQ servers in production on your network you will want to disable the multicast autodiscovery in conf/activemq.xml.  (Around lines 56 and 98.)
+
+=== RabbitMQ (for the amqp adapter)
+Download the right tar from here: http://www.rabbitmq.com/download.html and follow the installation directions that comes with it.
+The features rely on a user of 'rosetta' being setup with the password of 'password' and added to the default virtualhost. You can set them up like so:
+
+  rabbitmqctl add_user rosetta password
+  rabbitmqctl map_user_vhost rosetta /
+
+=== Beanstalk (for the beanstalk adapter) ===
+
+You should set up and run a local instance of beanstalk for your
+tests.
+
+==== beanstalkd ====
+
+Mac OSX users can install beanstalkd from ports. Linux users should
+check their package manager of choice. This is probably the optimal
+method.
+
+Diehards can clone git://github.com/kr/beanstalkd and build it from
+source. It is nontrivial.
+
+Once installed, you can launch beanstalk by running
+
+  beanstalkd -p 11300
+
+This will make it listen on localhost on the standard port 11300,
+which the specs use. You might also want to daemonize beanstalk with
+the -d option but for testing this is not recommended, as the queue
+can get stuck with old messages, which will break your specs.
+
+==== beanstalk-client ====
+
+You will also need the Ruby beanstalk-client gem.
+
+  sudo gem install beanstalk-client
+
+
+
+

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+ 
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "--format pretty"
+end   
+
+desc "Run the specs under spec"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    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.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"]
+    s.authors = ["Ben Mabey", "Chris Wyckoff"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 2

data/cucumber.yml

@@ -0,0 +1 @@
+default: features --format pretty

data/lib/rosetta_queue.rb

@@ -0,0 +1,19 @@
+require 'activesupport' # TODO: remove dependency
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+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/producer'
+
+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 MissingSourceFile
+          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_bunny.rb

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

data/lib/rosetta_queue/adapters/base.rb

@@ -0,0 +1,27 @@
+module RosettaQueue
+  module Gateway
+
+    class BaseAdapter
+  
+      protected
+
+        def options_for(message_handler)
+          (message_handler.options_hash) || {}
+        end
+
+        def destination_for(message_handler)
+          raise DestinationNotFound.new("Missing destination!") unless message_handler.destination
+          @dest ||= Destinations.lookup(message_handler.destination.to_sym)
+        end
+        
+        def filter_receiving(msg)
+          Filters.process_receiving(msg)
+        end
+
+        def filter_sending(msg)
+          Filters.process_sending(msg)
+        end
+  
+    end
+  end
+end

data/lib/rosetta_queue/adapters/fake.rb

@@ -0,0 +1,26 @@
+module RosettaQueue
+  module Gateway
+    
+    class FakeAdapter
+
+      def initialize
+        @messages = []
+      end
+
+      def send_message(queue, message, headers)
+        @messages << {'queue' => queue, 'message' => RosettaQueue::Filters::process_receiving(message), 'headers' => headers}
+      end
+  
+      def messages_sent_to(queue)
+        (queue ? @messages.select{|message| message['queue'] == queue} : @messages).map{|m| m['message']}
+      end
+  
+      def queues
+        @messages.map {|message| message['queue']}
+      end
+
+    end
+    
+  end
+  
+end

data/lib/rosetta_queue/adapters/null.rb

@@ -0,0 +1,57 @@
+module RosettaQueue
+  module Gateway
+    
+    # The null adapter lets all send messages enter into the ether and so is ideal for modes
+    # when you do not want to incur the overhead of a real adapter.  You can not consume with 
+    # this adapter however.
+    #
+    # In your RosettaQueue definition block, and your using rails, you could base your adapter type on Rails.env:
+    #
+    # RosettaQueue::Adapter.define do |a|
+    #   if Rails.env == 'production' || ENV["RUNNING_STORIES"] == "true"
+    #     a.user = ""
+    #     a.password = ""
+    #     a.host = "localhost"
+    #     a.port = 61613
+    #     a.type = "stomp"
+    #   else
+    #     a.type = "null"
+    #   end
+    # end
+    # 
+    # (if you follow this example and are using stories be sure 
+    # to set ENV["RUNNING_STORIES"] = "true" in your helper.rb or env.rb file)
+    class NullAdapter
+                    
+      def initialize(adapter_settings)
+        # no-op
+      end
+
+      def disconnect
+        # no-op
+      end
+      
+      def receive
+        raise "Null Adpater is in use, you can not consume messages!"
+      end
+      
+      def receive_with(message_handler)
+        raise "Null Adpater is in use, you can not consume messages!"
+      end
+      
+      def send_message(queue, message, options)
+        # no-op
+      end
+
+      def subscribe(queue, options)
+        # no-op
+      end
+          
+      def unsubscribe(queue)
+        # no-op
+      end
+
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/stomp.rb

@@ -0,0 +1,73 @@
+require 'stomp'
+
+module RosettaQueue
+  module Gateway
+  
+    class StompAdapter < BaseAdapter
+
+      def ack(msg)
+        @conn.ack(msg.headers["message-id"])
+      end
+
+      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)
+        unsubscribe(destination_for(message_handler))
+        @conn.disconnect
+      end
+
+      def receive(options)
+        msg = @conn.receive
+        ack(msg) unless options[:ack].nil?
+        msg
+      end
+      
+      def receive_once(destination, opts)
+        subscribe(destination, opts)
+        msg = receive(opts).body
+        unsubscribe(destination)
+        RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+        filter_receiving(msg)
+      end
+
+      def receive_with(message_handler)
+        options = options_for(message_handler)
+        destination = destination_for(message_handler)
+        @conn.subscribe(destination, options)
+
+        running do
+          msg = receive(options).body
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          message_handler.on_message(filter_receiving(msg))
+        end
+      end
+      
+      def send_message(destination, message, options)
+        RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")        
+        @conn.send(destination, message, options)
+      end
+
+      def subscribe(destination, options)
+        @conn.subscribe(destination, options)
+      end
+          
+      def unsubscribe(destination)
+        @conn.unsubscribe(destination)
+      end
+      
+      private
+      
+        def running(&block)
+          loop(&block)
+        end
+
+    end
+  end
+end

data/lib/rosetta_queue/base.rb

@@ -0,0 +1,15 @@
+module RosettaQueue
+  
+  class Base
+
+    def disconnect
+      connection.disconnect(@message_handler)
+    end
+
+    protected
+     def connection
+       @conn ||= Adapter.instance
+     end
+
+  end
+end

data/lib/rosetta_queue/consumer.rb

@@ -0,0 +1,30 @@
+module RosettaQueue
+  class Consumer < Base
+
+    def self.receive(destination, options = {})
+      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"))
+    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
+
+    def receive
+      connection.receive_with(@message_handler)
+      
+      rescue Exception=>e
+        RosettaQueue.logger.error("Caught exception in Consumer#receive: #{$!}\n" + e.backtrace.join("\n\t"))
+    end
+
+  end
+end

data/lib/rosetta_queue/consumer_managers/base.rb

@@ -0,0 +1,22 @@
+module RosettaQueue
+  
+  class BaseManager
+    attr_reader :consumers
+
+    class << self
+      def create
+        yield self.new
+      end
+    end
+    
+    def initialize
+      @consumers  = {}
+    end
+    
+    def add(message_handler)
+      key = message_handler.class.to_s.underscore.to_sym
+      @consumers[key] = Consumer.new(message_handler)
+    end
+    
+  end  
+end

data/lib/rosetta_queue/consumer_managers/evented.rb

@@ -0,0 +1,43 @@
+require 'rosetta_queue/consumer_managers/base'
+require 'mq'
+
+module RosettaQueue
+  
+  class EventedManager < BaseManager
+    
+    def start
+      EM.run {
+        trap_interruptions
+
+        begin
+          @consumers.each do |key, consumer|
+            RosettaQueue.logger.info("Running consumer #{key} in event machine...")
+            consumer.receive
+          end
+        rescue Exception => e
+          RosettaQueue.logger.error("Exception thrown: #{$!}\n" + e.backtrace.join("\n\t"))
+        end
+      }
+    end
+    
+    def stop
+      RosettaQueue.logger.info("Shutting down event machine...")
+      EM.stop
+    end
+
+    private
+    
+      def trap_interruptions
+        trap("INT") {
+          RosettaQueue.logger.warn("Interrupt received.  Shutting down...")
+          EM.stop
+        }
+        
+        trap("TERM") {
+          RosettaQueue.logger.warn("Interrupt received.  Shutting down...")
+          EM.stop
+        }
+      end
+
+  end
+end

data/lib/rosetta_queue/consumer_managers/threaded.rb

@@ -0,0 +1,75 @@
+require 'rosetta_queue/consumer_managers/base'
+
+module RosettaQueue
+  class ThreadedManager < BaseManager
+
+    def initialize
+      @threads    = {}
+      @running    = true
+      super
+    end
+
+    def start
+      start_threads
+      join_threads
+      monitor_threads
+    end
+
+    def stop
+      stop_threads
+    end
+
+  private
+
+    def join_threads
+      @threads.each { |thread| thread.join }
+    end
+
+    def monitor_threads
+      while @running
+        trap("TERM", "EXIT")
+        living = false
+        @threads.each { |name, thread| living ||= thread.alive? }
+        @running = living
+        sleep 1
+      end
+
+      puts "All connection threads have died..."
+      rescue Interrupt=>e
+        RosettaQueue.logger.warn("Interrupt received.  Shutting down...")
+        puts "\nInterrupt received\n"
+      rescue Exception=>e
+        RosettaQueue.logger.error("Exception thrown -- #{e.class.name}: #{e.message}")
+      ensure
+        RosettaQueue.logger.warn("Cleaning up threads...")
+        stop_threads
+    end
+
+    def start_threads
+      @consumers.each do |key, consumer|
+        @threads[key] = Thread.new(key, consumer) do |a_key, a_consumer|
+          while @running
+            begin
+              RosettaQueue.logger.info("Threading consumer #{a_consumer}...")
+              Mutex.new.synchronize { a_consumer.receive }
+            rescue StopProcessingException=>e
+              RosettaQueue.logger.error("#{a_key}: Processing Stopped - receive interrupted")
+            rescue Exception=>e
+              RosettaQueue.logger.error("#{a_key}: Exception from connection.receive: #{$!}\n" + e.backtrace.join("\n\t"))
+            end
+            Thread.pass
+          end
+        end
+      end      
+    end
+
+    def stop_threads
+      @running = false
+      @threads.each do |key, thread|
+        RosettaQueue.logger.info("Stopping thread and disconnecting from #{key}...")
+        @consumers[key].disconnect
+        thread.kill
+      end
+    end
+  end
+end

data/lib/rosetta_queue/destinations.rb

@@ -0,0 +1,34 @@
+module RosettaQueue
+
+  class Destinations
+    
+    @dest = {}
+
+    class << self
+      attr_reader :dest
+
+      def define
+        yield self
+      end
+      
+      def clear
+        @dest.clear
+      end
+      
+      def lookup(dest_name)
+        mapping = dest[dest_name.to_sym]
+        raise "No destination mapping for '#{dest_name}' has been defined!" unless mapping
+        return mapping
+      end
+      
+      def map(key, dest)
+        @dest[key] = dest
+      end
+      
+      def queue_names
+        @dest.values
+      end
+    end
+
+  end
+end

data/lib/rosetta_queue/exceptions.rb

@@ -0,0 +1,10 @@
+module RosettaQueue
+
+  class RosettaQueueError < StandardError; end
+  class DestinationNotFound < RosettaQueueError; end
+  class RosettaQueueVariableNotFound < RosettaQueueError; end
+  class CallbackNotImplemented < RosettaQueueError; end
+  class AdapterException < RosettaQueueError; end
+  class StopProcessingException < Interrupt; end
+
+end

data/lib/rosetta_queue/filters.rb

@@ -0,0 +1,42 @@
+# Example:
+# RosettaQueue::Filters.define do |filter_for|
+#   filter_for.receiving { |message| ActiveSupport::JSON.decode(message) }
+#   filter_for.sending { |hash| hash.to_json }
+# end
+
+
+module RosettaQueue
+  class Filters
+    
+    class << self
+            
+      def define
+        yield self
+      end
+      
+      def reset
+        @receiving = nil
+        @sending = nil
+      end
+    
+      def receiving(&receiving_filter)
+        @receiving = receiving_filter
+      end
+    
+      def sending(&sending_filter)
+        @sending = sending_filter
+      end
+      
+      def process_sending(message)
+        return message unless @sending
+        @sending.call(message)
+      end
+      
+      def process_receiving(message)
+        return message unless @receiving
+        @receiving.call(message)
+      end
+      
+    end
+  end
+end

data/lib/rosetta_queue/logger.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module RosettaQueue
+  class MissingLogger < ::StandardError; end
+
+  def self.logger=(new_logger)
+    @logger = new_logger
+  end
+  
+  def self.logger
+    return @logger if @logger
+    raise MissingLogger, "No logger has been set for RosettaQueue.  Please define one with RosettaQueue.logger=."
+  end
+
+end
+
+module RosettaQueue
+
+  class Logger < ::Logger
+
+    def format_message(severity, timestamp, progname, msg)
+      "[#{timestamp.to_formatted_s(:db)}] #{severity} #{msg}\n"
+    end
+
+  end
+
+end

data/lib/rosetta_queue/message_handler.rb

@@ -0,0 +1,33 @@
+module RosettaQueue
+  module MessageHandler
+    
+    module ClassMethods
+
+      attr_reader :destination, :options_hash
+
+      def options(options = {})
+        @options_hash = options
+      end
+
+      def publishes_to(destination)
+        @destination = destination
+      end
+
+      def subscribes_to(destination)
+        @destination = destination
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend(ClassMethods)
+
+      def destination
+        self.class.destination  
+      end
+      
+      def options_hash
+        self.class.options_hash
+      end
+    end
+  end
+end

data/lib/rosetta_queue/producer.rb

@@ -0,0 +1,14 @@
+module RosettaQueue
+  
+  class Producer < Base
+    include MessageHandler
+
+    def self.publish(destination, message, options = {})
+      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"))
+    end
+
+  end
+end

data/lib/rosetta_queue/spec_helpers.rb

@@ -0,0 +1,5 @@
+require 'rosetta_queue/adapters/null'
+require 'rosetta_queue/adapters/fake'
+require 'rosetta_queue/spec_helpers/hash'
+require 'rosetta_queue/spec_helpers/publishing_matchers'
+require 'rosetta_queue/spec_helpers/helpers'

data/lib/rosetta_queue/spec_helpers/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  # To be used in conjuction with rspec's predicate matcher.
+  #
+  # For example, in story/feature or a functional spec you could say:  
+  #
+  # expected_message =  {'name' => 'Advertiser'}
+  # expected_message.should be_published_to(:advertiser_create)
+  #
+  def published_to?(destination)
+    received_message = nil
+    begin
+      Timeout::timeout(2) { received_message = RosettaQueue::Consumer.receive(destination)}
+    rescue Timeout::Error
+      raise "#{destination} should have received a message but did not NOTE: make sure there are no other processes which are polling messages"
+    end
+    
+    # calling should == is kinda wierd, I know.. but in order to get a decent error message it is needed
+    received_message.should ==  self
+  end
+  
+end

data/lib/rosetta_queue/spec_helpers/helpers.rb

@@ -0,0 +1,47 @@
+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:
+  # World {|world| world.extend RosettaQueue::SpecHelpers }
+  module SpecHelpers
+    require 'open-uri'
+    
+    # *Currently* only works with ActiveMQ being used as gateway. 
+    # This will clear the queues defined in the RosettaQueue::Destinations mapping.
+    # TODO: Figure out a better spot for this to allow for other gateways...
+    def clear_queues
+      RosettaQueue::Destinations.queue_names.each do |name| 
+        queue = name.gsub('/queue/','')
+        open("http://127.0.0.1:8161/admin/deleteDestination.action?JMSDestination=#{queue}&JMSDestinationType=queue")
+      end
+    end
+    
+    # Publishes a given hash as json to the specified destination. 
+    # Example:
+    # publish_message(expected_message, :to => :client_status, :options => {...})
+    # The :options will be passed to the publisher and are optional.
+    def publish_message(message, options)
+      options[:options] ||= {:persistent => false}
+      RosettaQueue::Producer.publish(options[:to], message, options[:options])
+    end
+    
+    # Consumes the first message on queue of consumer that is passed in and uses the consumer to handle it.
+    # Example:
+    # consume_once_with ClientStatusConsumer
+    def consume_once_with(consumer)
+      consumer.new.on_message(RosettaQueue::Consumer.receive(consumer.destination))
+    end
+    
+    # Consumes the first message on queue and returns it.
+    # Example:
+    # message = consume_once :foo_queue
+    def consume_once(dest)
+      RosettaQueue::Consumer.receive(dest)
+    end
+
+    def consuming_from(destination)
+      sleep 1
+      Messaging::Consumer.receive(destination, :persistent => false).to_hash_from_json
+    end
+    
+  end
+end

data/lib/rosetta_queue/spec_helpers/publishing_matchers.rb

@@ -0,0 +1,144 @@
+module RosettaQueue
+  module Matchers
+    
+    class PublishAMessageTo
+
+      def initialize(expected_queue_name, options=nil)
+        @options = options || {}
+        @how_many_messages_expected = (@options[:exactly] || 1).to_i
+        @expected_queue_name = expected_queue_name
+        @expected_queue = expected_queue_name.is_a?(Symbol) ? RosettaQueue::Destinations.lookup(expected_queue_name) : expected_queue_name
+      end
+
+      def matches?(lambda_to_run)    
+        #given
+        RosettaQueue::Adapter.stub!(:instance).and_return(fake_adapter = RosettaQueue::Gateway::FakeAdapter.new)
+        #when
+        lambda_to_run.call
+        #then
+        @actual_queues = fake_adapter.queues      
+        @number_of_messages_published = @actual_queues.select{ |q| q == @expected_queue}.size 
+        @number_of_messages_published == @how_many_messages_expected
+      end
+
+      def failure_message
+        "expected #{message_plural} published to the #{@expected_queue.inspect} queue but #{@number_of_messages_published} messages were"
+      end
+
+      def negative_failure_message
+        "expected ##{message_plural} NOT to be published to the #{@expected_queue.inspect} queue but that queue was published to #{@number_of_messages_published} times"
+      end
+
+      def description
+        "publish #{message_plural} to the '#{@expected_queue_name}' queue"
+      end
+      
+    private
+      def message_plural
+        @how_many_messages_expected == 1 ? "a message" : "#{@how_many_messages_expected} messages"
+      end
+    end
+
+    def publish_a_message_to(expected_queue)
+      PublishAMessageTo.new(expected_queue)
+    end
+  
+    alias :publish_message_to :publish_a_message_to
+    
+    def publish_messages_to(expected_queue, options)
+      PublishAMessageTo.new(expected_queue, options)
+    end
+  
+    class PublishMessageMatcher
+    
+    
+      def matches?(lambda_to_run)
+        #given
+        RosettaQueue::Adapter.stub!(:instance).and_return(fake_adapter = RosettaQueue::Gateway::FakeAdapter.new)
+        #when
+        lambda_to_run.call
+        #then
+        message = fake_adapter.messages_sent_to(@expected_queue).first || ''
+        @actual_message = message
+      end
+    
+      protected
+      def extract_options(options)
+        if (expected_queue_name = options[:to])        
+          @expected_queue = expected_queue_name.is_a?(Symbol) ? RosettaQueue::Destinations.lookup(expected_queue_name) : expected_queue_name
+        end
+      end
+    end
+  
+    class PublishMessageWith < PublishMessageMatcher
+        
+      def initialize(message_subset, options)
+        @message_subset = message_subset
+        extract_options(options)
+      end
+
+      def matches?(lambda_to_run)    
+        super
+        Spec::Mocks::ArgumentConstraints::HashIncludingConstraint.new(@message_subset) == @actual_message
+      end
+
+      def failure_message
+        if @actual_message.blank?
+          "expected #{@message_subset.inspect} to be contained in a message but no message was published"        
+        else
+          "expected #{@message_subset.inspect} to be contained in the message: #{@actual_message.inspect}"
+        end
+      end
+
+      def negative_failure_message
+        "expected #{@message_subset.inspect} not to be contained in the message but was"
+      end
+
+      def description
+        "publish a message with #{@message_subset.inspect}"
+      end
+        
+    end
+    
+    def publish_message_with(message_subset, options={})
+      PublishMessageWith.new(message_subset, options)
+    end
+  
+  
+    class PublishMessage < PublishMessageMatcher
+        
+      def initialize(expected_message, options)
+        @expected_message = expected_message
+        extract_options(options)
+      end
+
+      def matches?(lambda_to_run)    
+        super
+        @actual_message == @expected_message
+      end
+
+      def failure_message
+        if @actual_message.blank?
+          "expected #{@expected_message.inspect} to be published but no message was"        
+        else
+          "expected #{@expected_message.inspect} to be published but the following was instead: #{@actual_message.inspect}"
+        end
+      end
+
+      def negative_failure_message
+        "expected #{@expected_message.inspect} not to be published but it was"
+      end
+
+      def description
+        "publish the message: #{@expected_message.inspect}"
+      end
+        
+    end
+    
+    def publish_message(exact_expected_message, options={})
+      PublishMessage.new(exact_expected_message, options)
+    end
+    
+  end
+end
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: cwyckoff-rosetta_queue
+version: !ruby/object:Gem::Version 
+  version: 0.1.4
+platform: ruby
+authors: 
+- Ben Mabey
+- Chris Wyckoff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 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.
+email: ben@benmabey.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE.txt
+files: 
+- History.txt
+- MIT-LICENSE.txt
+- README.rdoc
+- VERSION.yml
+- lib/rosetta_queue
+- lib/rosetta_queue/adapter.rb
+- lib/rosetta_queue/adapters
+- lib/rosetta_queue/adapters/amqp_bunny.rb
+- lib/rosetta_queue/adapters/base.rb
+- lib/rosetta_queue/adapters/fake.rb
+- lib/rosetta_queue/adapters/null.rb
+- lib/rosetta_queue/adapters/stomp.rb
+- lib/rosetta_queue/base.rb
+- lib/rosetta_queue/consumer.rb
+- lib/rosetta_queue/consumer_managers
+- lib/rosetta_queue/consumer_managers/base.rb
+- lib/rosetta_queue/consumer_managers/evented.rb
+- lib/rosetta_queue/consumer_managers/threaded.rb
+- lib/rosetta_queue/destinations.rb
+- lib/rosetta_queue/exceptions.rb
+- lib/rosetta_queue/filters.rb
+- lib/rosetta_queue/logger.rb
+- lib/rosetta_queue/message_handler.rb
+- lib/rosetta_queue/producer.rb
+- lib/rosetta_queue/spec_helpers
+- lib/rosetta_queue/spec_helpers/hash.rb
+- lib/rosetta_queue/spec_helpers/helpers.rb
+- lib/rosetta_queue/spec_helpers/publishing_matchers.rb
+- lib/rosetta_queue/spec_helpers.rb
+- lib/rosetta_queue.rb
+- Rakefile
+- cucumber.yml
+has_rdoc: true
+homepage: http://github.com/bmabey/rosetta_queue
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rosetta-queue
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Messaging gateway API with adapters for many messaging systems available in Ruby.
+test_files: []
+