openwferu 0.9.4 → 0.9.5

data/lib/openwfe/expressions/fe_concurrence.rb

@@ -41,6 +41,7 @@
 
 require 'openwfe/utils'
 require 'openwfe/rudefinitions'
+require 'openwfe/expressions/condition'
 require 'openwfe/expressions/flowexpression'
 
 
@@ -50,7 +51,84 @@ require 'openwfe/expressions/flowexpression'
 
 module OpenWFE
 
+    #
+    # The concurrence expression will execute each of its (direct) children
+    # in parallel threads.
+    #
+    # Thus,
+    #
+    #     <concurrence>
+    #         <participant ref="pa" />
+    #         <participant ref="pb" />
+    #     </concurrence>
+    #
+    # Participants pa and pb will be 'treated' in parallel (quasi 
+    # simultaneously).
+    #
+    # The concurrence expressions accept many attributes, that can get
+    # combined. By default, the concurrence waits for all its children to 
+    # reply and returns the workitem of the first child that replied.
+    # The attributes tune this behaviour.
+    #
+    # <em>count</em>
+    #
+    #     <concurrence count="1">
+    #         <participant ref="pa" />
+    #         <participant ref="pb" />
+    #     </concurrence>
+    #
+    # The concurrence will be over as soon as 'pa' or 'pb' replied, i.e.
+    # as soon as "1" child replied.
+    #
+    # <em>remaining</em>
+    #
+    # The attribute 'remaining' can take two values 'cancel' (the default) and
+    # 'forget'.
+    # Cancelled children are completely wiped away, forgotten ones continue
+    # to operate but their reply will simply get discarded.
+    #
+    # <em>over-if</em>
+    #
+    # 'over-if' accepts a 'boolean expression' (something replying 'true' or
+    # 'false'), if the expression evaluates to true, the concurrence will be
+    # over and the remaining children will get cancelled (the default) or 
+    # forgotten.
+    #
+    # <em>merge</em>
+    #
+    # By default, the first child to reply to its parent 'concurrence' 
+    # expression 'wins', i.e. its workitem is used for resuming the flow (after
+    # the concurrence).
+    #
+    # [first]    The default : the first child to reply wins
+    # [last]     The last child to reply wins
+    # [highest]  The first 'defined' child (in the list of children) will win
+    # [lowest]   The last 'defined' child (in the list of children) will win
+    #
+    # Thus, in that example
+    #
+    #     <concurrence merge="lowest">
+    #         <participant ref="pa" />
+    #         <participant ref="pb" />
+    #     </concurrence>
+    #
+    # when the concurrence is done, the workitem of 'pb' is used to resume the
+    # flow after the concurrence.
+    #
+    # <em>merge-type</em>
+    #
+    # [override]  The default : no mix of values between the workitems do occur
+    # [mix]       Priority is given to the 'winning' workitem but their values
+    #             get mixed
+    #
+    # The merge occurs are the top level of workitem attributes.
+    #
+    # More complex merge behaviour can be obtained by extending the 
+    # GenericSyncExpression class. But the default sync options are already
+    # numerous and powerful.
+    #
     class ConcurrenceExpression < SequenceExpression
+        include ConditionMixin
 
         attr_accessor \
             :sync_expression
@@ -73,6 +151,7 @@ module OpenWFE
             @children.each do |child|
                 Thread.new do
                     begin
+                        #ldebug { "apply() child : #{child.to_debug_s}" }
                         concurrence.synchronize do
                             get_expression_pool().apply(child, workitem.dup)
                         end
@@ -141,6 +220,11 @@ module OpenWFE
             @count = determine_count(synchable, workitem)
             @cancel_remaining = cancel_remaining?(synchable, workitem)
 
+            merge = synchable.lookup_attribute(:merge, workitem, :first)
+            merge_type = synchable.lookup_attribute(:merge_type, workitem, :mix)
+
+            @merge_array = MergeArray.new(merge, merge_type)
+
             @unready_queue = []
         end
 
@@ -162,7 +246,11 @@ module OpenWFE
                 synchable.store_itself()
 
                 queue.each do |workitem|
-                    do_reply(synchable, workitem)
+                    break if do_reply(synchable, workitem)
+                        #
+                        # do_reply() will return 'true' as soon as the 
+                        # concurrence is over, if this is the case, the
+                        # queue should not be treated anymore
                 end
             end
         end
@@ -200,27 +288,52 @@ module OpenWFE
                     "#{workitem.last_expression_id.to_debug_s}"
                 end
 
+                @merge_array.push(synchable, workitem)
+
                 @reply_count = @reply_count + 1
 
                 @remaining_children.delete(workitem.last_expression_id)
 
                 if @remaining_children.length <= 0
-                    synchable.reply_to_parent(workitem)
-                    return
+                    reply_to_parent(synchable)
+                    return true
                 end
 
                 if @count > 0 and @reply_count >= @count
                     treat_remaining_children(synchable)
-                    synchable.reply_to_parent(workitem)
-                    return
+                    reply_to_parent(synchable)
+                    return true
+                end
+
+                #
+                # over-if
+
+                conditional = synchable.eval_condition("over-if", workitem)
+
+                if conditional
+                    treat_remaining_children(synchable)
+                    reply_to_parent(synchable)
+                    return true
                 end
 
+                #
+                # not over, resuming
+
                 synchable.store_itself()
 
                 #synchable.ldebug do
                 #    "#{self.class}.do_reply() not replying to parent "+
                 #    "#{workitem.last_expression_id.to_debug_s}"
                 #end
+
+                return false
+            end
+
+            def reply_to_parent (synchable)
+
+                workitem = @merge_array.do_merge
+
+                synchable.reply_to_parent(workitem)
             end
 
             def treat_remaining_children (synchable)
@@ -260,20 +373,143 @@ module OpenWFE
                 return -1 if i < 1
                 return i
             end
-    end
 
-    #
-    # Merges a workitem (source) into another (target).
-    # If inPlace is left to false, a brand new workitem is returned,
-    # else the merge occurs directly into the target workitem.
-    #
-    def merge (wiTarget, wiSource, inPlace=false)
+            #
+            # This inner class is used to gather workitems before the final
+            # merge, which is triggered by calling the do_merge() method
+            # which returns the merged workitem.
+            #
+            class MergeArray
 
-        wiTarget = wiTarget.dup if not inPlace
+                attr_accessor \
+                    :workitem,
+                    :workitems_by_arrival,
+                    :workitems_by_altitude,
+                    :merge,
+                    :merge_type
+
+                def initialize (merge, merge_type)
+
+                    @merge = merge.downcase
+                    @merge_type = merge_type.downcase
+
+                    ensure_merge_settings()
+
+                    @workitem = nil
+
+                    if highest? or lowest?
+                        @workitems_by_arrival = []
+                        @workitems_by_altitude = []
+                    end
+                end
+
+                def push (synchable, wi)
+
+                    if not @workitems_by_arrival
+                        #
+                        # last or first
+                        #
+                        source, target = if first?
+                            [ @workitem, wi ]
+                        else
+                            [ wi, @workitem ]
+                        end
+                        @workitem = merge(target, source)
+
+                        return
+                    end
+
+                    index = synchable.children.index(
+                        wi.last_expression_id)
+
+                    @workitems_by_arrival << wi
+                    @workitems_by_altitude[index] = wi
+                end
+
+                #
+                # merges the workitems stored here
+                #
+                def do_merge
+
+                    return @workitem if @workitem
+
+                    list = if first?
+                        @workitems_by_arrival.reverse
+                    elsif last?
+                        @workitems_by_arrival
+                    elsif highest?
+                        @workitems_by_altitude.reverse
+                    elsif lowest?
+                        @workitems_by_altitude
+                    end
+
+                    result = nil
+
+                    list.each do |wi|
+                        next unless wi
+                        result = merge(result, wi)
+                    end
+
+                    #puts "___ result :"
+                    #puts result.to_s
+                    #puts
+
+                    return result
+                end
+
+                protected
+
+                    def first?
+                        @merge == "first"
+                    end
+                    def last?
+                        @merge == "last"
+                    end
+                    def highest?
+                        @merge == "highest"
+                    end
+                    def lowest?
+                        @merge == "lowest"
+                    end
+
+                    def mix?
+                        @merge_type == "mix"
+                    end
+                    def override?
+                        @merge_type == "override"
+                    end
+
+                    #
+                    # Making sure @merge and @merge_type are set to
+                    # appropriate values.
+                    #
+                    def ensure_merge_settings
+
+                        @merge_type = "mix" unless override?
+                        @merge = "first" unless last? or highest? or lowest?
+                    end
+
+                    def merge (wiTarget, wiSource)
+
+                        return wiSource unless wiTarget
+                        return wiTarget unless wiSource
+
+                        return wiSource if override?
+
+                        wiSource.attributes.each do | k, v |
+
+                            #puts "merge() '#{k}' => '#{v}'"
+
+                            nk = OpenWFE::fulldup(k)
+                            nv = OpenWFE::fulldup(v)
+
+                            wiTarget.attributes[nk] = nv
+                        end
+
+                        return wiTarget
+                    end
+            end
 
-        wiSource.attributes.each do | k, v |
-            wiTarget.attributes[k.dup] = v.dup
-        end
     end
 
 end

data/lib/openwfe/expressions/fe_cursor.rb

@@ -39,8 +39,9 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/expressions/condition'
+require 'openwfe/expressions/wtemplate'
 require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/fe_condition'
 
 
 #
@@ -69,6 +70,7 @@ module OpenWFE
     class CursorExpression < WithTemplateExpression
 
         attr_accessor \
+            :loop_id,
             :current_child_id,
             :current_child_fei
 
@@ -77,6 +79,8 @@ module OpenWFE
 
         def apply (workitem)
 
+            @loop_id = 0
+
             @current_child_id = -1
 
             clean_children_list()
@@ -119,6 +123,7 @@ module OpenWFE
                         reply_to_parent(workitem)
                         return
                     end
+                    @loop_id += 1
                     @current_child_id = 0
                 end
             end
@@ -134,8 +139,8 @@ module OpenWFE
             #
             # launch the next child as a template
 
-            get_expression_pool\
-                .launch_template(self, @current_child_fei, workitem, nil)
+            get_expression_pool.launch_template(
+                self, @loop_id, @current_child_fei, workitem, nil)
         end
 
         #

data/lib/openwfe/{util/stoppable.rb → expressions/fe_do.rb}

@@ -39,30 +39,61 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/expressions/flowexpression'
+
+
+#
+# do / redo / undo
+#
 
 module OpenWFE
 
     #
-    # A simple mixin for adding a stopped instance variable and some
-    # methods around it to a class (or an object).
+    # in preparation.
     #
-    module Stoppable
+    class DoExpression < FlowExpression
+
+        attr_accessor \
+            :name
 
-        def initialize
-            @stopped = false
+        #
+        # apply / reply
+
+        def apply (workitem)
         end
 
-        def do_stop
-            @stopped = true
+        def reply (workitem)
         end
+    end
+
+    #
+    # in preparation.
+    #
+    class UndoExpression < FlowExpression
+
+        #
+        # apply / reply
 
-        def do_restart
-            @stopped = false
+        def apply (workitem)
         end
 
-        def is_stopped?
-            @stopped
+        #def reply (workitem)
+        #end
+    end
+
+    #
+    # in preparation.
+    #
+    class RedoExpression < FlowExpression
+
+        #
+        # apply / reply
+
+        def apply (workitem)
         end
+
+        #def reply (workitem)
+        #end
     end
 
 end

data/lib/openwfe/expressions/fe_iterator.rb

@@ -64,7 +64,8 @@ module OpenWFE
     #
     class IteratorExpression < WithTemplateExpression
 
-        attr_accessor :iterator
+        attr_accessor \
+            :iterator
 
         def apply (workitem)
 
@@ -89,8 +90,8 @@ module OpenWFE
 
             store_itself()
 
-            get_expression_pool\
-                .launch_template(self, @children[0], workitem, nil)
+            get_expression_pool.launch_template(
+                self, 0, @children[0], workitem, nil)
         end
     end
 

data/lib/openwfe/expressions/fe_misc.rb

@@ -88,11 +88,12 @@ module OpenWFE
             code = OpenWFE::lookup_vf_attribute(self, workitem, 'code')
 
             code = OpenWFE::fetch_text_content(self, workitem, escape) \
-                if not code
+                unless code
 
             result = eval(code.to_s)
 
-            OpenWFE::set_result(workitem, result) if result != nil
+            OpenWFE::set_result(workitem, result) \
+                if result != nil  # 'false' is a valid result
 
             reply_to_parent(workitem)
         end

data/lib/openwfe/expressions/fe_participant.rb

@@ -69,6 +69,8 @@ module OpenWFE
 
         def apply (workitem)
 
+            remove_timedout_flag(workitem)
+
             @applied_workitem = workitem.dup
 
             @participant_name = OpenWFE::lookup_ref(self, workitem)
@@ -122,6 +124,9 @@ module OpenWFE
                     # so that cancel won't unschedule without need 
 
                 cancel()
+
+                set_timedout_flag(@applied_workitem)
+
                 reply_to_parent(@applied_workitem)
             rescue
                 lerror do

data/lib/openwfe/expressions/fe_raw.rb

@@ -107,8 +107,15 @@ module OpenWFE
                 #
                 # is it a subprocess ?
 
-            template = get_participant_map.lookup_participant(exp_name) \
-                if (not template) and (not exp_class)
+            if (not template) and (not exp_class)
+
+                template = get_participant_map.lookup_participant(exp_name)
+
+                unless template
+                    exp_name = OpenWFE::to_underscore(exp_name)
+                    template = get_participant_map.lookup_participant(exp_name)
+                end
+            end
                     #
                     # is it a directly a participant ?
 
@@ -167,6 +174,7 @@ module OpenWFE
 
                 get_expression_pool().launch_template(
                     self, 
+                    0,
                     template, 
                     workitem, 
                     lookup_attributes(workitem))

data/lib/openwfe/expressions/fe_subprocess.rb

@@ -93,7 +93,7 @@ module OpenWFE
             #puts " ... params are #{params.to_s}"
 
             get_expression_pool()\
-                .launch_template(requester, template_fei, workitem, params)
+                .launch_template(requester, 0, template_fei, workitem, params)
         end
 
         #def reply (workitem)

data/lib/openwfe/expressions/fe_time.rb

@@ -44,7 +44,7 @@ require 'openwfe/utils'
 require 'openwfe/util/otime'
 require 'openwfe/util/scheduler'
 require 'openwfe/expressions/timeout'
-require 'openwfe/expressions/fe_condition'
+require 'openwfe/expressions/condition'
 
 
 #
@@ -108,31 +108,31 @@ module OpenWFE
             :awakening_time
 
         def apply (workitem)
-            synchronize do
+            #synchronize do
 
-                sfor = lookup_attribute(:for, workitem)
-                suntil = lookup_attribute(:until, workitem)
+            sfor = lookup_attribute(:for, workitem)
+            suntil = lookup_attribute(:until, workitem)
 
-                tuntil = nil
+            tuntil = nil
 
-                if suntil
-                    tuntil = suntil
-                elsif sfor
-                    tfor = OpenWFE::parse_time_string(sfor)
-                    ldebug { "apply() tfor is '#{tfor}'" }
-                    tuntil = Time.new.to_f + tfor
-                end
+            if suntil
+                tuntil = suntil
+            elsif sfor
+                tfor = OpenWFE::parse_time_string(sfor)
+                ldebug { "apply() tfor is '#{tfor}'" }
+                tuntil = Time.new.to_f + tfor
+            end
 
-                if not tuntil
-                    reply_to_parent(workitem)
-                    return
-                end
+            if not tuntil
+                reply_to_parent(workitem)
+                return
+            end
 
-                @awakening_time = tuntil
-                @applied_workitem = workitem.dup
+            @awakening_time = tuntil
+            @applied_workitem = workitem.dup
 
-                reschedule(get_scheduler)
-            end
+            reschedule(get_scheduler)
+            #end
         end
 
         #def reply (workitem)
@@ -159,6 +159,8 @@ module OpenWFE
         #
         def reschedule (scheduler)
 
+            return unless @awakening_time
+
             ldebug do 
                 "[re]schedule() " + 
                 "will sleep until '#{@awakening_time}' " +
@@ -197,10 +199,12 @@ module OpenWFE
     class CronExpression < TimeExpression
 
         attr_accessor \
-            :raw_child, :tab, :name
+            :raw_child, :tab, :name, :counter
 
         def apply (workitem)
 
+            @counter = 0
+
             if @children.size < 1
                 reply_to_parent(workitem)
                 return
@@ -229,7 +233,7 @@ module OpenWFE
             # (have to do it after the reschedule, so that the schedule
             # info is stored within the variable)
 
-            set_variable(@name, self)
+            set_variable(@name, self) if @name
 
             #
             # resume flow
@@ -260,8 +264,17 @@ module OpenWFE
             @raw_child.application_context = @application_context
 
             begin
+
                 get_expression_pool.launch_template(
-                    @fei.wfid, @raw_child, @applied_workitem.dup)
+                    @fei.wfid, @counter, @raw_child, @applied_workitem.dup)
+
+                #
+                # update count and store self
+
+                @counter += 1
+
+                set_variable(@name, self) if @name
+
             rescue
                 lerror do 
                     "trigger() cron caught exception\n"+
@@ -277,6 +290,8 @@ module OpenWFE
         #
         def reschedule (scheduler)
 
+            #return unless @applied_workitem
+
             @scheduler_job_id = @name.dup
 
             @scheduler_job_id = "#{@fei.wfid}__#{@scheduler_job_id}" \
@@ -314,6 +329,8 @@ module OpenWFE
 
         def apply (workitem)
 
+            remove_timedout_flag(workitem)
+
             if @children.size < 1
                 reply_to_parent(workitem)
                 return
@@ -366,6 +383,7 @@ module OpenWFE
                 #
                 # do timeout...
                 #
+                set_timedout_flag(@applied_workitem)
                 reply_to_parent(@applied_workitem)
                 return
             end
@@ -377,6 +395,8 @@ module OpenWFE
 
         def reschedule (scheduler)
 
+            #return unless @applied_workitem
+
             @scheduler_job_id = 
                 scheduler.schedule_in(@frequency, self, nil)