ruote 2.1.9 → 2.1.10

data/lib/ruote/exp/ro_persist.rb

@@ -54,8 +54,9 @@ module Ruote::Exp
 
       r = @context.storage.put(@h)
 
-      #puts "+ per #{h.fei['expid']} #{tree.first} #{h._rev} --> #{r.class}"
-      #Ruote.p_caller('+ per') if r != nil || h.fei['expid'] == '0_0'
+      #t = Thread.current.object_id.to_s[-3..-1]
+      #puts "+ per #{h.fei['expid']} #{tree.first} #{h._rev} #{t} -> #{r.class}"
+      #Ruote.p_caller('+ per') #if r != nil || h.fei['expid'] == '0_0'
 
       r
     end
@@ -64,8 +65,9 @@ module Ruote::Exp
 
       r = @context.storage.delete(@h)
 
-      #puts "- unp #{h.fei['expid']} #{tree.first} #{h._rev} --> #{r.class}"
-      #Ruote.p_caller('- unp') if r != nil || h.fei['expid'] == '0_0'
+      #t = Thread.current.object_id.to_s[-3..-1]
+      #puts "- unp #{h.fei['expid']} #{tree.first} #{h._rev} #{t} -> #{r.class}"
+      #Ruote.p_caller('- unp') #if r != nil || h.fei['expid'] == '0_0'
 
       return r if r
 
@@ -73,6 +75,8 @@ module Ruote::Exp
       err = @context.storage.get('errors', "err_#{Ruote.to_storage_id(h.fei)}")
       @context.storage.delete(err) if err
       #end
+        # removes any error in the journal for this expression
+        # since it will now be gone, no need to keep track of its errors
 
       nil
     end

data/lib/ruote/exp/ro_variables.rb

@@ -139,9 +139,9 @@ module Ruote::Exp
     def un_set_variable (op, var, val, should_persist)
 
       if op == :set
-        h.variables[var] = val
+        Ruote.set(h.variables, var, val)
       else # op == :unset
-        h.variables.delete(var)
+        Ruote.unset(h.variables, var)
       end
 
       return unless should_persist

data/lib/ruote/fei.rb

@@ -23,6 +23,7 @@
 #++
 
 require 'ruote/version'
+require 'ruote/workitem'
 require 'ruote/util/misc'
 require 'ruote/util/hashdot'
 
@@ -38,6 +39,15 @@ module Ruote
     Ruote::FlowExpressionId.to_storage_id(fei)
   end
 
+  # A shorter shortcut for
+  #
+  #   Ruote::FlowExpressionId.to_storage_id(fei)
+  #
+  def self.sid (fei)
+
+    Ruote::FlowExpressionId.to_storage_id(fei)
+  end
+
   #
   # The FlowExpressionId (fei for short) is an process expression identifier.
   # Each expression when instantiated gets a unique fei.
@@ -78,21 +88,26 @@ module Ruote
       @h['sub_wfid']
     end
 
+    def engine_id
+      @h['engine_id']
+    end
+
     def to_storage_id
       "#{@h['expid']}!#{@h['sub_wfid']}!#{@h['wfid']}"
     end
 
     def self.to_storage_id (hfei)
-      "#{hfei['expid']}!#{hfei['sub_wfid']}!#{hfei['wfid']}"
+
+      hfei.respond_to?(:to_storage_id) ?
+        hfei.to_storage_id :
+        "#{hfei['expid']}!#{hfei['sub_wfid']}!#{hfei['wfid']}"
     end
 
+    # Turns the result of to_storage_id back to a FlowExpressionId instance.
+    #
     def self.from_id (s, engine_id='engine')
 
-      ss = s.split('!')
-
-      FlowExpressionId.new(
-        'engine_id' => engine_id,
-        'expid' => ss[-3], 'sub_wfid' => ss[-2], 'wfid' => ss[-1])
+      extract("#{engine_id}!#{s}")
     end
 
     # Returns the last number in the expid. For instance, if the expid is
@@ -139,10 +154,47 @@ module Ruote
         return false if parent_fei[k] != other_fei[k]
       end
 
-      pei = other_fei['expid'].split(CHILD_SEP)[0..-2].join('_')
+      pei = other_fei['expid'].split(CHILD_SEP)[0..-2].join(CHILD_SEP)
 
       (pei == parent_fei['expid'])
     end
+
+    # Attempts at extracting a FlowExpressionId from the given argument
+    # (workitem, string, ...)
+    #
+    # Uses .extract_h
+    #
+    def self.extract (arg)
+
+      FlowExpressionId.new(extract_h(arg))
+    end
+
+    # Attempts at extracting a FlowExpressionId (as a Hash instance) from the
+    # given argument (workitem, string, ...)
+    #
+    def self.extract_h (arg)
+
+      if arg.is_a?(Hash)
+        return arg if arg['expid']
+        return arg['fei'] if arg['fei']
+      end
+
+      return extract_h(arg.fei) if arg.respond_to?(:fei)
+      return arg.h if arg.is_a?(Ruote::FlowExpressionId)
+      return arg.h['fei'] if arg.is_a?(Ruote::Workitem)
+
+      if arg.is_a?(String)
+
+        ss = arg.split('!')
+
+        return {
+          'engine_id' => ss[-4] || 'engine',
+          'expid' => ss[-3], 'sub_wfid' => ss[-2], 'wfid' => ss[-1] }
+      end
+
+      raise ArgumentError.new(
+        "couldn't extract fei out of instance of #{arg.class}")
+    end
   end
 end
 

data/lib/ruote/log/storage_history.rb

@@ -62,6 +62,8 @@ module Ruote
 
       ids = @context.storage.ids('history')
 
+      #p ids.sort == ids
+
       fm = DATE_REGEX.match(ids.first)[1]
       lm = DATE_REGEX.match(ids.last)[1]
 

data/lib/ruote/log/test_logger.rb

@@ -74,7 +74,7 @@ module Ruote
       check_waiting
     end
 
-    def wait_for (*interests)
+    def wait_for (interests)
 
       @waiting = [ Thread.current, interests ]
 
@@ -82,6 +82,8 @@ module Ruote
 
       Thread.stop if @waiting
 
+      # and when this thread gets woken up, go on and return __result__
+
       Thread.current['__result__']
     end
 
@@ -131,40 +133,45 @@ module Ruote
       end
     end
 
-    def check_interest (msg)
+    FINAL_ACTIONS = %w[ terminated ceased error_intercepted ]
 
-      over = false
+    def check_interest (msg)
 
       action = msg['action']
 
-      Array(@waiting.last).each do |interest|
+      @waiting.last.each do |interest|
 
-        over = if interest.is_a?(Symbol) # participant
+        satisfied =  if interest == :inactive
 
-          (action == 'dispatch' && msg['participant_name'] == interest.to_s)
+          (FINAL_ACTIONS.include?(action) && @context.worker.inactive?)
 
-        elsif interest.is_a?(Fixnum)
+        elsif interest == :empty
 
-          interest = interest - 1
-          @waiting = [ @waiting.first, interest ]
+          (action == 'terminated' && @context.storage.empty?('expressions'))
 
-          #@debug ||= {}
-          #c = @debug[action] ||= 0
-          #@debug[action] = c+1
-          #p [ interest, @debug ]
+        elsif interest.is_a?(Symbol) # participant
 
-          (interest < 1)
+          (action == 'dispatch' && msg['participant_name'] == interest.to_s)
+
+        elsif interest.is_a?(Fixnum)
+
+          @waiting[-1] = @waiting[-1] - [ interest ]
+          if (interest > 1)
+            @waiting[-1] << (interest - 1)
+            false
+          else
+            true
+          end
 
         else # wfid
 
-          %w[ terminated ceased error_intercepted ].include?(action) &&
-          msg['wfid'] == interest
+          (FINAL_ACTIONS.include?(action) && msg['wfid'] == interest)
         end
 
-        break if over
+        @waiting[-1] = @waiting[-1] - [ interest ] if satisfied
       end
 
-      over
+      @waiting.last.size < 1
     end
 
     # <ESC>[{attr1};...;{attrn}m
@@ -244,6 +251,7 @@ module Ruote
       action = msg['action'][0, 2]
       action = case msg['action']
         when 'receive' then 'rc'
+        when 'dispatched' then 'dd'
         when 'dispatch_cancel' then 'dc'
         else action
       end
@@ -253,8 +261,9 @@ module Ruote
         when 'ce' then color('31', action)
         when 'ca' then color('31', action)
         when 'rc' then color('4;33', action)
-        when 'dc' then color('4;31', action)
         when 'di' then color('4;33', action)
+        when 'dd' then color('4;33', action)
+        when 'dc' then color('4;31', action)
         else action
       end
 

data/lib/ruote/log/wait_logger.rb

@@ -55,12 +55,14 @@ module Ruote
       check_msg(msg)
     end
 
-    def wait_for (interest)
+    def wait_for (interests)
 
-      @waiting = [ Thread.current, interest ]
+      @waiting = [ Thread.current, interests ]
 
       Thread.stop
 
+      # and when this thread gets woken up, go on and return __result__
+
       Thread.current['__result__']
     end
   end

data/lib/ruote/parser.rb

@@ -104,7 +104,8 @@ module Ruote
         t = atts.find { |k, v| v == nil }
         if t
           atts.delete(t.first)
-          atts['ref'] = t.first
+          key = tree[0] == 'if' ? 'test' : 'ref'
+          atts[key] = t.first
         end
 
         atts = atts.inject({}) { |h, (k, v)| h[k.to_s.gsub(/\_/, '-')] = v; h }

data/lib/ruote/part/dispatch_pool.rb

@@ -89,25 +89,25 @@ module Ruote
       workitem.fields['dispatched_at'] = Ruote.now_to_utc_s
 
       participant.consume(workitem)
+
+      @context.storage.put_msg('dispatched', 'fei' => msg['fei'])
+        # once the consume is done, asynchronously flag the
+        # participant expression as 'dispatched'
     end
 
     def do_threaded_dispatch (participant, msg)
 
+      # Maybe at some point a limit on the number of dispatch threads
+      # would be OK.
+      # Or maybe it's the job of an extension / subclass
+
       Thread.new do
         begin
 
           do_dispatch(participant, msg)
 
-        rescue Exception => e
-
-          #puts '/' * 80
-          #p e
-          #puts '/' * 80
-
-          @context.worker.handle_exception(
-            msg,
-            Ruote::Exp::FlowExpression.fetch(@context, msg['workitem']['fei']),
-            e)
+        rescue Exception => exception
+          @context.error_handler.msg_handle(msg, exception)
         end
       end
     end

data/lib/ruote/part/engine_participant.rb

@@ -63,7 +63,7 @@ module Ruote
   # detail the class and the arguments to the storage of the target engine.
   #
   # This example is a bit dry / flat. A real world example would perhaps detail
-  # a 'master' engine connected to 'departemental' engines, something more
+  # a 'master' engine connected to 'departmental' engines, something more
   # hierarchical.
   #
   # The example also binds reciprocally engines. If the delegated processes
@@ -105,7 +105,7 @@ module Ruote
 
     include LocalParticipant
 
-    def initialize (opts=nil)
+    def initialize (opts)
 
       if pa = opts['storage_path']
         require pa

data/lib/ruote/part/local_participant.rb

@@ -22,6 +22,8 @@
 # Made in Japan.
 #++
 
+require 'ruote/receiver/base'
+
 
 module Ruote
 
@@ -31,22 +33,112 @@ module Ruote
   # Assumes the class that includes this module has a #context method
   # that points to the worker or engine ruote context.
   #
+  # It's "local" because it has access to the ruote storage.
+  #
   module LocalParticipant
 
+    include ReceiverMixin
+      # the reply_to_engine method is there
+
     attr_accessor :context
 
-    # Sends back the workitem to the ruote engine.
+    # Use this method to re_dispatch the workitem.
     #
-    def reply_to_engine (workitem)
-
-      # the local participant knows how to deal with the storage directly
+    # It takes two options :in and :at for "later re_dispatch".
+    #
+    # Look at the unschedule_re_dispatch method for an example of
+    # participant implementation that uses re_dispatch.
+    #
+    # Without one of those options, the method is a "reject".
+    #
+    def re_dispatch (workitem, opts={})
 
-      @context.storage.put_msg(
-        'receive',
+      msg = {
+        'action' => 'dispatch',
         'fei' => workitem.h.fei,
         'workitem' => workitem.h,
-        'participant_name' => workitem.participant_name)
+        'participant_name' => workitem.participant_name,
+        'rejected' => true
+      }
+
+      if t = opts[:in] || opts[:at]
+
+        sched_id = @context.storage.put_schedule('at', workitem.h.fei, t, msg)
+
+        fexp = fetch_flow_expression(workitem)
+        fexp.h['re_dispatch_sched_id'] = sched_id
+        fexp.try_persist
+
+      else
+
+        @context.storage.put_msg('dispatch', msg)
+      end
+    end
+
+    # Cancels the scheduled re_dispatch, if any.
+    #
+    # An example or 'retrying participant' :
+    #
+    #   class RetryParticipant
+    #     include Ruote::LocalParticipant
+    #
+    #     def initialize (opts)
+    #       @opts = opts
+    #     end
+    #
+    #     def consume (workitem)
+    #       begin
+    #         do_the_job
+    #         reply(workitem)
+    #       rescue
+    #         re_dispatch(workitem, :in => @opts['delay'] || '1s')
+    #       end
+    #     end
+    #
+    #     def cancel (fei, flavour)
+    #       unschedule_re_dispatch(fei)
+    #     end
+    #   end
+    #
+    # Note how unschedule_re_dispatch is used in the cancel method. Warning,
+    # this example could loop forever...
+    #
+    def unschedule_re_dispatch (fei)
+
+      fexp = Ruote::Exp::FlowExpression.fetch(
+        @context, Ruote::FlowExpressionId.extract_h(fei))
+
+      if s = fexp.h['re_dispatch_sched_id']
+        @context.storage.delete_schedule(s)
+      end
     end
+
+    # WARNING : this method is only for 'stateless' participants, ie
+    # participants that are registered in the engine by passing their class
+    # and a set of options, like in
+    #
+    #   engine.register_participant 'alpha', MyParticipant, 'info' => 'none'
+    #
+    # This reject method replaces the workitem in the [internal] message queue
+    # of the ruote engine (since it's a local participant, it has access to
+    # the storage and it's thus easy).
+    # The idea is that another worker will pick up the workitem and
+    # do the participant dispatching.
+    #
+    # This is an advanced technique. It was requested by people who
+    # want to have multiple workers and have only certain worker/participants
+    # do the handling.
+    # Using reject is not the best method, it's probably better to implement
+    # this by re-opening the Ruote::Worker class and changing the
+    # cannot_handle(msg) method.
+    #
+    # reject could be useful anyway, not sure now, but one could imagine
+    # scenarii where some participants reject workitems temporarily (while
+    # the same participant on another worker would accept it).
+    #
+    # Well, here it is, use with care.
+    #
+    alias :reject :re_dispatch
   end
 end