ruote-amqp 0.9.21.1 → 2.1.5

data/.gitignore

@@ -0,0 +1,6 @@
+*.swp
+work/
+logs/
+pkg/
+.yardoc
+doc/

data/History.txt

@@ -1,3 +1,10 @@
+=== 2.0.0 (WIP)
+
+* Compatible with ruote 2.0
+  * Thanks to John Mettraux (http://github.com/jmettraux/ruote-amqp)
+  * Thanks to Jason & Jordan (http://github.com/asm/ruote-amqp)
+  * Thanks to Charles Magid (http://github.com/ChasManRors/ruote-amqp)
+
 === 0.9.21.1 2009-08-03
 
 * Switch to using persistent AMQP messages by default

data/Manifest.txt

@@ -5,7 +5,8 @@ README.rdoc
 Rakefile
 TODO.txt
 lib/ruote-amqp.rb
-lib/ruote-amqp/listener.rb
+lib/ruote-amqp/launchitem_listener.rb
+lib/ruote-amqp/workitem_listener.rb
 lib/ruote-amqp/participant.rb
 lib/spec/ruote.rb
 lib/spec/ruote_example_group.rb
@@ -14,7 +15,8 @@ lib/spec/ruote_matchers.rb
 script/console
 script/destroy
 script/generate
-spec/listener_spec.rb
+spec/launchitem_listener_spec.rb
+spec/workitem_listener_spec.rb
 spec/participant_spec.rb
 spec/ruote_amqp_spec.rb
 spec/spec.opts

data/README.rdoc

@@ -1,54 +1,58 @@
 = ruote-amqp
 
 * http://github.com/kennethkalmer/ruote-amqp
-* http://openwfe.rubyforge.org
+* http://rdoc.info/projects/kennethkalmer/ruote-amqp
+* http://ruote.rubyforge.org
 
 == DESCRIPTION:
 
 ruote-amqp provides an AMQP participant/listener pair that allows you to 
-distribute workitems out to AMQP consumers for processing.
+distribute workitems out to AMQP consumers for processing, as well as launching
+processes over AMQP.
 
 To learn more about remote participants in ruote please see
-http://openwfe.rubyforge.org/part.html
+http://ruote.rubyforge.org/part_implementations.html
 
 == FEATURES/PROBLEMS:
 
 * Flexible participant for sending workitems
 * Flexible listener for receiving replies
+* Flexible launch item listener for launching processes over AMQP
 * Fully evented (thanks to the amqp gem)
 
 == SYNOPSIS:
 
-Please review the detailed RDOC in RuoteAMQP::Participant and Ruote::AMQP::Listener
+Please review the 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
+* ruote[http://ruote.rubyforge.org] 2.1.4 or later
+* amqp[http://github.com/tmm1/amqp] 0.6.6 or later
+* rufus-json[http://github.com/jmettraux/rufus-json] 0.1.0 or later
+* rabbitmq[http://www.rabbitmq.com/] 1.6.0 or later
 
-NOTE: It might be required that you build the amqp gem yourself.
+== INSTALL:
 
-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:
+Please be sure to have read the requirements section above
 
-  $ git clone git://github.com/jmettraux/ruote.git
-  $ cd ruote
-  $ rake gem
-  $ sudo gem install pkg/ruote-0.9.21.gem
+* sudo gem install ruote-amqp
 
-Please note that this requires Rubygems 1.3.2 or newer to work
+== TESTS:
 
-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:
+To run the tests you need the following requirements met, or the testing environment
+will fail horribly.
 
-  $ sudo gem install ruote-amqp -v 0.9.20
+=== RabbitMQ vhost
 
-== INSTALL:
+The tests use dedicated vhost on a running AMQP broker. To configure RabbitMQ
+you can run the following commands:
 
-Please be sure to have read the requirements section above
+  # rabbitmqctl add_vhost ruote-test
+  # rabbitmqctl add_user ruote ruote
+  # rabbitmqctl set_permissions -p ruote-test ruote '.*' '.*' '.*'
 
-* sudo gem install ruote-amqp
+If you need to change the AMQP configuration used by the tests, edit the
++spec/spec_helper.rb+ file.
 
 == DAEMON-KIT:
 
@@ -59,11 +63,13 @@ to write your remote participants.
 daemon-kit offers plenty of convenience for remote participants and includes
 a code generator for ruote remote participants.
 
+DaemonKit doesn't currently support ruote 2.1, support is forthcoming.
+
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2009 Kenneth Kalmer
+Copyright (c) 2010 Kenneth Kalmer
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,26 +1,50 @@
 require 'rubygems'
-gem 'hoe', '>= 2.1.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 '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.20'], ['amqp', '= 0.6.0']]
+require 'rake'
 
+require 'lib/ruote-amqp'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'ruote-amqp'
+    gemspec.version = RuoteAMQP::VERSION
+    gemspec.summary = 'AMQP participant/listener pair for ruote 2.1'
+    gemspec.email = 'kenneth.kalmer@gmail.com'
+    gemspec.homepage = 'http://github.com/kennethkalmer/ruote-amqp'
+    gemspec.authors = ['kenneth.kalmer@gmail.com']
+    gemspec.extra_rdoc_files.include '*.txt'
+
+    gemspec.add_dependency 'rufus-json', '>= 0.1.0'
+    gemspec.add_dependency 'amqp', '>= 0.6.6'
+    gemspec.add_dependency 'ruote', '>= 2.1.5'
+    gemspec.add_development_dependency 'rspec'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with 'gem install jeweler'"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
 end
 
-require 'newgem/tasks'
-Dir['tasks/**/*.rake'].each { |t| load t }
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec #=> :check_dependencies
 
-# TODO - want other tests/tasks run by default? Add them to the list
-# remove_task :default
-# task :default => [:spec, :features]
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/lib/ruote-amqp.rb

@@ -1,20 +1,3 @@
-$:.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'
 
 # AMQP participant and listener pair for ruote.
@@ -31,10 +14,12 @@ require 'mq'
 # to be restarted in order for messages to be resent.
 #
 module RuoteAMQP
-  VERSION = '0.9.21.1'
 
-  autoload 'Participant', 'ruote-amqp/participant'
-  autoload 'Listener',    'ruote-amqp/listener'
+  VERSION = '2.1.5'
+
+  autoload 'Participant',        'ruote-amqp/participant'
+  autoload 'WorkitemListener',   'ruote-amqp/workitem_listener'
+  autoload 'LaunchitemListener', 'ruote-amqp/launchitem_listener'
 
   class << self
 
@@ -45,5 +30,46 @@ module RuoteAMQP
       @use_persistent_messages = true if @use_persistent_messages.nil?
       @use_persistent_messages
     end
+
+    # Ensure the AMQP connection is started
+    def start!
+      return if started?
+
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+
+      Thread.main[:ruote_amqp_connection] = Thread.new do
+        Thread.abort_on_exception = true
+        AMQP.start {
+          started!
+          cv.signal
+        }
+      end
+
+      mutex.synchronize { cv.wait(mutex) }
+
+      MQ.prefetch(1)
+
+      yield if block_given?
+    end
+
+    # Check whether the AMQP connection is started
+    def started?
+      Thread.main[:ruote_amqp_started] == true
+    end
+
+    def started! #:nodoc:
+      Thread.main[:ruote_amqp_started] = true
+    end
+
+    # Close down the AMQP connections
+    def stop!
+      return unless started?
+
+      AMQP.stop
+      Thread.main[:ruote_amqp_connection].join
+      Thread.main[:ruote_amqp_started] = false
+    end
+
   end
 end

data/lib/ruote-amqp/launchitem_listener.rb

@@ -0,0 +1,88 @@
+module RuoteAMQP
+
+  # = AMQP Launchitem Listener
+  #
+  # Used on its own, the RuoteAMQP::LaunchitemListener provides the engine with
+  # a way to launch process definitions over an AMQP direct exchange.
+  #
+  # == Message Format
+  #
+  # The LaunchitemListener expects JSON formatted messages that look like this:
+  #
+  #   {
+  #     "definition" : "process definition",
+  #     "fields" : { "key" : "value" },
+  #     "variables" : { "key" : "value" }
+  #  }
+  #
+  # The definition key is a complete string representation of a business process.
+  #
+  # == 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 listener. The only +option+ parsed by the initializer is the +queue+
+  # key (in the optional hash). If no +queue+ key is provided, the listener
+  # will subscribe to the +ruote_launchitems+ direct exchange for launchitems.
+  #
+  # The listener requires version 0.6.6 or later of the amqp gem.
+  #
+  # == Usage
+  #
+  # Register the engine with the listener:
+  #
+  #   RuoteAMQP::LaunchitemListener.new( engine_instance )
+  #
+  # The workitem listener leverages the asynchronous nature of the amqp gem,
+  # so no timers are setup when initialized.
+  class LaunchitemListener < Ruote::Receiver
+
+    class << self
+
+      # Listening queue - set this before initialization
+      attr_writer :queue
+
+      def queue
+        @queue ||= 'ruote_launchitems'
+      end
+
+    end
+
+    # Start a new LaunchItem listener
+    #
+    # @param [ Ruote::Engine ] An instance of a ruote engine
+    # @param [ String ] Optional queue name
+    def initialize( engine, queue = nil )
+
+      self.class.queue = queue if queue
+
+      RuoteAMQP.start!
+
+      MQ.queue( self.class.queue, :durable => true ).subscribe do |message|
+        if AMQP.closing?
+          # Do nothing, we're going down
+        else
+          launchitem = decode_launchitem( message )
+          engine.launch( *launchitem )
+        end
+      end
+    end
+
+    def stop
+      RuoteAMQP.stop!
+    end
+
+    private
+
+    # Complicated guesswork that needs to happen here to detect the format
+    def decode_launchitem( msg )
+      hash = Rufus::Json.decode( msg )
+      opts = {}
+      definition = hash.delete('definition')
+      fields = hash.delete('fields') || {}
+      variables = hash.delete('variables') || {}
+
+      [ definition, fields, variables ]
+    end
+  end
+end

data/lib/ruote-amqp/participant.rb

@@ -1,3 +1,5 @@
+require 'ruote/part/local_participant'
+
 module RuoteAMQP
 
   # = AMQP Participants
@@ -111,14 +113,15 @@ module RuoteAMQP
   # #RuoteAMQP)
   #
   class Participant
-    include OpenWFE::LocalParticipant
+
+    include Ruote::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!
+      RuoteAMQP.start!
 
       @options = {
         :reply_by_default => false,
@@ -140,57 +143,44 @@ module RuoteAMQP
     # 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}" }
+        if message = ( workitem.fields['message'] || workitem.fields['params']['message'] )
           q.publish( message, :persistent => RuoteAMQP.use_persistent_messages? )
-
         else
-          ldebug { "sending workitem to queue: #{target_queue}" }
-
           q.publish( encode_workitem( workitem ), :persistent => RuoteAMQP.use_persistent_messages? )
         end
       else
-        lerror { "no queue in workitem params!" }
+        raise "no queue in workitem params!"
       end
 
-      if @options[:reply_by_default] || workitem.params['reply-anyway'] == true
+      if @options[:reply_by_default] || workitem.fields['params']['reply_anyway'] == true
         reply_to_engine( workitem )
       end
-
-      ldebug { "done" }
     end
 
     def stop
-      linfo { "Stopping..."  }
+      RuoteAMQP.stop!
+    end
 
-      AMQP.stop { EM.stop } #if EM.reactor_running? }
-      @em_thread.join if @em_thread
+    def cancel(fei, flavour)
     end
 
     private
 
     def determine_queue( workitem )
-      workitem.params['queue'] ||
+      workitem.fields['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?
+      wi.fields['params']['reply_queue'] = WorkitemListener.queue
+      wi.to_h.to_json
     end
   end
 end