ruote-stomp 2.2.0.a

data/lib/ruote-stomp/receiver.rb

@@ -0,0 +1,156 @@
+
+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').
+    #
+    # 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]
+
+      @queue =
+        opts[:queue] ||
+        (@launchitems == :only ? '/queue/ruote_launchitems' : '/queue/ruote_workitems')
+
+      RuoteStomp.start!
+
+      if opts[:unsubscribe]
+        #MQ.queue(@queue, :durable => true).unsubscribe
+        $stomp.unsubscribe(@queue)
+        sleep 0.300
+      end
+      
+      $stomp.subscribe(@queue, {}) do |message|
+        # Process your message here
+        # Your submitted data is in msg.body
+        if $stomp.closed?
+          # do nothing, we're going down
+        else
+          handle(message)
+        end
+      end
+      #$stomp.join # Wait until listening thread dies
+      
+      # MQ.queue(@queue, :durable => true).subscribe do |message|
+      #   if AMQP.closing?
+      #     # 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,6 @@
+
+module RuoteStomp
+
+  VERSION = '2.2.0.a'
+end
+

data/lib/ruote-stomp/workitem_listener.rb

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

data/lib/ruote-stomp.rb

@@ -0,0 +1,96 @@
+require 'stomp'
+
+require 'ruote-stomp/version'
+
+
+#
+# Stomp participant and listener pair for ruote.
+#
+# == Documentation
+#
+# See #RuoteStomp::Listener and #RuoteStomp::Participant for detailed
+# documentation on using each of them.
+#
+# == Stomp Notes
+#
+# RuoteAmqp uses durable queues and persistent messages by default, to ensure
+# no messages get lost along the way and that running expressions doesn't have
+# to be restarted in order for messages to be resent. <- not exactly sure yet
+# how RuoteStomp will handle durable queues, messages are persisted.
+#
+module RuoteStomp
+
+  autoload 'ParticipantProxy',   'ruote-stomp/participant'
+
+  autoload 'Receiver',           'ruote-stomp/receiver'
+  autoload 'WorkitemListener',   'ruote-stomp/workitem_listener'
+  autoload 'LaunchitemListener', 'ruote-stomp/launchitem_listener'
+
+  class << self
+
+    attr_writer :use_persistent_messages
+    
+    # Whether or not to use persistent messages (true by default)
+    def use_persistent_messages?
+      @use_persistent_messages = true if @use_persistent_messages.nil?
+      @use_persistent_messages
+    end
+
+    # Ensure the Stomp connection is started
+    def start!
+      return if started?
+
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+
+      Thread.main[:ruote_stomp_connection] = Thread.new do
+        Thread.abort_on_exception = true
+        
+        begin
+          $stomp = Stomp::Client.new STOMP.settings[:user], 
+                                     STOMP.settings[:passcode], 
+                                     STOMP.settings[:host], 
+                                     STOMP.settings[:port], 
+                                     STOMP.settings[:reliable]
+          if $stomp
+            started!
+            cv.signal
+          end
+        rescue
+          raise RuntimeError, "Failed to connect to Stomp server."
+        end
+      end
+
+      mutex.synchronize { cv.wait(mutex) }
+
+      # Stomp equivalent?
+      #MQ.prefetch(1)
+
+      yield if block_given?
+    end
+
+    # Check whether the AMQP connection is started
+    def started?
+      Thread.main[:ruote_stomp_started] == true
+    end
+
+    def started! #:nodoc:
+      Thread.main[:ruote_stomp_started] = true
+    end
+
+    # Close down the Stomp connections
+    def stop!
+      return unless started?
+      $stomp.close
+      Thread.main[:ruote_stomp_connection].join
+      Thread.main[:ruote_stomp_started] = false
+    end
+  end
+end
+
+module STOMP
+  def self.settings
+    @settings ||= {:host => "localhost", :port => "61613", :reliable => false}
+  end
+end
+

data/ruote-stomp.gemspec

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+
+  s.name = 'ruote-stomp'
+  s.version = File.read('lib/ruote-stomp/version.rb').match(/VERSION = '([^']+)'/)[1]
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'Kit Plummer' ]
+  s.email = [ 'kplummer@maestrodev.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 - ported from ruote-amqp.
+  }
+
+  #s.files = `git ls-files`.split("\n")
+  s.files = Dir[
+    'Rakefile',
+    'lib/**/*.rb', 'spec/**/*.rb', 'test/**/*.rb',
+    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+  ]
+
+  #s.add_runtime_dependency 'stmop'
+  s.add_runtime_dependency 'stomp', '1.1.8'
+  s.add_runtime_dependency 'ruote', ">= #{s.version}"
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', ">= 2.6.3"
+  s.add_development_dependency 'stompserver', '~> 0.9.9'
+
+  s.require_path = 'lib'
+end
+

data/spec/launchitem_listener_spec.rb

@@ -0,0 +1,68 @@
+
+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)
+
+    $stomp.publish '/queue/ruote_launchitems', json, { :persistent => true }
+    #MQ.queue('ruote_launchitems', :durable => true).publish(json)
+
+    sleep 0.5
+
+    @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)
+
+    serr = String.new
+    err = StringIO.new(serr, 'w+')
+    $stderr = err
+
+    $stomp.publish '/queue/ruote_launchitems', json, { :persistent => true }
+
+    #MQ.queue('ruote_launchitems', :durable => true).publish(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,208 @@
+
+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
+        #MQ.queue('test1', :durable => true).subscribe { |msg| @msg = msg }
+        $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
+        #MQ.queue('test2', :durable => true).subscribe { |msg| @msg = msg }
+        $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
+          #MQ.queue('test5', :durable => true).subscribe { |msg| @msg = msg }
+          $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
+