ruote 2.1.10 → 2.1.11

data/lib/ruote/exp/fe_iterator.rb

@@ -78,6 +78,17 @@ module Ruote::Exp
   #   end
   #
   #
+  # == the classical case
+  #
+  # Iterating over a workitem field :
+  #
+  #   pdef = Ruote.process_definition :name => 'test' do
+  #     iterator :on_field => 'customers', :to_f => 'customer'
+  #       participant '${f:customer}'
+  #     end
+  #   end
+  #
+  #
   # == break/rewind/continue/skip/jump
   #
   # The 'iterator' expression understands a certain the following commands :
@@ -97,6 +108,35 @@ module Ruote::Exp
   #     end
   #   end
   #
+  # == iterator command in the workitem
+  #
+  # It's OK to issue a command to the iterator from a participant via the
+  # workitem.
+  #
+  #   pdef = Ruote.process_definition do
+  #     iterator :times => 10
+  #       sequence do
+  #         participant 'accounting'
+  #         participant 'adjust'
+  #       end
+  #     end
+  #   end
+  #
+  # where
+  #
+  #   class Adjust
+  #     include Ruote::LocalParticipant
+  #     def consume (workitem)
+  #       workitem.command = 'break' if workitem.fields['amount'] > 10_000
+  #       reply_to_engine(workitem)
+  #     end
+  #     def cancel (fei, flavour)
+  #     end
+  #   end
+  #
+  # A completely stupid example... The adjust participant will make the
+  # loop break if the amount reaches 10_000 (euros?).
+  #
   #
   # == break/rewind/continue/skip/jump with :ref
   #

data/lib/ruote/exp/fe_listen.rb

@@ -136,13 +136,13 @@ module Ruote::Exp
       h.lmerge = attribute(:merge).to_s
       h.lmerge = 'true' if h.lmerge == ''
 
-      h.wfid = attribute(:wfid).to_s
-      h.wfid = %w[ same current true ].include?(h.wfid)
+      h.lwfid = attribute(:wfid).to_s
+      h.lwfid = %w[ same current true ].include?(h.lwfid)
 
       persist_or_raise
 
       @context.tracker.add_tracker(
-        h.wfid ? h.fei['wfid'] : nil,
+        h.lwfid ? h.fei['wfid'] : nil,
         h.upon,
         h.fei,
         { 'participant_name' => h.to },

data/lib/ruote/exp/fe_participant.rb

@@ -123,20 +123,26 @@ module Ruote::Exp
     #
     h_reader :dispatched
 
+    h_reader :participant
+
     def apply
 
       #
       # determine participant
 
-      h.participant_name = attribute(:ref) || attribute_text
+      h.participant_name = (attribute(:ref) || attribute_text).to_s
 
-      h.participant_name = h.participant_name.to_s
+      raise ArgumentError.new(
+        "no participant name specified"
+      ) if h.participant_name == ''
 
-      if h.participant_name == ''
-        raise ArgumentError.new("no participant name specified")
-      end
+      participant_info =
+        h.participant ||
+        @context.plist.lookup_info(h.participant_name, h.applied_workitem)
 
-      participant_info = @context.plist.lookup_info(h.participant_name)
+      unless participant_info.respond_to?(:consume)
+        h.participant = participant_info
+      end
 
       raise(ArgumentError.new(
         "no participant named #{h.participant_name.inspect}")
@@ -159,6 +165,7 @@ module Ruote::Exp
         'dispatch',
         'fei' => h.fei,
         'participant_name' => h.participant_name,
+        'participant' => h.participant,
         'workitem' => h.applied_workitem,
         'for_engine_worker?' => (participant_info.class != Array))
     end
@@ -177,14 +184,18 @@ module Ruote::Exp
         'dispatch_cancel',
         'fei' => h.fei,
         'participant_name' => h.participant_name,
+        'participant' => h.participant,
         'flavour' => flavour,
         'workitem' => h.applied_workitem)
     end
 
     def reply (workitem)
 
-      pa = @context.plist.lookup(
-        workitem['participant_name'], :on_reply => true)
+      pinfo =
+        h.participant ||
+        @context.plist.lookup_info(h.participant_name, workitem)
+
+      pa = @context.plist.instantiate(pinfo, :if_respond_to? => :on_reply)
 
       pa.on_reply(Ruote::Workitem.new(workitem)) if pa
 
@@ -227,10 +238,17 @@ module Ruote::Exp
     #
     def schedule_timeout (p_info)
 
-      timeout =
-        attribute(:timeout) ||
-        (p_info.timeout rescue nil) ||
-        (p_info.is_a?(Array) ? p_info.last['timeout'] : nil)
+      timeout = attribute(:timeout)
+
+      unless timeout
+
+        pa = @context.plist.instantiate(p_info, :if_respond_to? => :timeout)
+
+        timeout = pa.timeout if pa && pa.method(:timeout).arity == 0
+          #
+          # the arity check is for jruby which seems to have a timeout
+          # method here and there
+      end
 
       do_schedule_timeout(timeout)
     end

data/lib/ruote/exp/fe_ref.rb

@@ -0,0 +1,126 @@
+#--
+# Copyright (c) 2005-2010, 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Sometimes you don't know at 'design time', if you want to trigger a
+  # participant or subprocess.
+  #
+  #   Ruote.process_definition do
+  #     sequence do
+  #       participant 'alice'
+  #       ref '${solver}'
+  #       participant 'charlie'
+  #     end
+  #   end
+  #
+  # In this process, solver's name could be a participant name or a subprocess
+  # name.
+  #
+  # Subprocesses have the priority over participants.
+  #
+  # Note : this expression is used by the worker when substituting unknown
+  # expression names with participant or subprocess refs.
+  #
+  class RefExpression < FlowExpression
+
+    names :ref
+
+    def apply
+
+      key = (attribute(:ref) || attribute_text).to_s
+
+      if name != 'ref'
+        key = name
+        tree[1]['ref'] = key
+      end
+
+      key2, value = iterative_var_lookup(key)
+
+      tree[1]['ref'] = key2 if key2
+      tree[1]['original_ref'] = key if key2 != key
+
+      unless value
+        #
+        # seems like it's participant
+
+        @h['participant'] =
+          @context.plist.lookup_info(tree[1]['ref'], h.applied_workitem)
+
+        value = key2 if ( ! @h['participant']) && (key2 != key)
+      end
+
+      if value.is_a?(Array) && value.size == 2 && value.last.is_a?(Hash)
+        #
+        # participant 'defined' in var
+
+        @h['participant'] = value
+      end
+
+      unless value || @h['participant']
+        #
+        # unknown participant or subprocess
+
+        @h['state'] = 'failed'
+        persist_or_raise
+
+        raise("unknown participant or subprocess '#{tree[1]['ref']}'")
+      end
+
+      new_exp = if @h['participant']
+
+        @h['participant'] = nil if @h['participant'].respond_to?(:consume)
+          # instantiated participant
+
+        tree[0] = 'participant'
+        @h['name'] = 'participant'
+        Ruote::Exp::ParticipantExpression.new(@context, @h)
+      else
+
+        tree[0] = 'subprocess'
+        @h['name'] = 'subprocess'
+        Ruote::Exp::SubprocessExpression.new(@context, @h)
+      end
+
+      do_schedule_timeout(attribute(:timeout)) if tree[0] == 'subprocess'
+        #
+        # since ref neutralizes consider_timeout because participant expressions
+        # handle timeout by themselves, we have to force timeout consideration
+        # for subprocess expressions
+
+      #new_exp.initial_persist
+        # not necessary
+
+      new_exp.apply
+    end
+
+    def consider_timeout
+
+      # neutralized
+    end
+  end
+end
+

data/lib/ruote/exp/fe_subprocess.rb

@@ -22,7 +22,7 @@
 # Made in Japan.
 #++
 
-require 'ruote/subprocess'
+require 'ruote/util/subprocess'
 
 
 module Ruote::Exp
@@ -153,6 +153,8 @@ module Ruote::Exp
 
     def apply
 
+      return invoke_engine_participant if attribute(:engine)
+
       ref = attribute(:ref) || attribute_text
 
       raise "no subprocess referred in #{tree}" unless ref
@@ -165,6 +167,23 @@ module Ruote::Exp
 
       launch_sub(pos, subtree, :variables => vars)
     end
+
+    protected
+
+    def invoke_engine_participant
+
+      atts = tree[1]
+
+      if ref = atts.find { |k, v| v.nil? }
+        ref = ref.first
+        atts.delete(ref)
+      end
+      atts['pdef'] = atts['ref'] || ref
+      atts['ref'] = atts.delete('engine')
+
+      @h['name'] = 'participant'
+      Ruote::Exp::ParticipantExpression.new(@context, @h).apply
+    end
   end
 end
 

data/lib/ruote/exp/fe_wait.rb

@@ -42,7 +42,10 @@ module Ruote::Exp
   #
   # == :for and :until
   #
-  # TODO
+  # 'wait' accepts as well :
+  #
+  #   wait :for => '30d' # wait for 30 days
+  #   wait :until => '2011/12/10 12:00:00' # any parseable date/time format
   #
   class WaitExpression < FlowExpression
 

data/lib/ruote/exp/fe_when.rb

@@ -96,16 +96,13 @@ module Ruote::Exp
   # As said, the default 'check' frequency is 10 seconds. This can be changed
   # by using the :frequency (or :freq) attribute.
   #
-  #    sequence do
-  #
-  #      participant 'logistic_unit'
-  #
-  #      _when '${v:/delivery_ok}', :frequency => '2d'
-  #        # block until delivery is OK (another branch of the process probably)
-  #        # check every two days
-  #
-  #      participant 'accounting_unit'
-  #    end
+  #   sequence do
+  #     participant 'logistic_unit'
+  #     _when '${v:/delivery_ok}', :frequency => '2d'
+  #       # block until delivery is OK (another branch of the process probably)
+  #       # check every two days
+  #     participant 'accounting_unit'
+  #   end
   #
   #
   # == :frequency and cron notation

data/lib/ruote/exp/flowexpression.rb

@@ -24,7 +24,6 @@
 
 require 'ruote/util/time'
 require 'ruote/util/ometa'
-require 'ruote/util/dollar'
 require 'ruote/util/hashdot'
 
 
@@ -120,7 +119,7 @@ module Ruote::Exp
     end
 
     # Turns this FlowExpression instance into a Hash (well, just hands back
-    # the base hash behind it.
+    # the base hash behind it).
     #
     def to_h
 
@@ -169,17 +168,25 @@ module Ruote::Exp
       action = msg['action']
 
       if action == 'reply' && fei['engine_id'] != context.engine_id
+        #
+        # the reply has to go to another engine, let's locate the
+        # 'engine participant' and give it the workitem/reply
+        #
+        # see ft_37 for a test/example
 
-        ep = context.plist.lookup(fei['engine_id'])
+        engine_participant =
+          context.plist.lookup(fei['engine_id'], msg['workitem'])
 
         raise(
           "no EngineParticipant found under name '#{fei['engine_id']}'"
-        ) unless ep
+        ) unless engine_participant
 
-        ep.reply(fei, msg['workitem'])
+        engine_participant.reply(fei, msg['workitem'])
         return
       end
 
+      # normal case
+
       fexp = nil
 
       3.times do
@@ -240,6 +247,10 @@ module Ruote::Exp
 
         trigger('on_cancel', workitem)
 
+      elsif (h.state == 'cancelling') and h.on_re_apply
+
+        trigger('on_re_apply', workitem)
+
       elsif (h.state == 'timing_out') and h.on_timeout
 
         trigger('on_timeout', workitem)
@@ -346,7 +357,9 @@ module Ruote::Exp
         elsif hra = msg['re_apply']
 
           hra = {} if hra == true
-          h.on_cancel = hra['tree'] || tree
+
+          h.on_re_apply = hra['tree'] || tree
+
           if fs = hra['fields']
             h.applied_workitem['fields'] = fs
           end
@@ -512,7 +525,7 @@ module Ruote::Exp
       workitem = msg['workitem']
 
       workitem['fields']['__error__'] = [
-        h.fei, Ruote.now_to_utc_s, error.class.to_s, error.message ]
+        h.fei, Ruote.now_to_utc_s, error.class.to_s, error.message, error.backtrace ]
 
       @context.storage.put_msg(
         'fail',
@@ -656,7 +669,7 @@ module Ruote::Exp
       end
     end
 
-    # Called by do_apply. Overriden in ParticipantExpression.
+    # Called by do_apply. Overriden in ParticipantExpression and RefExpression.
     #
     def consider_timeout
 
@@ -669,9 +682,7 @@ module Ruote::Exp
     def do_schedule_timeout (timeout)
 
       return unless timeout
-
-      #h.timeout_at = Ruote.s_to_at(timeout)
-      #return if not(h.timeout_at) || h.timeout_at < Time.now.utc + 1.0
+      return if timeout.strip == ''
 
       h.timeout_schedule_id = @context.storage.put_schedule(
         'at',
@@ -711,7 +722,7 @@ module Ruote::Exp
         }.merge!(opts))
     end
 
-    # 'on_{error|timeout|cancel}' triggering
+    # 'on_{error|timeout|cancel|re_apply}' triggering
     #
     def trigger (on, workitem)
 

data/lib/ruote/exp/ro_attributes.rb

@@ -60,7 +60,7 @@ module Ruote::Exp
       elsif escape
         v
       else
-        Ruote.dosub(v, self, workitem)
+        @context.dollar_sub.s(v, self, workitem)
       end
 
       v = v.to_s if v and string
@@ -130,7 +130,7 @@ module Ruote::Exp
     def expand_atts (opts={})
 
       attributes.keys.inject({}) { |r, k|
-        kk = Ruote.dosub(k, self, h.applied_workitem)
+        kk = @context.dollar_sub.s(k, self, h.applied_workitem)
         r[kk] = attribute(k, h.applied_workitem, opts)
         r
       }
@@ -152,7 +152,7 @@ module Ruote::Exp
 
       text = attributes.keys.find { |k| attributes[k] == nil }
 
-      Ruote.dosub(text.to_s, self, workitem)
+      @context.dollar_sub.s(text.to_s, self, workitem)
     end
 
     protected
@@ -163,6 +163,8 @@ module Ruote::Exp
         attribute(:to_f) || attribute(:to_fld) || attribute(:to_field) ]
     end
 
+    # Val and Value (Sense and Sensibility ?)
+    #
     VV = %w[ val value ]
 
     def s_cartesian (a0, a1)
@@ -183,11 +185,6 @@ module Ruote::Exp
 
       elsif k = has_att(*flds)
 
-        #k = attribute(k, @applied_workitem, att_options)
-
-        #@applied_workitem.attributes[k.to_s] ||
-        #@applied_workitem.attributes[k.to_s.to_sym]
-
         k = attribute(k, h.applied_workitem, att_options)
         h.applied_workitem['fields'][k]
 

data/lib/ruote/exp/ro_variables.rb

@@ -50,7 +50,7 @@ module Ruote::Exp
     end
 
     # Looks up the value of a variable in expression tree
-    # (seen from a leave, it looks more like a stack than a tree)
+    # (seen from a leaf, it looks more like a stack than a tree)
     #
     def lookup_variable (var, prefix=nil)
 
@@ -118,7 +118,9 @@ module Ruote::Exp
       fexp.un_set_variable(:unset, v, nil, should_persist)
     end
 
-    # This method is mostly used by the expression pool when looking up
+    # TODO : redoc rewrite needed
+    #
+    # This method is mostly used by the worker when looking up
     # a process name or participant name bound under a variable.
     #
     def iterative_var_lookup (k)

data/lib/ruote/fei.rb

@@ -96,6 +96,8 @@ module Ruote
       "#{@h['expid']}!#{@h['sub_wfid']}!#{@h['wfid']}"
     end
 
+    alias sid to_storage_id
+
     def self.to_storage_id (hfei)
 
       hfei.respond_to?(:to_storage_id) ?

data/lib/ruote/id/wfid_generator.rb

@@ -50,7 +50,7 @@ module Ruote
       lraw = @last['raw'] + 0.01
 
       raw = Time.now.utc
-      while raw.to_f <= lraw; raw = raw + 0.01; end
+      raw = raw + 0.01 while raw.to_f <= lraw
 
       @last['raw'] = raw.to_f
 

data/lib/ruote/log/pretty.rb

@@ -0,0 +1,137 @@
+#--
+# Copyright (c) 2005-2010, 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  #
+  # A container for the pretty printing logic of TestLogger.
+  #
+  module PrettyLogging
+
+    protected
+
+    #--
+    # <ESC>[{attr1};...;{attrn}m
+    #
+    # 0 Reset all attributes
+    # 1 Bright
+    # 2 Dim
+    # 4 Underscore
+    # 5 Blink
+    # 7 Reverse
+    # 8 Hidden
+    #
+    # Foreground Colours
+    # 30 Black
+    # 31 Red
+    # 32 Green
+    # 33 Yellow
+    # 34 Blue
+    # 35 Magenta
+    # 36 Cyan
+    # 37 White
+    #
+    # Background Colours
+    # 40 Black
+    # 41 Red
+    # 42 Green
+    # 43 Yellow
+    # 44 Blue
+    # 45 Magenta
+    # 46 Cyan
+    # 47 White
+    #++
+
+    def color (mod, s, clear=false)
+
+      return s if Ruote::WIN
+      return s unless STDOUT.tty?
+
+      "[#{mod}m#{s}#{clear ? '' : "[#{@color}m"}"
+    end
+
+    def pretty_print (msg)
+
+      @count += 1
+      @count = 0 if @count > 9
+
+      ei = self.object_id.to_s[-2..-1]
+
+      fei = msg['fei']
+      depth = fei ? fei['expid'].split('_').size : 0
+
+      i = fei ?
+        [ fei['wfid'], fei['sub_wfid'], fei['expid'] ].join(' ') :
+        msg['wfid']
+
+      rest = msg.dup
+      %w[
+        _id put_at _rev
+        type action
+        fei wfid variables
+      ].each { |k| rest.delete(k) }
+
+      if v = rest['parent_id']
+        rest['parent_id'] = Ruote.to_storage_id(v)
+      end
+      if v = rest.delete('workitem')
+        rest[:wi] = [
+          v['fei'] ? Ruote.to_storage_id(v['fei']) : nil,
+          v['fields'].size ]
+      end
+
+      { 'tree' => :t, 'parent_id' => :pi }.each do |k0, k1|
+        if v = rest.delete(k0)
+          rest[k1] = v
+        end
+      end
+
+      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
+      action = case action
+        when 'la' then color('4;32', action)
+        when 'te' then color('4;31', action)
+        when 'ce' then color('31', action)
+        when 'ca' then color('31', action)
+        when 'rc' then color('4;33', 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
+
+      color(
+        @color,
+        "#{@count} #{ei} #{'  ' * depth}#{action} * #{i} #{rest.inspect}",
+        true)
+    end
+  end
+end
+