simianarmy-ruote-amqp 0.9.21

data/History.txt

@@ -0,0 +1,11 @@
+=== 0.9.21 2009-07-13
+
+* Depend on ruote-0.9.21 for flexible JSON backends
+* Support for default queues
+* Support for mapping participant names to queue names
+* Plenty of RDOC fixed
+
+=== 0.9.20 2009-07-13
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+TODO.txt
+lib/ruote-amqp.rb
+lib/ruote-amqp/listener.rb
+lib/ruote-amqp/participant.rb
+lib/spec/ruote.rb
+lib/spec/ruote_example_group.rb
+lib/spec/ruote_helpers.rb
+lib/spec/ruote_matchers.rb
+script/console
+script/destroy
+script/generate
+spec/listener_spec.rb
+spec/participant_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,12 @@
+
+For more information on ruote-amqp, see http://github.com/kennethkalmer/ruote-amqp
+
+Please note that this gem requires access to an AMQP broker and a good 
+understanding of AMQP and remote participants in general.
+
+Join us in #ruote on Freenode or on the openwfe-users Google Group to discuss
+it's uses.
+
+You might also want to look at daemon-kit for help with writing external
+participants that communicate with ruote via AMQP.
+

data/README.rdoc

@@ -0,0 +1,85 @@
+= ruote-amqp
+
+* http://github.com/kennethkalmer/ruote-amqp
+* http://openwfe.rubyforge.org
+
+== DESCRIPTION:
+
+ruote-amqp provides an AMQP participant/listener pair that allows you to 
+distribute workitems out to AMQP consumers for processing.
+
+To learn more about remote participants in ruote please see
+http://openwfe.rubyforge.org/part.html
+
+== FEATURES/PROBLEMS:
+
+* Flexible participant for sending workitems
+* Flexible listener for receiving replies
+* Fully evented (thanks to the amqp gem)
+
+== SYNOPSIS:
+
+Please review the detailed RDOC in RuoteAMQP::Participant and Ruote::AMQP::Listener
+
+== REQUIREMENTS:
+
+* ruote[http://openwfe.rubyforge.org] 0.9.21 or later
+* amqp[http://github.com/tmm1/amqp] 0.6.1 or later
+
+NOTE: It might be required that you build the amqp gem yourself.
+
+ruote 0.9.21 is currently only available to build on your own since John 
+Mettraux is working tirelessly to ship ruote 2.0. To build your own ruote 
+0.9.21 gem run these commands:
+
+  $ git clone git://github.com/jmettraux/ruote.git
+  $ cd ruote
+  $ rake gem
+  $ sudo gem install pkg/ruote-0.9.21.gem
+
+Please note that this requires Rubygems 1.3.2 or newer to work
+
+If you're using ruote 0.9.20 and would like to use ruote-amqp, you can install
+ruote-amqp-0.9.20, like so:
+
+  $ sudo gem install ruote-amqp -v 0.9.20
+
+== INSTALL:
+
+Please be sure to have read the requirements section above
+
+* sudo gem install ruote-amqp
+
+== DAEMON-KIT:
+
+Although the RuoteAMQP gem will work perfectly well with any AMQP consumer,
+it is recommended that you use daemon-kit[http://github.com/kennethkalmer/daemon-kit]
+to write your remote participants.
+
+daemon-kit offers plenty of convenience for remote participants and includes
+a code generator for ruote remote participants.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Kenneth Kalmer
+
+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/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.4.0'
+require 'hoe'
+require 'fileutils'
+require './lib/ruote-amqp'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'simianarmy-ruote-amqp' do
+  self.developer 'Kenneth Kalmer', 'kenneth.kalmer@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps         = [['ruote','= 0.9.21'], ['amqp', '= 0.6.7']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/TODO.txt

@@ -0,0 +1,4 @@
+ruote-amqp TODO
+===============
+
+[ ] Launch processes over AMQP

data/lib/ruote-amqp.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+begin
+  require 'openwfe'
+rescue LoadError
+  require 'rubygems'
+  gem 'ruote', '>= 0.9.21'
+  require 'openwfe'
+end
+require 'openwfe/version'
+
+if OpenWFE::OPENWFERU_VERSION < '0.9.21'
+  raise "ruote-amqp requires at least ruote-0.9.21"
+end
+
+require 'yaml'
+require 'mq'
+
+module RuoteAMQP
+  VERSION = '0.9.21'
+
+  autoload 'Participant', 'ruote-amqp/participant'
+  autoload 'Listener',    'ruote-amqp/listener'
+end

data/lib/ruote-amqp/listener.rb

@@ -0,0 +1,92 @@
+require 'openwfe/service'
+require 'openwfe/listeners/listener'
+
+module RuoteAMQP
+
+  #
+  # = AMQP Listeners
+  #
+  # Used in conjunction with the RuoteAMQP::Participant, the Listener
+  # subscribes to a specific direct exchange and monitors for
+  # incoming workitems. It expects workitems to arrive serialized as
+  # JSON.
+  #
+  # == Configuration
+  #
+  # AMQP configuration is handled by directly manipulating the values of
+  # the +AMQP.settings+ hash, as provided by the AMQP gem. No
+  # defaults are set by the participant. The only +option+ parsed by
+  # the initializer of the listener is the +queue+ key (Hash
+  # expected). If no +queue+ key is set, the listener will subscribe
+  # to the +ruote+ direct exchange for workitems, otherwise it will
+  # subscribe to the direct exchange provided.
+  #
+  # The participant requires version 0.6.1 or later of the amqp gem.
+  #
+  # == Usage
+  #
+  # Register the listener with the engine:
+  #
+  #   engine.register_listener( RuoteAMQP::Listener )
+  #
+  # The listener leverages the asynchronous nature of the amqp gem,
+  # so no timers are setup when initialized.
+  #
+  # See the RuoteAMQP::Participant docs for information on sending
+  # workitems out to remote participants, and have them send replies
+  # to the correct direct exchange specified in the workitem
+  # attributes.
+  #
+  class Listener < OpenWFE::Service
+    include OpenWFE::WorkItemListener
+
+    class << self
+
+      # Listening queue
+      attr_writer :queue
+
+      def queue
+        @queue ||= 'ruote'
+      end
+
+    end
+
+    # Only one option is used (:queue) to determine where to listen
+    # for work
+    def initialize( service_name, options )
+
+      if q = options.delete(:queue)
+        self.class.queue = q
+      end
+
+      super( service_name, options )
+
+      #if AMQP.connection.nil?
+        @em_thread = Thread.new { EM.run } unless EM.reactor_running?
+      #end
+
+      MQ.queue( self.class.queue, :durable => true ).subscribe do |message|
+        workitem = decode_workitem( message )
+        ldebug { "workitem from '#{self.class.queue}': #{workitem.inspect}" }
+        handle_item( workitem )
+      end
+    end
+
+    def stop
+      linfo { "Stopping..." }
+
+      AMQP.stop { EM.stop } #if EM.reactor_running? }
+      @em_thread.join if @em_thread
+    end
+
+    private
+
+    # Complicated guesswork that needs to happen here to detect the format
+    def decode_workitem( msg )
+      ldebug { "decoding workitem from: #{msg}" }
+
+      hash = OpenWFE::Json.decode(msg)
+      OpenWFE.workitem_from_h( hash )
+    end
+  end
+end

data/lib/ruote-amqp/participant.rb

@@ -0,0 +1,195 @@
+module RuoteAMQP
+
+  # = AMQP Participants
+  #
+  # The RuoteAMQP::Participant allows you to send workitems (serialized as
+  # JSON) or messages to any AMQP queues right from the process
+  # definition. When combined with the RuoteAMQP::Listener you can easily
+  # leverage an extremely powerful local/remote participant
+  # combinations.
+  #
+  # By default the participant relies on the presence of an AMQP
+  # listener. Workitems are sent and no replies are given to the
+  # engine. The participant can be configured to reply to the engine
+  # immediately after queueing a message, see the usage section below.
+  #
+  # == Configuration
+  #
+  # AMQP configuration is handled by directly manipulating the
+  # values of the +AMQP.settings+ hash, as provided by the AMQP
+  # gem. No AMQP defaults are set by the participant.
+  #
+  # The participant requires version 0.6.1 or later of the amqp gem.
+  #
+  # == Usage
+  #
+  # Currently it's possible to send either workitems or messages
+  # directly to a specific queue, and have the engine wait for
+  # replies on another queue (see AMQPListener).
+  #
+  # Setting up the participant
+  #
+  #   engine.register_participant(
+  #     :amqp, RuoteAMQP::Participant )
+  #
+  # Setup a participant that always replies to the engine
+  #
+  #   engine.register_participant(
+  #     :amqp, RuoteAMQP::Participant.new(:reply_by_default => true ) )
+  #
+  # Sending a message example
+  #
+  #   class AmqpMessageExample0 < OpenWFE::ProcessDefinition
+  #     sequence do
+  #       amqp :queue => 'test', :message => 'foo'
+  #     end
+  #   end
+  #
+  # Sending a workitem
+  #
+  #   class AmqpWorkitemExample0 < OpenWFE::ProcessDefinition
+  #     sequence do
+  #       amqp :queue => 'test'
+  #     end
+  #   end
+  #
+  # Let the participant reply to the engine without involving the listener
+  #
+  #   class AmqpWaitExample < OpenWFE::ProcessDefinition
+  #     sequence do
+  #       amqp :queue => 'test', :reply_anyway => true
+  #     end
+  #   end
+  #
+  # When waiting for a reply it only makes sense to send a workitem.
+  #
+  # Keeping things DRY with participant name to queue maps:
+  #
+  #   amqp = RuoteAMQP::Participant.new( :default_queue => 'test' )
+  #   amqp.map_participant 'george', 'whitehouse'
+  #   amqp.map_participant 'barak', 'whitehouse'
+  #   amqp.map_participant 'greenspan', 'treasury'
+  #
+  #   engine.register_participant( :george, amqp )
+  #   engine.register_participant( :barak, amqp )
+  #   engine.register_participant( :greespan, amqp )
+  #   engine.register_participant( :amqp, amqp )
+  #
+  #   class DryAmqProcess0 < OpenWFE::ProcessDefinition
+  #     cursor :break_if => "${f:economy_recovered}" do
+  #       # Workitem sent to 'whitehouse' queue
+  #       george :activity => 'Tank economy'
+  #
+  #       # Workitem sent to 'treasury' queue
+  #       greenspan :activity => 'Resign'
+  #
+  #       # Workitem sent to 'whitehouse' queue
+  #       barak :activity => 'Cleanup mess'
+  #
+  #       # Workitem sent to default 'test' queue
+  #       amqp :activity => 'Notify CNN'
+  #     end
+  #   end
+  #
+  # == Workitem modifications
+  #
+  # To ease replies, and additional workitem attribute is set:
+  #
+  #   'reply_queue'
+  #
+  # +reply_queue+ has the name of the queue where the RuoteAMQP::Listener
+  # expects replies from remote participants
+  #
+  # == AMQP notes
+  #
+  # The participant currently only makes use of direct
+  # exchanges. Possible future improvements might see use for topic
+  # and fanout exchanges as well.
+  #
+  # The direct exchanges are always marked as durable by the
+  # participant.
+  #
+  class Participant
+    include OpenWFE::LocalParticipant
+
+    # Accepts an options hash with the following keys:
+    #
+    # * :reply_by_default => (bool) false by default
+    # * :default_queue => (string) nil by default
+    def initialize( options = {} )
+      ensure_reactor!
+
+      @options = {
+        :reply_by_default => false,
+        :default_queue => nil
+      }.merge( options )
+
+      @participant_maps = {}
+    end
+
+    def map_participant( name, queue )
+      @participant_maps[ name ] = queue
+    end
+
+    # Process the workitem at hand. By default the workitem will be
+    # published to the direct exchange specified in the +queue+
+    # workitem parameter. You can specify a +message+ workitem
+    # parameter to have that sent instead of the workitem.
+    #
+    # To force the participant to reply to the engine, set the
+    # +reply_anyway+ workitem parameter.
+    def consume( workitem )
+      ldebug { "consuming workitem" }
+      ensure_reactor!
+
+      if target_queue = determine_queue( workitem )
+
+        q = MQ.queue( target_queue, :durable => true )
+
+        # Message or workitem?
+        if message = ( workitem.attributes['message'] || workitem.params['message'] )
+          ldebug { "sending message to queue: #{target_queue}" }
+          q.publish( message )
+
+        else
+          ldebug { "sending workitem to queue: #{target_queue}" }
+
+          q.publish( encode_workitem( workitem ) )
+        end
+      else
+        lerror { "no queue in workitem params!" }
+      end
+
+      if @options[:reply_by_default] || workitem.params['reply-anyway'] == true
+        reply_to_engine( workitem )
+      end
+
+      ldebug { "done" }
+    end
+
+    def stop
+      linfo { "Stopping..."  }
+
+      AMQP.stop { EM.stop } #if EM.reactor_running? }
+      @em_thread.join if @em_thread
+    end
+
+    private
+
+    def determine_queue( workitem )
+      workitem.params['queue'] ||
+      @participant_maps[ workitem.participant_name ] ||
+      @options[:default_queue]
+    end
+
+    # Encode (and extend) the workitem as JSON
+    def encode_workitem( wi )
+      wi.attributes['reply_queue'] = Listener.queue
+      OpenWFE::Json.encode( wi.to_h )
+    end
+
+    def ensure_reactor!
+      @em_thread = Thread.new { EM.run } unless EM.reactor_running?
+    end
+  end
+end

data/lib/spec/ruote.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/ruote_example_group.rb'
+require File.dirname(__FILE__) + '/ruote_matchers.rb'
+require File.dirname(__FILE__) + '/ruote_helpers.rb'
+
+Spec::Example::ExampleGroupFactory.register(:ruote, Spec::Ruote::Example::RuoteExampleGroup)

data/lib/spec/ruote_example_group.rb

@@ -0,0 +1,8 @@
+module Spec
+  module Ruote
+    module Example
+      class RuoteExampleGroup < Spec::Example::ExampleGroup
+      end
+    end
+  end
+end

data/lib/spec/ruote_helpers.rb

@@ -0,0 +1,24 @@
+module RuoteSpecHelpers
+
+  def purge_engine
+    @engine.application_context.values.each do |s|
+      s.purge if s.respond_to?(:purge)
+    end
+  end
+
+  def run_definition( pdef )
+    fei = @engine.launch( pdef )
+    wait( fei )
+
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+
+    purge_engine
+  end
+
+  def wait( fei )
+    Thread.pass
+    return if @terminated_processes.include?( fei.wfid )
+    @engine.wait_for( fei )
+  end
+end

data/lib/spec/ruote_matchers.rb

@@ -0,0 +1,56 @@
+Spec::Matchers.define :have_errors do |*args|
+  match do |engine|
+    @ps = if fei = args.shift
+      engine.process_status( fei )
+    else
+      engine.process_statuses.values.first
+    end
+
+    if @ps
+      @ps.errors.size != 0
+    else
+      false
+    end
+  end
+
+  failure_message_for_should do |engine|
+    "Expected engine to have errors, but didn't"
+  end
+  failure_message_for_should_not do |engine|
+    "Expected the engine to not have errors, but it did.\n" +
+    @ps.errors.values.map do |e|
+      "  * error: #{e.error_class} \"#{e.stacktrace}\""
+    end.join("\n")
+  end
+  description do
+    #
+  end
+end
+
+Spec::Matchers.define :have_remaining_expressions do
+  match do |engine|
+    exp_count = engine.get_expression_storage.size
+
+    if exp_count == 1
+      false
+    else
+      50.times { Thread.pass }
+      exp_count = engine.get_expression_storage.size
+      if exp_count == 1
+        false
+      else
+        true
+      end
+    end
+  end
+
+  failure_message_for_should do |engine|
+    "Expected engine to have processes remaining, but it didn't"
+  end
+  failure_message_for_should_not do |engine|
+    "Expected engine to have no processes remaining, but it did.#{engine.get_expression_storage.to_s}"
+  end
+  description do
+
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/ruote-amqp.rb'}"
+puts "Loading ruote-amqp gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/listener_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RuoteAMQP::Listener do
+
+  it "should handle replies" do
+    pdef = <<-EOF
+    class AmqpParticipant2 < OpenWFE::ProcessDefinition
+
+      set :field => 'foo', :value => 'foo'
+
+      sequence do
+        echo '${f:foo}'
+        amqp :queue => 'test3'
+        echo '${f:foo}'
+      end
+    end
+    EOF
+
+    @engine.register_participant( :amqp, RuoteAMQP::Participant )
+
+    @engine.register_listener( RuoteAMQP::Listener )
+
+    fei = @engine.launch pdef
+
+    begin
+      Timeout::timeout(10) do
+        msg = nil
+        MQ.queue('test3').subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    wi = OpenWFE::InFlowWorkItem.from_h( OpenWFE::Json.decode( @msg ) )
+    wi.attributes['foo'] = "bar"
+
+    MQ.queue( wi.attributes['reply_queue'] ).publish( OpenWFE::Json.encode( wi.to_h ) )
+
+    wait( fei )
+
+    @engine.should_not have_errors( fei )
+    @engine.should_not have_remaining_expressions
+
+    @tracer.to_s.should == "foo\nbar"
+
+    purge_engine
+  end
+end

data/spec/participant_spec.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RuoteAMQP::Participant, :type => :ruote do
+
+  it "should support 'reply anyway' on expression parameter" do
+
+    pdef = <<-EOF
+    class AmqpParticipant0 < OpenWFE::ProcessDefinition
+
+      sequence do
+        amqp :queue => 'test1', 'reply_anyway' => true
+        echo 'done.'
+      end
+    end
+    EOF
+
+    @engine.register_participant( :amqp, RuoteAMQP::Participant )
+
+    run_definition( pdef )
+
+    @tracer.to_s.should == 'done.'
+
+    begin
+      Timeout::timeout(10) do
+        @msg = nil
+        MQ.queue('test1').subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    @msg.should match(/^\{.*\}$/) # JSON message by default
+  end
+
+  it "should support 'reply anyway' as participant configuration" do
+    pdef = <<-EOF
+    class AmqpParticipant0 < OpenWFE::ProcessDefinition
+
+      sequence do
+        amqp :queue => 'test4'
+        echo 'done.'
+      end
+    end
+    EOF
+
+    p = RuoteAMQP::Participant.new( :reply_by_default => true )
+    @engine.register_participant( :amqp, p )
+
+    run_definition( pdef )
+
+    @tracer.to_s.should == "done."
+
+    begin
+      Timeout::timeout(10) do
+        @msg = nil
+        MQ.queue('test4').subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    @msg.should match( /^\{.*\}$/) # JSON message by default
+  end
+
+  it "should support custom messages instead of workitems" do
+    pdef = <<-EOF
+    class AmqpParticipant1 < OpenWFE::ProcessDefinition
+
+      sequence do
+        amqp :queue => 'test2', :message => 'foo', 'reply_anyway' => true
+        echo 'done.'
+      end
+    end
+    EOF
+
+    @engine.register_participant( :amqp, RuoteAMQP::Participant )
+
+    run_definition( pdef )
+
+    @tracer.to_s.should == "done."
+
+    begin
+      Timeout::timeout(10) do
+        @msg = nil
+        MQ.queue('test2').subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    @msg.should == 'foo'
+  end
+
+  it "should support a default queue name" do
+
+    pdef = <<-EOF
+    class AmqpParticipant0 < OpenWFE::ProcessDefinition
+
+      sequence do
+        amqp 'reply_anyway' => true
+        echo 'done.'
+      end
+    end
+    EOF
+
+    amqp = RuoteAMQP::Participant.new( :default_queue => 'test5' )
+    @engine.register_participant( :amqp, amqp )
+
+    run_definition( pdef )
+
+    @tracer.to_s.should == 'done.'
+
+    begin
+      Timeout::timeout(10) do
+        @msg = nil
+        MQ.queue('test5').subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+  end
+
+  it "should support mapping participant names to queue names" do
+    pdef = <<-EOF
+    class AmqpParticipant0 < OpenWFE::ProcessDefinition
+
+      sequence do
+        q1
+        q2
+        amqp
+        echo 'done.'
+      end
+    end
+    EOF
+
+    amqp = RuoteAMQP::Participant.new( :reply_by_default => true, :default_queue => 'test6' )
+    amqp.map_participant( 'q1', 'test7' )
+    amqp.map_participant( 'q2', 'test8' )
+    @engine.register_participant( :amqp, amqp )
+    @engine.register_participant( :q1, amqp )
+    @engine.register_participant( :q2, amqp )
+
+    run_definition( pdef )
+
+    @tracer.to_s.should == 'done.'
+
+    [ 'test6', 'test7', 'test8' ].each do |q|
+      begin
+        Timeout::timeout(10) do
+          @msg = nil
+          MQ.queue( q ).subscribe { |msg| @msg = msg }
+
+          loop do
+            break unless @msg.nil?
+            sleep 0.1
+          end
+        end
+      rescue Timeout::Error
+        violated "Timeout waiting for message on #{q}"
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'ruote-amqp'
+require 'spec/ruote'
+require 'fileutils'
+
+# AMQP magic worked here
+AMQP.settings[:vhost] = '/ruote-test'
+AMQP.settings[:user]  = 'ruote'
+AMQP.settings[:pass]  = 'ruote'
+
+Spec::Runner.configure do |config|
+
+  config.include( RuoteSpecHelpers )
+
+  config.before(:each) do
+    @tracer = Tracer.new
+
+    ac = {}
+
+    class << ac
+      alias :old_put :[]=
+      def []= (k, v)
+        raise("!!!!! #{k.class}\n#{k.inspect}") \
+          if k.class != String and k.class != Symbol
+        old_put(k, v)
+      end
+    end
+      #
+      # useful for tracking misuses of the application context
+
+    ac['__tracer'] = @tracer
+    ac[:ruby_eval_allowed] = true
+    ac[:definition_in_launchitem_allowed] = true
+
+    @engine = OpenWFE::Engine.new( ac )
+
+    @terminated_processes = []
+    @engine.get_expression_pool.add_observer(:terminate) do |c, fe, wi|
+      @terminated_processes << fe.fei.wfid
+      #p [ :terminated, @terminated_processes ]
+    end
+
+    if ENV['DEBUG']
+      $OWFE_LOG = Logger.new( STDOUT )
+      $OWFE_LOG.level = Logger::DEBUG
+    end
+  end
+
+  config.after(:each) do
+    @engine.stop
+    AMQP.stop { EM.stop }
+    sleep 0.001 while EM.reactor_running?
+  end
+
+  config.after(:all) do
+    base = File.expand_path( File.dirname(__FILE__) + '/..' )
+    FileUtils.rm_rf( base + '/logs' )
+    FileUtils.rm_rf( base + '/work' )
+  end
+end
+
+
+class Tracer
+  def initialize
+    @trace = ''
+  end
+  def to_s
+    @trace.to_s.strip
+  end
+  def << s
+    @trace << s
+  end
+  def clear
+    @trace = ''
+  end
+  def puts s
+    @trace << "#{s}\n"
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: simianarmy-ruote-amqp
+version: !ruby/object:Gem::Version 
+  version: 0.9.21
+platform: ruby
+authors: 
+- Kenneth Kalmer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-31 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruote
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.21
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: amqp
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.6.7
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.4.0
+    version: 
+description: |-
+  ruote-amqp provides an AMQP participant/listener pair that allows you to 
+  distribute workitems out to AMQP consumers for processing.
+  
+  To learn more about remote participants in ruote please see
+  http://openwfe.rubyforge.org/part.html
+email: 
+- kenneth.kalmer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- TODO.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- TODO.txt
+- lib/ruote-amqp.rb
+- lib/ruote-amqp/listener.rb
+- lib/ruote-amqp/participant.rb
+- lib/spec/ruote.rb
+- lib/spec/ruote_example_group.rb
+- lib/spec/ruote_helpers.rb
+- lib/spec/ruote_matchers.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/listener_spec.rb
+- spec/participant_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/kennethkalmer/ruote-amqp
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+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: simianarmy-ruote-amqp
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ruote-amqp provides an AMQP participant/listener pair that allows you to  distribute workitems out to AMQP consumers for processing
+test_files: []
+