ruote-amqp 2.2.0 → 2.3.0

data/ruote-amqp.gemspec

@@ -1,17 +1,20 @@
-# encoding: utf-8
 
 Gem::Specification.new do |s|
 
   s.name = 'ruote-amqp'
-  s.version = File.read('lib/ruote-amqp/version.rb').match(/VERSION = '([^']+)'/)[1]
+
+  s.version = File.read(
+    File.expand_path('../lib/ruote/amqp/version.rb', __FILE__)
+  ).match(/ VERSION *= *['"]([^'"]+)/)[1]
+
   s.platform = Gem::Platform::RUBY
   s.authors = [ 'Kenneth Kalmer', 'John Mettraux' ]
   s.email = [ 'kenneth.kalmer@gmail.com', 'jmettraux@gmail.com' ]
   s.homepage = 'http://ruote.rubyforge.org'
   s.rubyforge_project = 'ruote'
-  s.summary = 'AMQP participant/listener pair for ruote 2.1'
+  s.summary = 'AMQP participant/listener pair for ruote'
   s.description = %{
-AMQP participant/listener pair for ruote 2.1
+AMQP participant/listener pair for ruote
   }
 
   #s.files = `git ls-files`.split("\n")
@@ -21,11 +24,11 @@ AMQP participant/listener pair for ruote 2.1
     '*.gemspec', '*.txt', '*.rdoc', '*.md'
   ]
 
-  s.add_runtime_dependency 'amqp', '0.7.0'
+  s.add_runtime_dependency 'amqp', '~> 0.9'
   s.add_runtime_dependency 'ruote', ">= #{s.version}"
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', ">= 2.2.1"
+  s.add_development_dependency 'rspec', '~> 2.8'
 
   s.require_path = 'lib'
 end

data/spec/alert_participant_spec.rb

@@ -0,0 +1,58 @@
+
+require 'spec_helper'
+
+
+describe Ruote::Amqp::AlertParticipant do
+
+  before(:all) do
+
+    ensure_em_is_running
+  end
+
+  before(:each) do
+
+    @dashboard = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::HashStorage.new))
+
+    @dashboard.noisy = ENV['NOISY'].to_s == 'true'
+  end
+
+  after(:each) do
+
+    @dashboard.shutdown
+  end
+
+  it 'lets the flow resume upon receiving a message' do
+
+    @dashboard.register(
+      :snare,
+      Ruote::Amqp::AlertParticipant,
+      :queue => 'x')
+
+    pdef = Ruote.define do
+      snare
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    sleep 0.100 # let some time for the alert participant to settle in
+
+    exchange = AMQP::Exchange.new(AMQP::Channel.new, :direct, '')
+    exchange.publish('nada', :routing_key => 'x')
+
+    r = @dashboard.wait_for(wfid)
+
+    r['action'].should == 'terminated'
+
+    r['workitem']['fields'].should == {
+      'amqp_message' => [
+        {
+          'content_type' => 'application/octet-stream',
+          'priority' => 0,
+          'delivery_mode' => 1
+        },
+        'nada'
+      ]
+    }
+  end
+end
+

data/spec/participant_spec.rb

@@ -1,192 +1,338 @@
 
-require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'spec_helper'
 
 
-describe RuoteAMQP::ParticipantProxy, :type => :ruote do
+describe Ruote::Amqp::Participant do
 
-  it "supports 'forget' as participant attribute" do
+  before(:all) do
 
-    pdef = ::Ruote.process_definition :name => 'test' do
-      sequence do
-        amqp :queue => 'test1', :forget => true
-        echo 'done.'
-      end
+    ensure_em_is_running
+  end
+
+  before(:each) do
+
+    @dashboard = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::HashStorage.new))
+
+    @dashboard.noisy = ENV['NOISY'].to_s == 'true'
+  end
+
+  after(:each) do
+
+    @dashboard.shutdown
+    @queue.delete rescue nil
+  end
+
+  it 'publishes messages on the given exchange' do
+
+    @dashboard.register(
+      :toto,
+      Ruote::Amqp::Participant,
+      :exchange => [ 'direct', '' ],
+      :routing_key => 'alpha',
+      :forget => true)
+
+    wi = nil
+
+    @queue = AMQP::Channel.new.queue('alpha')
+    @queue.subscribe { |headers, payload| wi = Rufus::Json.decode(payload) }
+
+    sleep 0.1
+
+    pdef = Ruote.define do
+      toto
     end
 
-    @engine.register_participant(:amqp, RuoteAMQP::ParticipantProxy)
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
 
-    run_definition(pdef)
+    r['action'].should == 'terminated'
 
-    @tracer.to_s.should == 'done.'
+    sleep 0.1
 
-    begin
-      Timeout::timeout(10) do
-        @msg = nil
-        MQ.queue('test1', :durable => true).subscribe { |msg| @msg = msg }
+    wi['participant_name'].should == 'toto'
+  end
 
-        loop do
-          break unless @msg.nil?
-          sleep 0.1
-        end
-      end
-    rescue Timeout::Error
-      violated "Timeout waiting for message"
+  it 'blocks if :forget is not set to true' do
+
+    @dashboard.register(
+      :toto,
+      Ruote::Amqp::Participant,
+      :exchange => [ 'direct', '' ],
+      :routing_key => 'alpha')
+
+    wi = nil
+
+    @queue = AMQP::Channel.new.queue('alpha')
+    @queue.subscribe { |headers, payload| wi = Rufus::Json.decode(payload) }
+
+    sleep 0.1
+
+    pdef = Ruote.define do
+      toto
     end
 
-    @msg.should match(/^\{.*\}$/) # JSON message by default
+    wfid = @dashboard.launch(pdef, 'customer' => 'taira no kiyomori')
+    @dashboard.wait_for('dispatched')
+
+    sleep 0.1
+
+    wi['fields']['customer'].should == 'taira no kiyomori'
+
+    @dashboard.ps(wfid).expressions.size.should == 2
   end
 
-  it "supports 'forget' as participant option" do
+  it 'supports :forget as a participant attribute' do
 
-    pdef = ::Ruote.process_definition :name => 'test' do
-      sequence do
-        amqp :queue => 'test4'
-        echo 'done.'
-      end
+    @dashboard.register(
+      :toto,
+      Ruote::Amqp::Participant,
+      :exchange => [ 'direct', '' ],
+      :routing_key => 'alpha')
+
+    wi = nil
+
+    @queue = AMQP::Channel.new.queue('alpha')
+    @queue.subscribe { |headers, payload| wi = Rufus::Json.decode(payload) }
+
+    pdef = Ruote.define do
+      toto :forget => true
     end
 
-    @engine.register_participant(
-      :amqp, RuoteAMQP::ParticipantProxy, 'forget' => true)
+    wfid = @dashboard.launch(pdef, 'customer' => 'minamoto no yoshitomo')
+    r = @dashboard.wait_for(wfid)
+
+    r['action'].should == 'terminated'
 
-    run_definition(pdef)
+    sleep 0.1
 
-    @tracer.to_s.should == "done."
+    wi['fields']['customer'].should == 'minamoto no yoshitomo'
+  end
 
-    begin
-      Timeout::timeout(5) do
-        @msg = nil
-        MQ.queue('test4', :durable => true).subscribe { |msg| @msg = msg }
+  it 'supports the :message option' do
 
-        loop do
-          break unless @msg.nil?
-          sleep 0.1
-        end
-      end
-    rescue Timeout::Error
-      violated "Timeout waiting for message"
+    @dashboard.register(
+      :alpha,
+      Ruote::Amqp::Participant,
+      :exchange => [ 'direct', '' ],
+      :routing_key => 'alpha',
+      :message => 'hello world!',
+      :forget => true)
+
+    msg = nil
+
+    @queue = AMQP::Channel.new.queue('alpha')
+    @queue.subscribe { |headers, payload| msg = payload }
+
+    sleep 0.1
+
+    pdef = Ruote.define do
+      alpha
     end
 
-    @msg.should match(/^\{.*\}$/) # JSON message by default
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
+
+    sleep 0.1
+
+    msg.should == 'hello world!'
   end
 
-  it "supports custom messages instead of workitems" do
+  it 'publishes messages with the given correlation-id' do
 
-    pdef = ::Ruote.process_definition :name => 'test' do
-      sequence do
-        amqp :queue => 'test2', :message => 'foo', :forget => true
-        echo 'done.'
-      end
+    @dashboard.register(
+      :toto,
+      Ruote::Amqp::Participant,
+      :exchange => [ 'direct', '' ],
+      :routing_key => 'alpha',
+      :correlation_id => 'beta',
+      :forget => true)
+
+    correlation_id = nil
+
+    @queue = AMQP::Channel.new.queue('alpha')
+    @queue.subscribe { |headers, payload| correlation_id = headers.correlation_id }
+
+    sleep 0.1
+
+    pdef = Ruote.define do
+      toto
     end
 
-    @engine.register_participant(:amqp, RuoteAMQP::ParticipantProxy)
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
+
+    sleep 0.1
 
-    run_definition(pdef)
+    correlation_id.should == 'beta'
+  end
+
+  it 'reuses channels and exchanges within a thread' do
 
-    @tracer.to_s.should == "done."
+    @dashboard.register(
+      :alpha,
+      Ruote::Amqp::Participant,
+      :exchange => [ 'direct', '' ],
+      :routing_key => 'alpha',
+      :message => 'hello world!',
+      :forget => true)
 
-    begin
-      Timeout::timeout(5) do
-        @msg = nil
-        MQ.queue('test2', :durable => true).subscribe { |msg| @msg = msg }
+    c0 = count_amqp_objects
 
-        loop do
-          break unless @msg.nil?
-          sleep 0.1
-        end
+    wfid = @dashboard.launch(Ruote.define do
+      concurrence do
+        10.times { alpha }
       end
-    rescue Timeout::Error
-      violated "Timeout waiting for message"
-    end
+    end)
+
+    @dashboard.wait_for(2 + 3 * 10)
+
+    c1 = count_amqp_objects
 
-    @msg.should == 'foo'
+    3.times { GC.start }
+    sleep 2
+      # doesn't change much...
+
+    c2 = count_amqp_objects
+
+    c2.should == c1
+    c1['AMQP::Channel'].should == (c0['AMQP::Channel'] || 0) + 1
+    c1['AMQP::Exchange'].should == (c0['AMQP::Exchange'] || 0) + 1
   end
 
-  it "supports 'queue' as a participant option" do
+  context 'cancelitems' do
+
+    it 'publishes "cancelitems"' do
+
+      @dashboard.register(
+        :toto,
+        Ruote::Amqp::Participant,
+        :exchange => [ 'direct', '' ],
+        :routing_key => 'alpha')
+
+      msgs = []
 
-    pdef = ::Ruote.process_definition :name => 'test' do
-      sequence do
-        amqp :forget => true
-        echo 'done.'
+      @queue = AMQP::Channel.new.queue('alpha')
+      @queue.subscribe { |headers, payload| msgs << [ headers, payload ] }
+
+      pdef = Ruote.define do
+        toto
       end
+
+      wfid = @dashboard.launch(pdef)
+      @dashboard.wait_for('dispatched')
+
+      sleep 0.1
+
+      @dashboard.cancel(wfid)
+
+      sleep 0.1
+
+      msgs.size.should == 2
+
+      items = msgs.collect { |msg| Rufus::Json.decode(msg.last) }
+
+      items.first['participant_name'].should == 'toto'
+
+      items.last.keys.sort.should == %w[ cancel fei flavour ]
+      items.last['cancel'].should == true
+      items.last['fei']['wfid'].should == wfid
+      items.last['flavour'].should == nil
     end
 
-    @engine.register_participant(
-      :amqp, RuoteAMQP::ParticipantProxy, 'queue' => 'test5')
+    it "doesn't publish \"cancelitems\" if 'discard_cancel' => true" do
 
-    run_definition(pdef)
+      @dashboard.register(
+        :toto,
+        Ruote::Amqp::Participant,
+        :exchange => [ 'direct', '' ],
+        :routing_key => 'alpha',
+        :discard_cancel => true)
 
-    @tracer.to_s.should == 'done.'
+      msgs = []
 
-    begin
-      Timeout::timeout(5) do
-        @msg = nil
-        MQ.queue('test5', :durable => true).subscribe { |msg| @msg = msg }
+      @queue = AMQP::Channel.new.queue('alpha')
+      @queue.subscribe { |headers, payload| msgs << [ headers, payload ] }
 
-        loop do
-          break unless @msg.nil?
-          sleep 0.1
-        end
+      pdef = Ruote.define do
+        toto
       end
-    rescue Timeout::Error
-      violated "Timeout waiting for message"
+
+      wfid = @dashboard.launch(pdef)
+      @dashboard.wait_for('dispatched')
+
+      sleep 0.1
+
+      @dashboard.cancel(wfid)
+
+      sleep 0.1
+
+      msgs.size.should == 1
     end
   end
 
-  it "passes 'participant_options' over amqp" do
+  context 'Ruote::Amqp.session' do
+
+    after(:each) do
 
-    pdef = ::Ruote.process_definition :name => 'test' do
-      amqp :queue => 'test6', :forget => true
+      Ruote::Amqp.session = nil
     end
 
-    @engine.register_participant(:amqp, RuoteAMQP::ParticipantProxy)
+    it 'uses Ruote::Amqp.session if set for connecting to AMQP' do
 
-    run_definition(pdef)
+      Ruote::Amqp.session = 'fail!'
 
-    msg = nil
+      @dashboard.register(
+        :toto,
+        Ruote::Amqp::Participant,
+        :exchange => [ 'direct', '' ],
+        :routing_key => 'alpha',
+        :forget => true)
 
-    begin
-      Timeout::timeout(10) do
+      pdef = Ruote.define do
+        toto
+      end
 
-        MQ.queue('test6', :durable => true).subscribe { |m| msg = m }
+      wfid = @dashboard.launch(pdef)
+      r = @dashboard.wait_for(wfid)
 
-        loop do
-          break unless msg.nil?
-          sleep 0.1
-        end
-      end
-    rescue Timeout::Error
-      violated "Timeout waiting for message"
-    end
+      r['action'].should == 'error_intercepted'
 
-    wi = Rufus::Json.decode(msg)
-    params = wi['fields']['params']
+      r['error']['class'].should ==
+        'NoMethodError'
+      r['error']['message'].should ==
+        "undefined method `auto_recovering?' for \"fail!\":String"
+    end
 
-    params['queue'].should == 'test6'
-    params['forget'].should == true
-    params['participant_options'].should == { 'forget' => false, 'queue' => nil }
-  end
+    it "doesn't use Ruote::Amqp.session if a 'connection' option is given" do
 
-  it "doesn't create 1 queue instance per delivery" do
+      Ruote::Amqp.session = 'do fail now!'
 
-    pdef = ::Ruote.process_definition do
-      amqp :queue => 'test7', :forget => true
-    end
+      @dashboard.register(
+        :toto,
+        Ruote::Amqp::Participant,
+        :exchange => [ 'direct', '' ],
+        :routing_key => 'alpha',
+        :forget => true,
+        :connection => {})
 
-    mq_count = 0
-    ObjectSpace.each_object(MQ) { |o| mq_count += 1 }
+      wi = nil
 
-    @engine.register_participant(:amqp, RuoteAMQP::ParticipantProxy)
+      @queue = AMQP::Channel.new.queue('alpha')
+      @queue.subscribe { |headers, payload| wi = Rufus::Json.decode(payload) }
 
-    10.times do
-      run_definition(pdef)
-    end
+      sleep 0.1
 
-    sleep 1
+      pdef = Ruote.define do
+        toto
+      end
 
-    count = 0
-    ObjectSpace.each_object(MQ) { |o| count += 1 }
+      wfid = @dashboard.launch(pdef)
+      r = @dashboard.wait_for(wfid)
+      sleep 0.1
 
-    count.should == mq_count + 1
+      r['action'].should == 'terminated'
+      wi['participant_name'].should == 'toto'
+    end
   end
 end
 

data/spec/participant_subclass_spec.rb

@@ -0,0 +1,66 @@
+
+require 'spec_helper'
+
+
+describe 'X < Ruote::Amqp::Participant' do
+
+  before(:all) do
+
+    ensure_em_is_running
+  end
+
+  before(:each) do
+
+    @dashboard = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::HashStorage.new))
+
+    @dashboard.noisy = ENV['NOISY'].to_s == 'true'
+  end
+
+  after(:each) do
+
+    @dashboard.shutdown
+    @queue.delete rescue nil
+  end
+
+  context 'RoutingKeyParticipant' do
+
+    #
+    # Sample subclass, simply uses the participant name as the routing_key.
+    #
+    class RoutingKeyParticipant < Ruote::Amqp::Participant
+
+      def routing_key
+
+        @workitem.participant_name
+      end
+    end
+
+    it 'sets the routing key to the participant name' do
+
+      @dashboard.register(
+        /.+/, RoutingKeyParticipant, :forget => true)
+
+      wi = nil
+
+      @queue = AMQP::Channel.new.queue('alpha')
+      @queue.subscribe { |headers, payload| wi = Rufus::Json.decode(payload) }
+
+      sleep 0.1
+
+      pdef = Ruote.define do
+        alpha
+      end
+
+      wfid = @dashboard.launch(pdef, 'customer' => 'goshirakawa')
+      r = @dashboard.wait_for(wfid)
+
+      r['action'].should == 'terminated'
+
+      sleep 0.1
+
+      wi['participant_name'].should == 'alpha'
+      wi['fields']['customer'].should == 'goshirakawa'
+    end
+  end
+end
+