daemon-kit 0.1.7.9 → 0.1.7.10

data/lib/daemon_kit/ruote_pseudo_participant.rb

@@ -0,0 +1,68 @@
+module DaemonKit
+  # Common convenience methods for making ruote pseudo-participants more DRY
+  # and unified
+  class RuotePseudoParticipant
+
+    class << self
+
+      attr_reader :exception_handler_method, :exception_handler_block,
+        :on_complete_handler_method, :on_complete_handler_block
+
+      # Register a callback method or block that gets called when an exception
+      # occurs during the processing of an action. +handler+ can be a symbol or
+      # string with a method name, or a block. Both will get the exception as
+      # the first parameter, and the block handler will receive the participant
+      # instance as the second parameter
+      def on_exception( handler = nil, &block )
+        @exception_handler_method = handler
+        @exception_handler_block = block
+      end
+
+      # Register a callback method or block that gets called when the action
+      # was successfully completed. Block callbacks get the workitem as
+      # parameter.
+      def on_complete( handler = nil, &block )
+        @on_complete_handler_method = handler
+        @on_complete_handler_block = block
+      end
+    end
+
+    # Current workitem
+    attr_reader :workitem
+
+    # Current action
+    attr_reader :action
+
+    # Perform the specified action with the provided workitem
+    def perform( action, workitem )
+      @action, @workitem = action, workitem
+
+      begin
+        send( action )
+        run_callbacks
+      rescue => e
+        handle_exception( e )
+      end
+    end
+
+    def handle_exception( e )
+      raise e if self.class.exception_handler_method.nil? && self.class.exception_handler_block.nil?
+
+      if self.class.exception_handler_method
+        send( self.class.exception_handler_method, e )
+      else
+        self.class.exception_handler_block.call( e, self )
+      end
+    end
+
+    def run_callbacks
+      return if self.class.on_complete_handler_block.nil? && self.class.on_complete_handler_method.nil?
+
+      if self.class.on_complete_handler_method
+        send( self.class.on_complete_handler_method )
+      else
+        self.class.on_complete_handler_block.call( workitem )
+      end
+    end
+  end
+end

data/lib/daemon_kit/ruote_workitem.rb

@@ -0,0 +1,169 @@
+module DaemonKit
+
+  # Dual purpose class that is a) responsible for parsing incoming workitems and
+  # delegating to the correct RuotePseudoParticipant, and b) wrapping the
+  # workitem hash into something a bit more digestable.
+  class RuoteWorkitem
+
+    class << self
+
+      # = Process incoming commands via an AMQP queue
+      #
+      # Expects a JSON workitem from ruote that has these fields set in
+      # attributes key:
+      #
+      #   {
+      #     'reply_queue'    => 'queue to send replies to',
+      #     'params' => {
+      #       'command'  => '/actor/method'
+      #     }
+      #   }
+      #
+      # == Notes on the command key:
+      #
+      # It looks like a resource, and will be treated as such. Is should
+      # be in the format of +/class/method+, and it will be passed the
+      # complete workitem as a hash.
+      #
+      # == Notes on replies
+      #
+      # Replies are sent back to the queue specified in the +reply_queue+ key.
+      #
+      # == Notes on errors
+      #
+      # Where daemon-kit detects errors in attempting to parse and delegate the
+      # workitems, it will reply to the engine and set the following field with
+      # the error information:
+      #
+      #   daemon_kit.error
+      def process( transport, workitem )
+        # keep it singleton
+        @instance ||= new
+
+        work = parse( workitem )
+
+        DaemonKit.logger.warn "Processing workitem that has timed out!" if work.timed_out?
+
+        target, method = parse_command( work )
+
+        if target.nil? || method.nil?
+          msg = "Missing target/method in command parameter, or command parameter missing"
+          DaemonKit.logger.error( msg )
+          work["daemon_kit"] = { "error" => msg }
+
+        elsif target.public_methods.include?( method )
+          target.perform( method, work )
+
+        else
+          msg = "Workitem cannot be processes: #{method} not exposed by #{target.inspect}"
+          DaemonKit.logger.error( msg )
+          work["daemon_kit"] = { "error" => msg }
+        end
+
+        reply_to_engine( transport, work )
+      end
+
+      # Extract the class and method name from the workitem, then pick the matching
+      # class from the registered list of participants
+      def parse_command( work )
+        return nil if work['params']['command'].nil?
+
+        _, klass, method = work['params']['command'].split('/')
+
+        instance = RuoteParticipants.instance.participants[ klass ]
+
+        if instance.nil?
+          msg = "No instance registered for #{klass}"
+          DaemonKit.logger.error( msg )
+          raise DaemonKit::MissingParticipant, msg
+        end
+
+        return instance, method
+      end
+
+      def reply_to_engine( transport, response )
+        send( "reply_via_#{transport}", response )
+      end
+
+      def reply_via_amqp( response )
+        DaemonKit.logger.debug("Replying to engine via AMQP with #{response.inspect}")
+
+        ::MQ.queue( response['reply_queue'] ).publish( response.to_json )
+
+        response
+      end
+
+      def parse( workitem )
+        new( JSON.parse( workitem ) )
+      end
+    end
+
+    def initialize( workitem = {} )
+      @workitem = workitem
+    end
+
+    def fei
+      @workitem['flow_expression_id']
+    end
+
+    def short_fei
+      @short_fei ||=
+        '(' + [
+               'fei', self.fei['owfe_version'], self.fei['engine_id'],
+               self.fei['workflow_definition_url'], self.fei['workflow_definition_name'],
+               self.fei['workflow_definition_revision'], self.fei['workflow_instance_id'],
+               self.fei['expression_name'], self.fei['expression_id']
+              ].join(' ') + ')'
+    end
+
+    def dispatch_time
+      @dispath_time ||= Time.parse( @workitem['dispatch_time'] )
+    end
+
+    def last_modified
+      @last_modified ||= Time.parse( @workitem['last_modified'] )
+    end
+
+    def participant_name
+      @workitem['participant_name']
+    end
+
+    def attributes
+      @workitem['attributes']
+    end
+
+    def []( key )
+      self.attributes[ key ]
+    end
+
+    def []=( key, value )
+      self.attributes[ key ] = value
+    end
+
+    def to_json
+      @workitem.to_json
+    end
+
+    # Look at the workitem payload and attempt to determine if this workitem
+    # has timed out or not. This method will only ever work if you used the
+    # +:timeout: parameter was set for the expression.
+    def timed_out?
+      key = fei['workflow_instance_id'] + '__' + fei['expression_id']
+
+      if self.attributes["__timeouts__"] && timeout = self.attributes["__timeouts__"][ key ]
+        return Time.at( timeout.last ) < Time.now
+      end
+
+      return false
+    end
+
+    def method_missing( method_name, *args )
+      if self.attributes.keys.include?( method_name.to_s )
+        return self.attributes[ method_name.to_s ]
+      end
+
+      super
+    end
+
+  end
+end

data/spec/argument_spec.rb

@@ -47,5 +47,24 @@ describe DaemonKit::Arguments do
 
       res.last.should == [ '-h' ]
     end
+
+    it "should handle different ordered configurations easily" do
+      argv = [ '--pid', '/tmp/piddy', '--log', '/tmp/loggy' ]
+      res = DaemonKit::Arguments.configuration( argv )
+
+      # No additional args
+      res.last.should be_empty
+
+      res.first[0].should == "pid_file=/tmp/piddy"
+      res.first[1].should == "log_path=/tmp/loggy"
+    end
+
+    it "should handle mixed configurations easily" do
+      argv = [ '--rest', 'yes', '-l', '/tmp/loggy', '-f', 'bar' ]
+      res = DaemonKit::Arguments.configuration( argv )
+
+      res.first.should == [ 'log_path=/tmp/loggy' ]
+      res.last.should  == [ '--rest', 'yes', '-f', 'bar' ]
+    end
   end
 end

data/spec/config_spec.rb

@@ -4,7 +4,7 @@ describe DaemonKit::Config do
 
   describe "working with config data" do
     before(:each) do
-      @config = DaemonKit::Config.new('foo' => 'bar')
+      @config = DaemonKit::Config.new('foo' => 'bar', 'nes' => { 'ted' => 'value' })
     end
 
     it "should have string key access to values" do
@@ -19,15 +19,17 @@ describe DaemonKit::Config do
       @config.foo.should == 'bar'
     end
 
-    it "should return the config as a has" do
-      @config.to_h.should == { 'foo' => 'bar' }
+    it "should have nested instance accessors to values" do
+      @config.nes.ted.should == 'value'
     end
 
-    it "should be able to symbolize keys in returned hash" do
-      @config.to_h(true).should == { :foo => 'bar' }
+    it "should return the config as a hash" do
+      @config.to_h.should == { 'foo' => 'bar', 'nes' => { 'ted' => 'value' } }
     end
 
-    it "should symbolize keys in a nested fashion"
+    it "should be able to symbolize keys in returned hash" do
+      @config.to_h(true).should == { :foo => 'bar', :nes => { :ted => 'value' } }
+    end
   end
 
   describe "parsing files" do

data/spec/initializer_spec.rb

@@ -18,15 +18,9 @@ describe DaemonKit::Configuration do
     @configuration.log_level.should_not be_nil
   end
 
-end
-
-
-describe DaemonKit::Initializer do
-
-  it "should setup a logger" do
-    pending
-    DaemonKit::Initializer.run(:initialize_logger)
-    DaemonKit.logger.should_not be_nil
+  it "should set a default umask" do
+    File.umask.should_not be(0)
+    File.umask.should be(18)
   end
 
 end

data/test/test_ruote_generator.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "test_generator_helper.rb")
+
+
+class TestRuoteGenerator < Test::Unit::TestCase
+  include RubiGen::GeneratorTestHelper
+
+  def setup
+    bare_setup
+  end
+
+  def teardown
+    bare_teardown
+  end
+
+  # Some generator-related assertions:
+  #   assert_generated_file(name, &block) # block passed the file contents
+  #   assert_directory_exists(name)
+  #   assert_generated_class(name, &block)
+  #   assert_generated_module(name, &block)
+  #   assert_generated_test_for(name, &block)
+  # The assert_generated_(class|module|test_for) &block is passed the body of the class/module within the file
+  #   assert_has_method(body, *methods) # check that the body has a list of methods (methods with parentheses not supported yet)
+  #
+  # Other helper methods are:
+  #   app_root_files - put this in teardown to show files generated by the test method (e.g. p app_root_files)
+  #   bare_setup - place this in setup method to create the APP_ROOT folder for each test
+  #   bare_teardown - place this in teardown method to destroy the TMP_ROOT or APP_ROOT folder after each test
+
+  def test_generator_without_options
+    name = "myapp"
+    run_generator('ruote', [name], sources)
+    assert_directory_exists "some/directory"
+    assert_generated_file   "some_file"
+  end
+
+  private
+  def sources
+    [RubiGen::PathSource.new(:test, File.join(File.dirname(__FILE__),"..", generator_path))
+    ]
+  end
+
+  def generator_path
+    "daemon_generators"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: daemon-kit
 version: !ruby/object:Gem::Version 
-  version: 0.1.7.9
+  version: 0.1.7.10
 platform: ruby
 authors: 
 - Kenneth Kalmer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-22 00:00:00 +02:00
+date: 2009-08-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.4.1
+        version: 1.5.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
@@ -50,9 +50,20 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.0
+        version: 2.3.2
     version: 
-description: "Daemon Kit aims to simplify creating Ruby daemons by providing a sound application skeleton (through a generator), task specific generators (jabber bot, etc) and robust environment management code.  Using simple built-in generators it is easy to created evented and non-evented daemons that perform a multitude of different tasks.  Supported generators:  * Evented and non-evented Jabber Bot (coming next) * Evented and non-evented loops (coming soon) * Queue poller (SQS, AMQP, etc) (coming soon)"
+description: |-
+  Daemon Kit aims to simplify creating Ruby daemons by providing a sound application skeleton (through a generator), task specific generators (jabber bot, etc) and robust environment management code.
+  
+  Using simple built-in generators it is easy to created evented and non-evented daemons that perform a multitude of different tasks.
+  
+  Supported generators:
+  
+  * XMPP bot (non-evented)
+  * AMQP consumer (evented)
+  * Nanite agent
+  * Cron-style daemon
+  * ruote remote participants
 email: 
 - kenneth.kalmer@gmail.com
 executables: 
@@ -66,7 +77,7 @@ extra_rdoc_files:
 - Logging.txt
 - Manifest.txt
 - PostInstall.txt
-- README.rdoc
+- RuoteParticipants.txt
 - TODO.txt
 files: 
 - Configuration.txt
@@ -77,6 +88,7 @@ files:
 - PostInstall.txt
 - README.rdoc
 - Rakefile
+- RuoteParticipants.txt
 - TODO.txt
 - app_generators/daemon_kit/USAGE
 - app_generators/daemon_kit/daemon_kit_generator.rb
@@ -136,6 +148,14 @@ files:
 - daemon_generators/rspec/templates/spec/spec.opts
 - daemon_generators/rspec/templates/spec/spec_helper.rb
 - daemon_generators/rspec/templates/tasks/rspec.rake
+- daemon_generators/ruote/USAGE
+- daemon_generators/ruote/ruote_generator.rb
+- daemon_generators/ruote/templates/config/amqp.yml
+- daemon_generators/ruote/templates/config/initializers/ruote.rb
+- daemon_generators/ruote/templates/config/ruote.yml
+- daemon_generators/ruote/templates/lib/daemon.rb
+- daemon_generators/ruote/templates/lib/sample.rb
+- daemon_generators/ruote/templates/libexec/daemon.rb
 - lib/daemon_kit.rb
 - lib/daemon_kit/abstract_logger.rb
 - lib/daemon_kit/amqp.rb
@@ -154,11 +174,15 @@ files:
 - lib/daemon_kit/error_handlers/base.rb
 - lib/daemon_kit/error_handlers/hoptoad.rb
 - lib/daemon_kit/error_handlers/mail.rb
+- lib/daemon_kit/exceptions.rb
 - lib/daemon_kit/initializer.rb
 - lib/daemon_kit/jabber.rb
 - lib/daemon_kit/nanite.rb
 - lib/daemon_kit/nanite/agent.rb
 - lib/daemon_kit/pid_file.rb
+- lib/daemon_kit/ruote_participants.rb
+- lib/daemon_kit/ruote_pseudo_participant.rb
+- lib/daemon_kit/ruote_workitem.rb
 - lib/daemon_kit/safety.rb
 - lib/daemon_kit/tasks.rb
 - lib/daemon_kit/tasks/environment.rake
@@ -193,6 +217,7 @@ files:
 - test/test_helper.rb
 - test/test_jabber_generator.rb
 - test/test_nanite_agent_generator.rb
+- test/test_ruote_generator.rb
 - vendor/tmail-1.2.3/tmail.rb
 - vendor/tmail-1.2.3/tmail/address.rb
 - vendor/tmail-1.2.3/tmail/attachments.rb
@@ -223,6 +248,8 @@ files:
 - vendor/tmail.rb
 has_rdoc: true
 homepage: http://kit.rubyforge.org/daemon-kit/rdoc/
+licenses: []
+
 post_install_message: |+
   
   For more information on daemon-kit, see http://kit.rubyforge.org/daemon-kit
@@ -250,17 +277,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: kit
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Daemon Kit aims to simplify creating Ruby daemons by providing a sound application skeleton (through a generator), task specific generators (jabber bot, etc) and robust environment management code.
 test_files: 
 - test/test_generator_helper.rb
-- test/test_cron_generator.rb
-- test/test_nanite_agent_generator.rb
-- test/test_daemon_kit_config.rb
-- test/test_helper.rb
 - test/test_amqp_generator.rb
+- test/test_cron_generator.rb
 - test/test_daemon-kit_generator.rb
+- test/test_daemon_kit_config.rb
 - test/test_deploy_capistrano_generator.rb
+- test/test_helper.rb
 - test/test_jabber_generator.rb
+- test/test_nanite_agent_generator.rb
+- test/test_ruote_generator.rb