openwferu 0.9.7 → 0.9.8

data/lib/openwfe/expressions/fe_sleep.rb

@@ -41,6 +41,7 @@
 
 require 'openwfe/util/otime'
 require 'openwfe/util/scheduler'
+require 'openwfe/expressions/time'
 
 
 #
@@ -49,61 +50,6 @@ require 'openwfe/util/scheduler'
 
 module OpenWFE
 
-    #
-    # A parent class for CronExpression and SleepExpression, is never
-    # used directly.
-    # It contains a simple get_scheduler() method simplifying the scheduler
-    # localization for <sleep/> and <cron/>.
-    #
-    class TimeExpression < FlowExpression
-        include Schedulable
-
-        attr_accessor \
-            :applied_workitem,
-            :scheduler_job_id
-
-        #
-        # Makes sure to cancel any scheduler job associated with this
-        # expression
-        #
-        def cancel ()
-            synchronize do
-
-                ldebug { "cancel()..." }
-
-                unschedule()
-
-                return super()
-            end
-        end
-
-        def unschedule ()
-
-            ldebug { "unschedule() @scheduler_job_id is #{@scheduler_job_id}" }
-
-            get_scheduler.unschedule(@scheduler_job_id) \
-                if @scheduler_job_id
-        end
-
-        protected
-
-            #
-            # Will return true if this TimeExpression has a 
-            # 'scheduler_job_ib' and this job is this expression's job.
-            #
-            # The job_id is specifiable, so that this method can also be
-            # used by the 'when' expression for example.
-            #
-            def already_scheduled? (job_id=nil)
-
-                job_id = @scheduler_job_id unless job_id
-
-                s = get_scheduler.get_schedulable job_id
-
-                return (s and s.fei == self.fei)
-            end
-    end
-
     #
     # The 'sleep' expression expects one attribute, either 'for', either
     # 'until'.
@@ -129,9 +75,8 @@ module OpenWFE
             sfor = lookup_attribute(:for, workitem)
             suntil = lookup_attribute(:until, workitem)
 
-            if sfor == nil and suntil == nil
-                sfor = OpenWFE::fetch_text_content(self, workitem)
-            end
+            sfor = fetch_text_content(workitem) \
+                if sfor == nil and suntil == nil
 
             #ldebug { "apply() sfor is '#{sfor}'" }
             #ldebug { "apply() suntil is '#{suntil}'" }

data/lib/openwfe/expressions/fe_subprocess.rb

@@ -42,7 +42,6 @@
 #require 'uri'
 
 require 'openwfe/utils'
-require 'openwfe/expressions/fe_utils'
 
 
 #
@@ -90,7 +89,7 @@ module OpenWFE
 
         def apply (workitem)
 
-            ref = OpenWFE::lookup_ref(self, workitem)
+            ref = lookup_ref(workitem)
 
             raise "'subprocess' expression misses a 'ref', 'field-ref' or 'variable-ref' attribute" unless ref
 
@@ -114,13 +113,15 @@ module OpenWFE
 
             params = lookup_attributes(workitem)
 
-            text = OpenWFE::fetch_text_content(self, workitem, false)
+            text = fetch_text_content(workitem, false)
             params["0"] = text if text
 
+            #puts
             #puts " ... params are #{params.keys.join(', ')}"
+            #puts " ... values are #{params.values.join(', ')}"
 
-            get_expression_pool()\
-                .launch_template(requester, 0, template, workitem, params)
+            get_expression_pool.launch_template(
+                requester, get_next_sub_id, template, workitem, params)
         end
 
         #def reply (workitem)

data/lib/openwfe/expressions/fe_value.rb

@@ -41,9 +41,7 @@
 
 require 'openwfe/workitem'
 require 'openwfe/flowexpressionid'
-require 'openwfe/expressions/condition'
 require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/fe_utils'
 
 
 #
@@ -52,6 +50,17 @@ require 'openwfe/expressions/fe_utils'
 
 module OpenWFE
 
+    #
+    # The 'set' expression is used to set the value of a (process) variable or
+    # a (workitem) field.
+    #
+    #     <set field="price" value="CHF 12.00" />
+    #     <set variable="/stage" value="3" />
+    #     <set variable="/stage" field-value="f_stage" />
+    #     <set field="stamp" value="${r:Time.now.to_i}" />
+    #
+    # (Notice the usage of the dollar notation in the last exemple).
+    #
     class SetValueExpression < FlowExpression
 
         names :set
@@ -59,8 +68,7 @@ module OpenWFE
         def apply (workitem)
 
             if @children.length < 1
-                workitem.attributes[FIELD_RESULT] = \
-                    OpenWFE::lookup_value(self, workitem)
+                workitem.attributes[FIELD_RESULT] = lookup_value(workitem)
                 reply(workitem)
                 return
             end
@@ -73,8 +81,7 @@ module OpenWFE
             end
 
             #workitem.attributes[FIELD_RESULT] = child.to_s
-            workitem.attributes[FIELD_RESULT] = \
-                OpenWFE::fetch_text_content(self, workitem)
+            workitem.attributes[FIELD_RESULT] = fetch_text_content(workitem)
 
             reply(workitem)
         end
@@ -123,10 +130,16 @@ module OpenWFE
             #            return child
             #        end
             #    end
-            #    return OpenWFE::lookup_value(self, workitem)
+            #    return lookup_value(workitem)
             #end
     end
 
+    #
+    # 'unset' removes a field or a variable.
+    #
+    #     unset :field => "price"
+    #     unset :variable => "eval_result"
+    #
     class UnsetValueExpression < FlowExpression
 
         names :unset
@@ -151,119 +164,5 @@ module OpenWFE
         #end
     end
 
-    class ComparisonExpression < FlowExpression
-
-        def apply (workitem)
-
-            value_a = OpenWFE::lookup_value(self, workitem)
-            value_b = OpenWFE::lookup_value(self, workitem, 'other')
-
-            result = compare(value_a, value_b)
-
-            ldebug { "apply() result is '#{result}'  #{@fei.to_debug_s}" }
-
-            OpenWFE::set_result(workitem, result)
-
-            reply_to_parent(workitem)
-        end
-
-        protected
-
-            def compare (a, b)
-                raise "not yet implemented : '#{@fei.expressionName}'"
-            end
-    end
-
-    #
-    # <equals/>
-    #
-    class EqualsExpression < ComparisonExpression
-
-        names :equals
-
-        protected
-
-            def compare (a, b)
-                #ldebug { "compare()  #{fei.to_debug_s}" }
-                #ldebug { "compare() '#{a}' == '#{b}'" }
-                return a == b
-            end
-    end
-
-    #
-    #     <if/>
-    #
-    class IfExpression < FlowExpression
-        include ConditionMixin
-
-        names :if
-
-        attr_accessor \
-            :condition_replied
-
-        def apply (workitem)
-
-            reply_to_parent(workitem) if @children.length < 1
-
-            test = eval_condition(:test, workitem)
-
-            @condition_replied = (test != nil)
-                #
-                # if the "test" attribute is not used, test will be null
-
-            store_itself()
-
-            if test != nil
-                apply_consequence(test, workitem, 0)
-            else
-                get_expression_pool.apply(@children[0], workitem)
-            end
-        end
-
-        def reply (workitem)
-
-            if @condition_replied
-                reply_to_parent(workitem)
-                return
-            end
-
-            result = workitem.attributes[FIELD_RESULT]
-
-            @condition_replied = true
-
-            store_itself()
-
-            apply_consequence(result, workitem)
-        end
-
-        def reply_to_parent(workitem)
-            clean_children()
-            super(workitem)
-        end
-
-        protected
-
-            def apply_consequence (index, workitem, offset=1)
-
-                if index == true
-                    index = 0
-                elsif index == false
-                    index = 1
-                elsif index == nil
-                    index = 1
-                elsif not index.integer?
-                    index = 0
-                end
-
-                index = index + offset
-
-                if index >= @children.length
-                    reply_to_parent(workitem)
-                else
-                    get_expression_pool.apply(@children[index], workitem)
-                end
-            end
-    end
-
 end
 

data/lib/openwfe/expressions/fe_wait.rb

@@ -0,0 +1,79 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/expressions/time'
+
+
+module OpenWFE
+
+    #
+    # The 'wait' expression simply blocks/waits until the given condition
+    # evaluates to true.
+    # This expression accepts a timeout (else it will block ad eternam).
+    #
+    #     sequence do
+    #         wait :until => "${done} == true"
+    #         participant :toto
+    #     end
+    #
+    # Participant 'toto' will receive a workitem after the variable 'done' is
+    # set to true (somewhere else in the process definition).
+    #
+    #     sequence do
+    #         wait :runtil => "Time.new.to_i % 7 == 0"
+    #         participant :toto
+    #     end 
+    #
+    # Participant 'toto' will receive a workitem after a certain condition
+    # expressed directly in Ruby evaluates to true.
+    #
+    # 'wait' is different than 'when' : when it times out (if a timeout is set,
+    # the block ceases and the flow resumes. On a timeout, 'when' will not
+    # execute its nested 'consequence' child.
+    #
+    class WaitExpression < WaitingExpression
+
+        names :wait
+        conditions :until
+    end
+
+end
+

data/lib/openwfe/expressions/fe_when.rb

@@ -39,17 +39,16 @@
 # John Mettraux at openwfe.org
 #
 
-#require 'openwfe/rudefinitions'
 require 'openwfe/utils'
 require 'openwfe/util/otime'
 require 'openwfe/util/scheduler'
+require 'openwfe/expressions/time'
 require 'openwfe/expressions/timeout'
 require 'openwfe/expressions/condition'
-require 'openwfe/expressions/fe_sleep'
 
 
 #
-# expressions like 'sleep' and 'cron'
+# 'when' and 'wait'
 #
 
 module OpenWFE
@@ -65,129 +64,65 @@ module OpenWFE
     # where the participant "toto" will receive a workitem when the (local)
     # variable "over" has the value true.
     #
-    class WhenExpression < TimeExpression
-        include ConditionMixin, TimeoutMixin
+    # This is also possible :
+    #
+    #     <when>
+    #         <equals field-value="done" other-value="true" />
+    #         <participant ref="toto" />
+    #     </when>
+    #
+    # The 'when' expression by defaults, evaluates every 10 seconds its
+    # condition clause.
+    # A different frequency can be stated via the "frequency" attribute :
+    #
+    #     when :test => "${completion_level} == 4", :frequency => "1s"
+    #         participant "next_stage"
+    #     end
+    #
+    # will check for the completion_level value every second. The scheduler 
+    # itself is by default 'waking up' every 250 ms, so setting a frequency to 
+    # something smaller than that value might prove useless.
+    #
+    class WhenExpression < WaitingExpression
 
         names :when
+        conditions :test
 
         attr_accessor \
-            :frequency,
-            :consequence_triggered
+            :consequence_triggered,
+            :condition_sub_id
 
         DEFAULT_FREQUENCY = "10s"
 
         def apply (workitem)
 
-            remove_timedout_flag(workitem)
-
             if @children.size < 1
-                reply_to_parent(workitem)
+                reply_to_parent workitem
                 return
             end
 
-            @applied_workitem = workitem.dup
-
-            @frequency = 
-                lookup_attribute(:frequency, workitem, DEFAULT_FREQUENCY)
-            @frequency = 
-                OpenWFE::parse_time_string(@frequency)
-
-            determine_timeout()
-
+            @condition_sub_id = -1
             @consequence_triggered = false
 
-            store_itself()
-
-            trigger(nil)
+            super(workitem)
         end
 
         def reply (workitem)
 
-            ldebug do 
-                "reply() @consequence_triggered is '#{@consequence_triggered}'"
-            end
+            #ldebug do 
+            #    "reply() @consequence_triggered is '#{@consequence_triggered}'"
+            #end
 
             if @consequence_triggered
                 reply_to_parent(workitem)
                 return
             end
 
-            result = OpenWFE::get_result(workitem)
-
-            if result
-                apply_consequence(workitem)
-            else
-                reschedule(get_scheduler)
-            end
-        end
-
-        def cancel ()
-            to_unschedule()
-            super()
-        end
-
-        def trigger (params)
-
-            ldebug { "trigger() #{@fei.to_debug_s} params is #{params}" }
-
-            if params == :do_timeout!
-                #
-                # do timeout...
-                #
-                set_timedout_flag(@applied_workitem)
-                reply_to_parent(@applied_workitem)
-                return
-            end
-
-            @scheduler_job_id = nil
-
-            evaluate_condition()
-        end
-
-        def reschedule (scheduler)
-
-            #return unless @applied_workitem
-
-            @scheduler_job_id = 
-                scheduler.schedule_in(@frequency, self, nil)
-
-            ldebug { "reschedule() @scheduler_job_id is #{@scheduler_job_id}" }
-
-            to_reschedule(scheduler)
-        end
-
-        def reply_to_parent (workitem)
-
-            unschedule()
-            unschedule_timeout()
-
             super(workitem)
         end
 
         protected
 
-            def evaluate_condition
-
-                if @children.size > 1
-                    #
-                    # trigger the evaluation of the first (condition) child
-
-                    store_itself()
-
-                    get_expression_pool.launch_template(
-                        self, @children[0], @applied_workitem)
-                else
-                    #
-                    # eval the attribute condition immediately
-
-                    c = eval_condition(:test, @applied_workitem)
-
-                    OpenWFE::set_result(@applied_workitem, c)
-
-                    reply(@applied_workitem)
-                end
-            end
-
             def apply_consequence (workitem)
 
                 @consequence_triggered = true