ruote-stomp-maestrodev 2.2.2

data/lib/ruote-stomp/receiver.rb

@@ -0,0 +1,146 @@
+require 'ruote-stomp'
+
+module RuoteStomp
+
+  #
+  # = Stomp Receiver
+  #
+  # Used in conjunction with the RuoteStomp::Participant, the WorkitemListener
+  # subscribes to a specific direct exchange and monitors for
+  # incoming workitems. It expects workitems to arrive serialized as
+  # JSON.
+  #
+  # == Configuration
+  #
+  # Stomp configuration is handled by directly manipulating the values of
+  # the +Stomp.settings+ hash, as provided by the Stomp gem. No
+  # defaults are set by the listener. The only +option+ parsed by
+  # the initializer of the workitem listener is the +queue+ key (Hash
+  # expected). If no +queue+ key is set, the listener will subscribe
+  # to the +ruote_workitems+ direct exchange for workitems, otherwise it will
+  # subscribe to the direct exchange provided.
+  #
+  # == Usage
+  #
+  # Register the engine or storage with the listener:
+  #
+  #   RuoteStomp::Receiver.new(engine_or_storage)
+  #
+  # The workitem listener leverages the asynchronous nature of the stomp gem,
+  # so no timers are setup when initialized.
+  #
+  # == Options
+  #
+  # :queue and :launchitems
+  #
+  # See the RuoteStomp::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 Receiver < Ruote::Receiver
+
+    attr_reader :queue
+
+    # Starts a new Receiver
+    #
+    # Two arguments for this method.
+    #
+    # The first one should be a Ruote::Engine, a Ruote::Storage or
+    # a Ruote::Worker instance.
+    #
+    # The second one is a hash for options. There are two known options :
+    #
+    # :queue for setting the queue on which to listen (defaults to
+    # 'ruote_workitems').
+    #
+    # :ignore_disconnect_on_process => true|false (defauts to false)
+    # processes the message even if the client has disconnected (use in testing only)
+    # 
+    # The :launchitems option :
+    #
+    #   :launchitems => true
+    #     # the receiver accepts workitems and launchitems
+    #   :launchitems => false
+    #     # the receiver only accepts workitems
+    #   :launchitems => :only
+    #     # the receiver only accepts launchitems
+    #
+    def initialize(engine_or_storage, opts={})
+
+      super(engine_or_storage)
+
+      @launchitems = opts[:launchitems]
+      ignore_disconnect = opts[:ignore_disconnect_on_process]
+
+      @queue =
+        opts[:queue] ||
+        (@launchitems == :only ? '/queue/ruote_launchitems' : '/queue/ruote_workitems')
+
+      RuoteStomp.start!
+
+      if opts[:unsubscribe]
+        begin
+          $stomp.unsubscribe(@queue)
+        rescue OnStomp::UnsupportedCommandError => e
+          $stderr.puts("Connection does support unsubscribe")
+        end
+      end
+
+      $stomp.subscribe(@queue) do |message|
+        # Process your message here
+        # Your submitted data is in msg.body
+        if $stomp.connected? && !ignore_disconnect
+          # do nothing, we're going down
+        else
+          handle(message)
+        end
+      end
+    end
+    
+    def stop
+      RuoteStomp.stop!
+    end
+
+    # (feel free to overwrite me)
+    #
+    def decode_workitem(msg)
+      (Rufus::Json.decode(msg) rescue nil)
+    end
+
+    private
+
+    def handle(msg)
+      item = decode_workitem(msg.body)
+      return unless item.is_a?(Hash)
+      not_li = ! item.has_key?('definition')
+      return if @launchitems == :only && not_li
+      return unless @launchitems || not_li
+
+      if not_li
+        receive(item) # workitem resumes in its process instance
+      else
+        launch(item) # new process instance launch
+      end
+
+    rescue => e
+      # something went wrong
+      # let's simply discard the message
+      $stderr.puts('=' * 80)
+      $stderr.puts(self.class.name)
+      $stderr.puts("couldn't handle incoming message :")
+      $stderr.puts('')
+      $stderr.puts(msg.inspect)
+      $stderr.puts('')
+      $stderr.puts(Rufus::Json.pretty_encode(item)) rescue nil
+      $stderr.puts('')
+      $stderr.puts(e.inspect)
+      $stderr.puts(e.backtrace)
+      $stderr.puts('=' * 80)
+    end
+
+    def launch(hash)
+      super(hash['definition'], hash['fields'] || {}, hash['variables'] || {})
+    end
+  end
+end

data/lib/ruote-stomp/version.rb

@@ -0,0 +1,4 @@
+module RuoteStomp
+  VERSION = '2.2.2'
+end
+

data/lib/ruote-stomp/workitem_listener.rb

@@ -0,0 +1,11 @@
+module RuoteStomp
+
+  #
+  # Got replaced by RuoteStomp::Receiver
+  #
+  # This class is kept for backward compatibility.
+  #
+  class WorkitemListener < ::RuoteStomp::Receiver
+  end
+end
+

data/ruote-stomp.gemspec

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+
+  s.name = 'ruote-stomp-maestrodev'
+  s.version = File.read('lib/ruote-stomp/version.rb').match(/VERSION = '([^']+)'/)[1]
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'Kit Plummer', 'Brian Sam-Bodden' ]
+  s.email = [ 'kplummer@maestrodev.com', 'bsbodden@integrallis.com' ]
+  s.homepage = 'http://ruote.rubyforge.org'
+  s.rubyforge_project = 'ruote'
+  s.summary = 'Stomp participant/listener pair for ruote 2.2'
+  s.description = 'Stomp participant/listener pair for ruote 2.2'
+
+  s.files = Dir[
+    'Rakefile',
+    'lib/**/*.rb', 'spec/**/*.rb', 'test/**/*.rb',
+    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+  ]
+
+  s.add_runtime_dependency 'onstomp', "~> 1.0.4"
+  s.add_runtime_dependency 'ruote', "~> 2.2.0"
+  s.add_runtime_dependency 'json'
+  s.add_runtime_dependency 'parslet'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', ">= 2.6.0"
+  s.add_development_dependency 'stompserver', '~> 0.9.9'
+
+  s.require_path = 'lib'
+end
+

data/spec/launchitem_listener_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe RuoteStomp::LaunchitemListener do
+
+  after(:each) do
+    purge_engine
+  end
+
+  it 'launches processes' do
+
+    json = {
+      'definition' => %{
+        Ruote.process_definition :name => 'test' do
+          sequence do
+            echo '${f:foo}'
+          end
+        end
+      },
+      'fields' => { 'foo' => 'bar' }
+    }.to_json
+
+    RuoteStomp::LaunchitemListener.new(@engine, :ignore_disconnect_on_process => true)
+
+    finished_processing = false
+
+    $stomp.send('/queue/ruote_launchitems', json) do |r|
+      finished_processing = true
+    end
+    
+    begin
+      Timeout::timeout(10) do
+        while @tracer.to_s.empty?
+          print "*"
+          sleep 1
+        end
+      end
+    rescue Timeout::Error
+      fail "Timeout waiting for message"
+    end
+    
+    Thread.pass until finished_processing
+
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+    @tracer.to_s.should == 'bar'
+  end
+
+  it 'discards corrupt process definitions' do
+  
+    json = {
+      'definition' => %{
+        I'm a broken process definition
+      },
+      'fields' => { 'foo' => 'bar' }
+    }.to_json
+  
+    RuoteStomp::LaunchitemListener.new(@engine, {:unsubscribe => true, :ignore_disconnect_on_process => true})
+  
+    serr = String.new
+    err = StringIO.new(serr, 'w+')
+    $stderr = err
+  
+    $stomp.send '/queue/ruote_launchitems', json
+  
+    sleep 0.5
+  
+    err.close
+    $stderr = STDERR
+  
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+  
+    @tracer.to_s.should == ''
+  
+    serr.should match(/^===/)
+  end
+end
+

data/spec/participant_spec.rb

@@ -0,0 +1,204 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+describe RuoteStomp::ParticipantProxy, :type => :ruote do
+
+  after(:each) do
+    purge_engine
+  end
+  
+  it "supports 'forget' as participant attribute" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :queue => '/queue/test1', :forget => true
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == 'done.'
+
+    begin
+      Timeout::timeout(10) do
+        @msg = nil
+        $stomp.subscribe("/queue/test1") do |message|
+          @msg = message.body
+        end
+        
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      fail "Timeout waiting for message"
+    end
+
+    @msg.should match(/^\{.*\}$/) # JSON message by default
+  end
+
+  it "supports 'forget' as participant option" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :queue => '/queue/test4'
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(
+      :stomp, RuoteStomp::ParticipantProxy, 'forget' => true)
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == "done."
+
+    begin
+      Timeout::timeout(5) do
+        @msg = nil
+        $stomp.subscribe("/queue/test4", {}) do |message|
+          @msg = message.body
+        end
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      fail "Timeout waiting for message"
+    end
+
+    @msg.should match(/^\{.*\}$/) # JSON message by default
+  end
+
+  it "supports custom messages instead of workitems" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :queue => '/queue/test2', :message => 'foo', :forget => true
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == "done."
+
+    begin
+      Timeout::timeout(5) do
+        @msg = nil
+        $stomp.subscribe("/queue/test2") do |message|
+          @msg = message.body
+        end
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      fail "Timeout waiting for message"
+    end
+
+    @msg.should == 'foo'
+  end
+
+  it "supports 'queue' as a participant option" do
+  
+      pdef = ::Ruote.process_definition :name => 'test' do
+        sequence do
+          stomp :forget => true
+          echo 'done.'
+        end
+      end
+  
+      @engine.register_participant(
+        :stomp, RuoteStomp::ParticipantProxy, 'queue' => '/queue/test5')
+  
+      run_definition(pdef)
+  
+      @tracer.to_s.should == 'done.'
+  
+      begin
+        Timeout::timeout(5) do
+          @msg = nil
+          $stomp.subscribe("/queue/test5") do |message|
+            @msg = message.body
+          end
+          loop do
+            break unless @msg.nil?
+            sleep 0.1
+          end
+        end
+      rescue Timeout::Error
+        fail "Timeout waiting for message"
+      end
+    end
+
+  it "passes 'participant_options' over stomp" do
+  
+    pdef = ::Ruote.process_definition :name => 'test' do
+      stomp :queue => '/queue/stomp', :forget => true
+    end
+  
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+  
+    run_definition(pdef)
+  
+    msg = nil
+  
+    begin
+      Timeout::timeout(10) do
+  
+        #MQ.queue('test6', :durable => true).subscribe { |m| msg = m }
+        $stomp.subscribe("/queue/stomp") do |message|
+          msg = message.body
+        end
+        loop do
+          break unless msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      fail "Timeout waiting for message"
+    end
+  
+    wi = Rufus::Json.decode(msg)
+    params = wi['fields']['params']
+  
+    params['queue'].should == '/queue/stomp'
+    params['forget'].should == true
+    params['participant_options'].should == { 'forget' => false, 'queue' => nil }
+  end
+
+  # it "doesn't create 1 queue instance per delivery" do
+  #     
+  #         pdef = ::Ruote.process_definition do
+  #           stomp :queue => 'test7', :forget => true
+  #         end
+  #     
+  #         mq_count = 0
+  #         ObjectSpace.each_object($stomp) { |o| stomp_count += 1 }
+  #     
+  #         @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+  #     
+  #         10.times do
+  #           run_definition(pdef)
+  #         end
+  #     
+  #         sleep 1
+  #     
+  #         count = 0
+  #         ObjectSpace.each_object($stomp) { |o| count += 1 }
+  #     
+  #         count.should == stomp_count + 1
+  #       end
+end
+