ruote 2.2.0 → 2.3.0

data/lib/ruote/exp/fe_once.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
@@ -149,7 +149,6 @@ module Ruote::Exp
 
       h.frequency = attribute(:frequency) || attribute(:freq) || '10s'
       h.triggered = false
-      h.job_id = nil
 
       reply(h.applied_workitem)
     end
@@ -164,37 +163,29 @@ module Ruote::Exp
 
         h.triggered = true
 
-        @context.storage.delete_schedule(h.job_id)
+        @context.storage.delete_schedule(h.schedule_id)
           # especially for a cron...
 
-        if tree_children[0]
-          #
-          # trigger first child
-          #
+        if tree_children[0] # trigger first child
+
           apply_child(0, workitem)
-        else
-          #
-          # blocking case
-          #
+
+        else # blocking case
+
           reply_to_parent(workitem)
         end
+
       else
 
         reschedule
       end
     end
 
-    def cancel(flavour)
-
-      @context.storage.delete_schedule(h.job_id)
-      super
-    end
-
     protected
 
     def reschedule
 
-      h.job_id = @context.storage.put_schedule(
+      h.schedule_id = @context.storage.put_schedule(
         'cron',
         h.fei,
         h.frequency,
@@ -202,7 +193,7 @@ module Ruote::Exp
         'fei' => h.fei,
         'workitem' => h.applied_workitem)
 
-      @context.storage.delete_schedule(h.job_id) if try_persist
+      @context.storage.delete_schedule(h.schedule_id) if try_persist
         #
         # if the persist failed, immediately unschedule
         # the just scheduled job

data/lib/ruote/exp/fe_participant.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
@@ -117,7 +117,7 @@ module Ruote::Exp
 
     names :participant
 
-    # Should return true when the dispatch was successful.
+    # Should yield true when the dispatch was successful.
     #
     h_reader :dispatched
 
@@ -131,32 +131,44 @@ module Ruote::Exp
       h.participant_name = (attribute(:ref) || attribute_text).to_s
 
       raise ArgumentError.new(
-        "no participant name specified"
+        'no participant name specified'
       ) if h.participant_name == ''
 
-      participant_info =
-        h.participant ||
+      h.participant ||=
         @context.plist.lookup_info(h.participant_name, h.applied_workitem)
 
-      unless participant_info.respond_to?(:consume)
-        h.participant = participant_info
-      end
-
       raise(ArgumentError.new(
         "no participant named #{h.participant_name.inspect}")
-      ) if participant_info.nil?
+      ) if h.participant.nil?
 
       #
-      # participant found, consider timeout
+      # trigger on_apply if the participant sports it
 
-      schedule_timeout(participant_info)
+      pa = @context.plist.instantiate(
+        h.participant, :if_respond_to? => :on_apply)
+
+      Ruote.participant_send(
+        pa, :on_apply, 'workitem' => Ruote::Workitem.new(h.applied_workitem)
+      ) if pa
 
       #
       # dispatch to participant
 
       h.applied_workitem['participant_name'] = h.participant_name
+
       h.applied_workitem['fields']['params'] = compile_atts
 
+      h.applied_workitem['fields'].delete('t')
+      h.applied_workitem['fields'].delete('__result__')
+
+      h.applied_workitem['re_dispatch_count'] = 0
+
+      if tree.last.any?
+        h.applied_workitem['fields']['params']['__children__'] = dsub(tree.last)
+      end
+
+      consider_participant_timers(h.participant)
+
       persist_or_raise
 
       @context.storage.put_msg(
@@ -169,6 +181,8 @@ module Ruote::Exp
 
     def cancel(flavour)
 
+      cancel_flanks(flavour)
+
       return reply_to_parent(h.applied_workitem) unless h.participant_name
         # no participant, reply immediately
 
@@ -194,7 +208,9 @@ module Ruote::Exp
 
       pa = @context.plist.instantiate(pinfo, :if_respond_to? => :on_reply)
 
-      pa.on_reply(Ruote::Workitem.new(workitem)) if pa
+      Ruote.participant_send(
+        pa, :on_reply, 'workitem' => Ruote::Workitem.new(workitem)
+      ) if pa
 
       super(workitem)
     end
@@ -222,32 +238,78 @@ module Ruote::Exp
         # let's not care if it fails...
     end
 
-    # Overriden with an empty behaviour. The work is now done a bit later
-    # via the #schedule_timeout method.
-    #
-    def consider_timeout
-    end
-
     # Determines and schedules timeout if any.
     #
     # Note that process definition timeout has priority over participant
     # specified timeout.
     #
-    def schedule_timeout(p_info)
+    def consider_participant_timers(p_info)
+
+      return if h.has_timers
+        # process definition takes precedence over participant defined timers.
+
+      timers = nil
+
+      [ :rtimers, :timers, :rtimeout ].each do |meth|
+
+        pa = @context.plist.instantiate(p_info, :if_respond_to? => meth)
+
+        next unless pa
 
-      timeout = attribute(:timeout)
+        timers = Ruote.participant_send(
+          pa, meth, 'workitem' => Ruote::Workitem.new(h.applied_workitem))
 
-      unless timeout
+        break if timers
+      end
 
-        pa = @context.plist.instantiate(p_info, :if_respond_to? => :rtimeout)
+      return unless timers
 
-        timeout = (pa.method(:rtimeout).arity == 0 ?
-          pa.rtimeout :
-          pa.rtimeout(Ruote::Workitem.new(h.applied_workitem))
-        ) if pa
+      timers = if timers.index(':')
+        timers.split(/,/)
+      else
+        [ "#{timers}: timeout" ]
       end
 
-      do_schedule_timeout(timeout)
+      schedule_timers(timers)
+    end
+
+    def do_pause(msg)
+
+      return if h.state != nil
+
+      h['state'] = 'paused'
+      h['breakpoint'] = true if msg['breakpoint']
+
+      do_persist || return
+
+      @context.storage.put_msg(
+        'dispatch_pause',
+        'fei' => h.fei,
+        'participant_name' => h.participant_name,
+        'participant' => h.participant
+      ) unless msg['breakpoint']
+    end
+
+    def do_resume(msg)
+
+      return if h.state != 'paused'
+
+      h['state'] = nil
+      replies = h.delete('paused_replies') || []
+
+      do_persist || return
+
+      if replies.empty?
+        @context.storage.put_msg(
+          'dispatch_resume',
+          'fei' => h.fei,
+          'participant_name' => h.participant_name,
+          'participant' => h.participant
+        ) unless h['breakpoint']
+      else
+        replies.each { |m| @context.storage.put_msg(m.delete('action'), m) }
+          # trigger replies
+      end
     end
   end
 end

data/lib/ruote/exp/fe_read.rb

@@ -0,0 +1,69 @@
+#--
+# 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
+# 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
+
+  #
+  # Reads the content of a local file or a file reachable over http and places
+  # the content in a [process] variable or a [workitem] field.
+  #
+  # Always attempts to parse the content as JSON. If the parsing fails, simply
+  # considers as plain text.
+  #
+  #   Ruote.process_definition do
+  #     read 'http://defs.example.org/filters/filter1.json', :to => 'x'
+  #     read 'http://defs.example.org/filters/filter1.json', :to => 'f:x'
+  #     read 'http://defs.example.org/filters/filter2.json', :to => 'v:y'
+  #     read 'filters/filter3.json', :to => 'f:y'
+  #     read 'texts/greetings${f:greeting_index}.txt', :to => 'f:greetings'
+  #     # ...
+  #   end
+  #
+  class ReadExpression < FlowExpression
+
+    names :read
+
+    def apply
+
+      to = attribute('to')
+      from = attribute('from') || attribute_text
+
+      content = open(from).read rescue nil
+        # should this happen in the worker loop ? thread out ?
+
+      content = Rufus::Json.decode(content) rescue content
+
+      set_vf(to, content)
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply(workitem)
+
+      # empty, never called
+    end
+  end
+end
+

data/lib/ruote/exp/fe_redo.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
@@ -63,7 +63,8 @@ module Ruote::Exp
 
       if tag && Ruote.is_a_fei?(tag)
 
-        @context.storage.put_msg('cancel', 'fei' => tag, 're_apply' => true)
+        @context.storage.put_msg(
+          'cancel', 'fei' => tag, 're_apply' => { 'workitem' => 'applied' })
 
         reply_to_parent(h.applied_workitem) unless ancestor?(tag)
 

data/lib/ruote/exp/fe_ref.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,7 +42,7 @@ module Ruote::Exp
   #
   # Subprocesses have the priority over participants.
   #
-  # Note : this expression is used by the worker when substituting unknown
+  # Note: this expression is used by the worker when substituting unknown
   # expression names with participant or subprocess refs.
   #
   class RefExpression < FlowExpression
@@ -58,6 +58,9 @@ module Ruote::Exp
         tree[1]['ref'] = key
       end
 
+      key = dsub(key)
+        # see test/functional/ft_62_
+
       key2, value = iterative_var_lookup(key)
 
       tree[1]['ref'] = key2 if key2
@@ -65,7 +68,7 @@ module Ruote::Exp
 
       unless value
         #
-        # seems like it's participant
+        # seems like it's a participant
 
         @h['participant'] =
           @context.plist.lookup_info(tree[1]['ref'], h.applied_workitem)
@@ -73,14 +76,54 @@ module Ruote::Exp
         value = key2 if ( ! @h['participant']) && (key2 != key)
       end
 
-      if value.is_a?(Array) && value.size == 2 && value.last.is_a?(Hash)
+      new_exp_name, new_exp_class = nil
+
+      # warning: abusing on 'then' in order to have [somehow] more readability
+
+      if
+        value.is_a?(String)
+      then
+
+        if
+          @context['participant_in_variable_enabled'] &&
+          value.match(/\bdef consume\(/) &&
+          (Rufus::TreeChecker.parse(value) rescue false)
+        then
+          #
+          # participant code passed
+
+          @h['participant'] = [ 'Ruote::CodeParticipant', { 'code' => value } ]
+          tree[1]['ref'] = key
+
+        elsif klass = @context.expmap.expression_class(tree[1]['ref'])
+          #
+          # aliased expression
+
+          new_exp_name = value
+          new_exp_class = klass
+        end
+
+      elsif
+        @context['participant_in_variable_enabled'] &&
+        value.is_a?(Hash) &&
+        value['on_workitem']
+      then
         #
         # participant 'defined' in var
 
+        @h['participant'] = [ 'Ruote::BlockParticipant', value ]
+
+      elsif
+        value.is_a?(Array) &&
+        value.size == 2 && value.last.is_a?(Hash)
+      then
+        #
+        # participant 'registered' in var
+
         @h['participant'] = value
       end
 
-      unless value || @h['participant']
+      if value == nil && @h['participant'] == nil
         #
         # unknown participant or subprocess
 
@@ -90,37 +133,24 @@ module Ruote::Exp
         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)
+      new_exp_name, new_exp_class = if new_exp_name
+        [ new_exp_name, new_exp_class ]
+      elsif @h['participant']
+        [ 'participant', Ruote::Exp::ParticipantExpression ]
       else
-
-        tree[0] = 'subprocess'
-        @h['name'] = 'subprocess'
-        Ruote::Exp::SubprocessExpression.new(@context, @h)
+        [ 'subprocess', Ruote::Exp::SubprocessExpression ]
       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
+      tree[0] = new_exp_name
+      @h['name'] = new_exp_name
+
+      new_exp = new_exp_class.new(@context, @h)
 
       #new_exp.initial_persist
         # not necessary
 
       new_exp.apply
     end
-
-    def consider_timeout
-
-      # neutralized
-    end
   end
 end