ruote 2.2.0 → 2.3.0

data/lib/ruote/storage/composite_storage.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -33,8 +33,8 @@ module Ruote
   #
   #   opts = {}
   #
-  #   engine =
-  #     Ruote::Engine.new(
+  #   dashboard =
+  #     Ruote::Dashboard.new(
   #       Ruote::Worker.new(
   #         Ruote::CompositeStorage.new(
   #           Ruote::FsStorage.new('ruote_work', opts),
@@ -51,58 +51,58 @@ module Ruote
 
       @default_storage = default_storage
       @storages = storages
-
-      prepare_base_methods
-    end
-
-    def put(doc, opts={})
-
-      storage(doc['type']).put(doc, opts)
-    end
-
-    def get(type, key)
-
-      storage(type).get(type, key)
-    end
-
-    def delete(doc)
-
-      storage(doc['type']).delete(doc)
-    end
-
-    def get_many(type, key=nil, opts={})
-
-      storage(type).get_many(type, key, opts)
-    end
-
-    def ids(type)
-
-      storage(type).ids(type)
     end
 
-    def purge!
+    # A class method 'delegate', to tell this storage how to deal with
+    # each method composing a storage.
+    #
+    # Followed by a list of 'delegations'.
+    #
+    def self.delegate(method_name, type=nil)
 
-      TYPES.collect { |t| storage(t) }.uniq.each { |s| s.purge! }
+      if type == nil
+        define_method(method_name) do |*args|
+          storage_for(args.first['type']).send(method_name, *args)
+        end
+      elsif type.is_a?(Fixnum)
+        define_method(method_name) do |*args|
+          storage_for(args[type]).send(method_name, *args)
+        end
+      else
+        type = type.to_s
+        define_method(method_name) do |*args|
+          storage_for(type).send(method_name, *args)
+        end
+      end
     end
 
-    def purge_type!(type)
-
-      storage(type).purge_type!(type)
+    delegate :put
+    delegate :get, 0
+    delegate :get_many, 0
+    delegate :delete
+
+    delegate :reserve
+    delegate :ids, 0
+    delegate :purge_type!, 0
+    delegate :empty?, 0
+
+    delegate :put_msg, :msgs
+    delegate :get_msgs, :msgs
+    delegate :put_schedule, :schedules
+    delegate :get_schedules, :schedules
+    delegate :delete_schedule, :schedules
+    delegate :find_root_expression, :expressions
+    delegate :expression_wfids, :expressions
+    delegate :get_trackers, :variables
+    delegate :get_engine_variable, :variables
+    delegate :put_engine_variable, :variables
+
+    # The dilemma for the CompositeStorage with add_type is "to which
+    # real storage should the new type get added". The solution: do nothing.
+    #
+    def add_type(type)
     end
 
-    #def add_type (type)
-    #end
-
-    protected
-
-    STORAGE_BASE_METHODS = {
-      'put_msg' => 'msgs',
-      'get_msgs' => 'msgs',
-      'find_root_expression' => 'expressions',
-      'get_schedules' => 'schedules',
-      'put_schedule' => 'schedules'
-    }
-
     TYPES = %w[
       variables
       msgs
@@ -113,19 +113,9 @@ module Ruote
       workitems
     ]
 
-    def prepare_base_methods
-
-      singleton = class << self; self; end
-
-      STORAGE_BASE_METHODS.each do |method, type|
-
-        singleton.send(:define_method, method) do |*args|
-          storage(type).send(method, *args)
-        end
-      end
-    end
+    protected
 
-    def storage(type)
+    def storage_for(type)
 
       @storages[type] || @default_storage
     end

data/lib/ruote/storage/fs_storage.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -22,18 +22,9 @@
 # Made in Japan.
 #++
 
-begin
-  require 'yajl'
-rescue LoadError
-  require 'json'
-end
-  # gem install yajl-ruby OR json OR json_pure OR json-jruby
-
-require 'rufus/json'
-Rufus::Json.detect_backend
 
-require 'rufus/cloche'
-  # gem install rufus-cloche
+require 'rufus-json/automatic'
+require 'rufus-cloche'
 
 require 'ruote/storage/base'
 
@@ -59,19 +50,31 @@ module Ruote
     #
     def initialize(dir, options={})
 
+      if dir.is_a?(Hash) && options == {}
+        options = dir
+        dir = options.delete('dir')
+      end
+
       FileUtils.mkdir_p(dir)
 
       @cloche = Rufus::Cloche.new(
         :dir => dir, :nolock => options['cloche_nolock'])
 
-      @options = options
+      replace_engine_configuration(options)
+    end
+
+    def dir
 
-      @cloche.put(@options.merge('type' => 'configurations', '_id' => 'engine'))
+      @cloche.dir
     end
 
     def put(doc, opts={})
 
-      @cloche.put(doc.merge!('put_at' => Ruote.now_to_utc_s), opts)
+      doc = doc.send(
+        opts[:update_rev] ? 'merge!' : 'merge',
+        'put_at' => Ruote.now_to_utc_s)
+
+      @cloche.put(doc, opts)
     end
 
     def get(type, key)
@@ -86,13 +89,13 @@ module Ruote
 
     def get_many(type, key=nil, opts={})
 
-      if key
-        key = Array(key)
-        key = key.map { |k| "!#{k}" } if key.first.is_a?(String)
-      end
-        # assuming /!#{wfid}$/...
+      keys = key ? Array(key) : nil
+
+      keys = keys.map { |k|
+        type == 'schedules' ? /!#{k}-\d+$/ : "!#{k}"
+      } if keys && keys.first.is_a?(String)
 
-      @cloche.get_many(type, key, opts)
+      @cloche.get_many(type, keys, opts)
     end
 
     def ids(type)
@@ -107,7 +110,7 @@ module Ruote
       FileUtils.rm_rf(@cloche.dir)
     end
 
-    # No need for that here (FsStorage adds type on the fly).
+    # No need for that here (FsStorage can add types on the fly).
     #
     def add_type(type)
     end
@@ -117,18 +120,6 @@ module Ruote
       @cloche.purge_type!(type)
     end
 
-    def dump(type)
-
-      s = "=== #{type} ===\n"
-
-      @cloche.get_many(type).inject(s) do |s1, e|
-        s1 << "\n"
-        e.keys.sort.inject(s1) do |s2, k|
-          s2 << "  #{k} => #{e[k].inspect}\n"
-        end
-      end
-    end
-
     # Shuts this storage down.
     #
     def shutdown

data/lib/ruote/storage/hash_storage.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -30,8 +30,11 @@ require 'monitor'
 
 module Ruote
 
+  #
   # An in-memory storage.
   #
+  # Useful for testing or for transient engines.
+  #
   class HashStorage
 
     include StorageBase
@@ -47,14 +50,13 @@ module Ruote
       @options = options
 
       purge!
+        # which initializes @h
 
-      put(options.merge('type' => 'configurations', '_id' => 'engine'))
+      replace_engine_configuration(options)
     end
 
     def put(doc, opts={})
 
-      i = @h.size
-
       synchronize do
 
         pre = get(doc['type'], doc['_id'])
@@ -68,8 +70,7 @@ module Ruote
         end
 
         doc = if opts[:update_rev]
-          doc['_rev'] = pre ? pre['_rev'] : -1
-          doc
+          doc.merge!('_rev' => pre ? pre['_rev'] : -1)
         else
           doc.merge('_rev' => doc['_rev'] || -1)
         end
@@ -82,12 +83,12 @@ module Ruote
         nil
       end
 
-    rescue => e
-      puts "=" * 80
-      File.open('doc.json', 'wb') do |f|
-        f.puts Rufus::Json.pretty_encode(doc)
-      end
-      raise e
+    #rescue => e
+    #  puts "=" * 80
+    #  File.open('doc.json', 'wb') do |f|
+    #    f.puts Rufus::Json.pretty_encode(doc)
+    #  end
+    #  raise e
     end
 
     def get(type, key)
@@ -125,19 +126,16 @@ module Ruote
 
       synchronize do
 
-        keys = key ?
-          Array(key).map { |k| k.is_a?(String) ? "!#{k}" : k } : nil
-
-        docs = keys ?
-          @h[type].values.select { |doc|
-            Ruote::StorageBase.key_match?(keys, doc)
-          } :
+        docs = if key
+          keys = Array(key).map { |k| k.is_a?(String) ? "!#{k}" : k }
+          @h[type].values.select { |doc| key_match?(type, keys, doc) }
+        else
           @h[type].values
-
-        docs = docs.sort_by { |d| d['_id'] }
+        end
 
         return docs.size if opts[:count]
 
+        docs = docs.sort_by { |d| d['_id'] }
         docs = docs.reverse if opts[:descending]
 
         skip = opts[:skip] || 0
@@ -154,6 +152,24 @@ module Ruote
       @h[type].keys.sort
     end
 
+    #--
+    # keeping it commented out... using it for documentation efforts
+    #class NoisyHash < Hash
+    #  def initialize(type)
+    #    @type = type
+    #    super()
+    #  end
+    #  def []=(k, v)
+    #    puts "       + #{@type}.put #{k} #{v['_rev']}"
+    #    super
+    #  end
+    #  def delete(k)
+    #    puts "       - #{@type}.del #{k} "
+    #    super
+    #  end
+    #end
+    #++
+
     # Purges the storage completely.
     #
     def purge!
@@ -169,9 +185,8 @@ module Ruote
         configurations
         workitems
 
-      ].inject({}) { |h, k|
+      ].each_with_object({}) { |k, h|
         h[k] = {}
-        h
       }
 
       @h['configurations']['engine'] = @options
@@ -187,19 +202,6 @@ module Ruote
       @h[type] = {}
     end
 
-    def dump(type)
-
-      s = "=== #{type} ===\n"
-
-      @h[type].inject(s) do |s1, (k, v)|
-        s1 << "\n"
-        s1 << "#{k} :\n"
-        v.keys.sort.inject(s1) do |s2, k1|
-          s2 << "  #{k1} => #{v[k1].inspect}\n"
-        end
-      end
-    end
-
     # Shuts this storage down.
     #
     def shutdown

data/lib/ruote/svc/dispatch_pool.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -42,48 +42,28 @@ module Ruote
     def handle(msg)
 
       case msg['action']
-        when 'dispatch'
-          dispatch(msg)
-        when 'dispatch_cancel'
-          dispatch_cancel(msg)
-        else
-          # simply discard the message
+        when 'dispatch' then dispatch(msg)
+        when 'dispatch_cancel' then dispatch_cancel(msg)
+        when 'dispatch_pause', 'dispatch_resume' then dispatch_pause(msg)
+        else # simply discard the message
       end
     end
 
     protected
 
-    def dispatch_cancel(msg)
-
-      flavour = msg['flavour']
-
-      participant = @context.plist.instantiate(msg['participant'])
-
-      begin
-        participant.cancel(Ruote::FlowExpressionId.new(msg['fei']), flavour)
-      rescue => e
-        raise(e) if flavour != 'kill'
-      end
-
-      @context.storage.put_msg(
-        'reply',
-        'fei' => msg['fei'],
-        'workitem' => msg['workitem'])
-    end
-
     def dispatch(msg)
 
       participant = @context.plist.lookup(
         msg['participant'] || msg['participant_name'], msg['workitem'])
 
-      if do_not_thread(participant, msg)
+      if (@context['participant_threads_enabled'] == false) || do_not_thread?(participant, msg)
         do_dispatch(participant, msg)
       else
         do_threaded_dispatch(participant, msg)
       end
     end
 
-    # The actual dispatching (call to Participant#consume).
+    # The actual dispatching (call to Participant#consume or #on_workitem).
     #
     def do_dispatch(participant, msg)
 
@@ -91,12 +71,14 @@ module Ruote
 
       workitem.fields['dispatched_at'] = Ruote.now_to_utc_s
 
-      participant.consume(workitem)
+      Ruote.participant_send(
+        participant, [ :on_workitem, :consume ], 'workitem' => workitem)
 
       @context.storage.put_msg(
         'dispatched',
         'fei' => msg['fei'],
-        'participant_name' => workitem.participant_name)
+        'participant_name' => workitem.participant_name,
+        'workitem' => msg['workitem'])
           # once the consume is done, asynchronously flag the
           # participant expression as 'dispatched'
     end
@@ -129,16 +111,103 @@ module Ruote
     # Returns true if the participant doesn't want the #consume to happen
     # in a new Thread.
     #
-    def do_not_thread(participant, msg)
+    def do_not_thread?(participant, msg)
 
-      return false unless participant.respond_to?(:do_not_thread)
+      # :default => false makes participant_send return false if no method
+      # were found (else it would raise a NoMethodError)
 
-      if participant.method(:do_not_thread).arity == 0
-        participant.do_not_thread
-      else
-        participant.do_not_thread(Ruote::Workitem.new(msg['workitem']))
+      Ruote.participant_send(
+        participant,
+        [ :do_not_thread, :do_not_thread?, :dont_thread, :dont_thread? ],
+        'workitem' => Ruote::Workitem.new(msg['workitem']), :default => false)
+    end
+
+    # Instantiates the participant and calls its cancel method.
+    #
+    def dispatch_cancel(msg)
+
+      flavour = msg['flavour']
+
+      participant = @context.plist.instantiate(msg['participant'])
+
+      result = begin
+
+        Ruote.participant_send(
+          participant,
+          [ :on_cancel, :cancel ],
+          'fei' => Ruote::FlowExpressionId.new(msg['fei']),
+          'flavour' => flavour)
+
+      rescue => e
+        raise(e) if flavour != 'kill'
       end
+
+      @context.storage.put_msg(
+        'reply',
+        'fei' => msg['fei'],
+        'workitem' => msg['workitem']
+      ) if result != false
+    end
+
+    # Instantiates the participant and calls its on_pause (or on_resume) method.
+    #
+    def dispatch_pause(msg)
+
+      action = (msg['action'] == 'dispatch_resume' ? :on_resume : :on_pause)
+
+      participant = @context.plist.instantiate(
+        msg['participant'], :if_respond_to? => action)
+
+      return unless participant
+
+      Ruote.participant_send(
+        participant,
+        action,
+        'fei' => Ruote::FlowExpressionId.new(msg['fei']), :default => false)
+    end
+  end
+
+  # Given a participant, a method name or an array of method names and
+  # a hash of arguments, will do its best to set the instance variables
+  # corresponding to the arguments (if possible) and to call the
+  # method with the right number of arguments...
+  #
+  # Made it a Ruote module method so that RevParticipant might use it
+  # independently.
+  #
+  # If the arguments hash contains a value keyed :default, that value is
+  # returned when none of the methods is responded to by the participant.
+  # Else if :default is not set or is set to nil, a NoMethodError.
+  #
+  def self.participant_send(participant, methods, arguments)
+
+    default = arguments.delete(:default)
+
+    # set instance variables if possible
+
+    arguments.each do |key, value|
+      setter = "#{key}="
+      participant.send(setter, value) if participant.respond_to?(setter)
     end
+
+    # call the method, with the right arity
+
+    Array(methods).each do |method|
+
+      next unless participant.respond_to?(method)
+
+      return participant.send(method) if participant.method(method).arity == 0
+
+      args = arguments.keys.sort.collect { |k| arguments[k] }
+        # luckily, our arg keys are in the alphabetical order (fei, flavour)
+
+      return participant.send(method, *args)
+    end
+
+    return default unless default == nil
+
+    raise NoMethodError.new(
+      "undefined method `#{methods.first}' for #{participant.class}")
   end
 end