openwferu 0.9.7 → 0.9.8

data/lib/openwfe/expressions/fe_if.rb

@@ -0,0 +1,262 @@
+#
+#--
+# Copyright (c) 2006-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/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/expressions/condition'
+require 'openwfe/expressions/flowexpression'
+
+
+#
+# expressions like 'set' and 'unset' and their utility methods
+#
+
+module OpenWFE
+
+    #
+    # The 'if' expression.
+    #
+    #     <if>
+    #         <equals field-value="f0" other-value="true" />
+    #         <!-- then -->
+    #         <participant ref="alpha" />
+    #     </if>
+    #
+    # It accepts an 'else' clause :
+    #
+    #     <if>
+    #         <equals field-value="f0" other-value="true" />
+    #         <!-- then -->
+    #         <participant ref="alpha" />
+    #         <!-- else -->
+    #         <participant ref="bravo" />
+    #     </if>
+    #
+    # The 'test' attribute can be used instead of a condition child :
+    #
+    #     <if test="${f:f0}">
+    #         <!-- then -->
+    #         <participant ref="alpha" />
+    #     </if>
+    #
+    # The 'rtest' attribute can be used to embed a condition expressed directly
+    # in Ruby :
+    #
+    #     <if rtest="5 * 12 == 61">
+    #         <!-- then -->
+    #         <participant ref="alpha" />
+    #     </if>
+    #
+    # Used alone with 'test' or 'rtest', the 'if' expression simply sets the 
+    # the __result__ field of its workitem to the result of its attribute
+    # evaluation :
+    #
+    #     <if test="5 == 6"/>
+    #
+    # will set the __result__ field of the workitem to 'false'.
+    #
+    class IfExpression < FlowExpression
+        include ConditionMixin
+
+        names :if
+
+        attr_accessor \
+            :condition_replied
+
+        def apply (workitem)
+
+            workitem.unset_result
+
+            test = eval_condition(:test, workitem)
+
+            if @children.length < 1
+                workitem.set_result test if test
+                reply_to_parent(workitem) 
+                return
+            end
+
+            @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
+
+    #
+    # The 'case' expression.
+    #
+    #     <case>
+    #
+    #         <equals field="f0" other-value="ready" />
+    #         <participant ref="alpha" />
+    #
+    #         <if test="${supply_level} == ${field:supply_request}" />
+    #         <participant ref="bravo" />
+    #
+    #         <!-- optional else -->
+    #         <participant ref="charly" />
+    #
+    #     </case>
+    #
+    # A generalized 'if'. Will evaluate its children, expecting the order :
+    #
+    #     - condition
+    #     - consequence
+    #     - condition
+    #     - consequence
+    #     ...
+    #     - else consequence (optional)
+    #
+    # The 'switch' nickname can be used for 'case'.
+    #
+    class CaseExpression < FlowExpression
+
+        names :case, :switch
+
+        attr_accessor \
+            :offset,
+            :evaluating_condition
+
+        def apply (workitem)
+
+            workitem.unset_result
+
+            @offset = nil
+
+            trigger_child workitem, true
+        end
+
+        def reply (workitem)
+
+            if @evaluating_condition
+
+                result = workitem.get_boolean_result
+
+                #ldebug { "reply() result : '#{result.to_s}' (#{result.class})" }
+
+                trigger_child workitem, !result
+            else
+
+                reply_to_parent workitem
+            end
+        end
+
+        protected
+
+            def trigger_child (workitem, is_condition)
+
+                @offset = if !@offset
+                    0
+                elsif is_condition
+                    @offset + 2
+                else
+                    @offset + 1
+                end
+
+                #ldebug { "trigger_child() is_condition ? #{is_condition}" }
+                #ldebug { "trigger_child() next offset is #{@offset}" }
+
+                unless @children[@offset]
+                    reply_to_parent workitem
+                    return
+                end
+
+                @evaluating_condition = is_condition
+
+                store_itself
+
+                get_expression_pool.apply(@children[@offset], workitem)
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_iterator.rb

@@ -40,7 +40,6 @@
 #
 
 require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/fe_utils'
 
 
 module OpenWFE
@@ -93,7 +92,7 @@ module OpenWFE
             store_itself()
 
             get_expression_pool.launch_template(
-                self, 0, @children[0], workitem, nil)
+                self, @iterator.counter-1, @children[0], workitem, nil)
         end
     end
 
@@ -125,8 +124,8 @@ module OpenWFE
 
             @counter = 0
 
-            raw_list = OpenWFE::lookup_vf_attribute(
-                iterator_expression, workitem, :value, :on)
+            raw_list = iterator_expression.lookup_vf_attribute(
+                workitem, :value, :on)
 
             @iteration_list = extract_iteration_list(raw_list)
 

data/lib/openwfe/expressions/fe_losfor.rb

@@ -40,7 +40,6 @@
 #
 
 require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/fe_utils'
 
 
 module OpenWFE

data/lib/openwfe/expressions/fe_misc.rb

@@ -41,7 +41,6 @@
 
 require 'openwfe/util/safe'
 require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/fe_utils'
 
 
 module OpenWFE
@@ -57,7 +56,7 @@ module OpenWFE
 
             escape = lookup_boolean_attribute('escape', workitem, false)
 
-            text = OpenWFE::fetch_text_content(self, workitem, escape)
+            text = fetch_text_content(workitem, escape)
             text << "\n"
 
             tracer = @application_context['__tracer']
@@ -109,9 +108,9 @@ module OpenWFE
 
             escape = lookup_boolean_attribute('escape', workitem, false)
 
-            code = OpenWFE::lookup_vf_attribute(self, workitem, 'code')
+            code = lookup_vf_attribute(workitem, 'code')
 
-            code = OpenWFE::fetch_text_content(self, workitem, escape) \
+            code = fetch_text_content(workitem, escape) \
                 unless code
 
             code = code.to_s
@@ -119,7 +118,7 @@ module OpenWFE
             #result = eval(code)
             result = OpenWFE::eval_safely(code, SAFETY_LEVEL, binding())
 
-            OpenWFE::set_result(workitem, result) \
+            workitem.set_result(result) \
                 if result != nil  # 'false' is a valid result
 
             reply_to_parent(workitem)

data/lib/openwfe/expressions/fe_participant.rb

@@ -42,7 +42,6 @@
 require 'openwfe/utils'
 require 'openwfe/rudefinitions'
 require 'openwfe/expressions/timeout'
-require 'openwfe/expressions/fe_utils'
 
 
 #
@@ -75,9 +74,9 @@ module OpenWFE
 
             @applied_workitem = workitem.dup
 
-            @participant_name = OpenWFE::lookup_ref(self, workitem)
+            @participant_name = lookup_ref(workitem)
 
-            @participant_name = OpenWFE::fetch_text_content(self, workitem) \
+            @participant_name = fetch_text_content(workitem) \
                 unless @participant_name
 
             determine_timeout()

data/lib/openwfe/expressions/fe_raw.rb

@@ -81,12 +81,15 @@ module OpenWFE
 
             attributes = extract_attributes() unless attributes
 
+
             expression = exp_class.new(
                 @fei, 
                 @parent_id, 
                 @environment_id, 
                 @application_context, 
                 attributes)
+
+            consider_tag(workitem, expression)
             
             handle_descriptions()
 
@@ -117,17 +120,19 @@ module OpenWFE
                     template = get_participant_map.lookup_participant(exp_name)
                 end
             end
-                    #
-                    # is it a directly a participant ?
+                #
+                # is it a directly a participant ?
 
             if template 
 
                 if template.kind_of? OpenWFE::FlowExpressionId
-                    launch_template(template, workitem)
-                    return
-                end
 
-                if template.kind_of? OpenWFE::Participant
+                    exp_class = OpenWFE::SubProcessRefExpression
+                    attributes = extract_attributes()
+                    attributes["ref"] = exp_name
+
+                elsif template.kind_of? OpenWFE::Participant
+
                     exp_class = OpenWFE::ParticipantExpression
                     attributes = extract_attributes()
                     attributes["ref"] = exp_name
@@ -163,19 +168,19 @@ module OpenWFE
         #end
 
         def is_definition? ()
-            return get_expression_map.is_definition?(expression_name())
+            get_expression_map.is_definition?(expression_name())
         end
 
         def expression_class ()
-            return get_expression_map.get_class(expression_name())
+            get_expression_map.get_class(expression_name())
         end
 
         def definition_name ()
-            return raw_representation.attributes['name'].to_s
+            raw_representation.attributes['name'].to_s
         end
 
         def expression_name ()
-            return raw_representation.name
+            raw_representation.name
         end
         
         protected
@@ -206,27 +211,19 @@ module OpenWFE
                     unless default
             end
 
-            def launch_template (template, workitem)
-
-                @attributes = extract_attributes()
-
-                #require 'pp'
-                #pp attributes
-                #pp lookup_attributes(workitem, attributes)
-
-                params = lookup_attributes(workitem)
-
-                extract_text_children.each_with_index do |value, index|
-                    params[index.to_s] = value
-                end
-
-                get_expression_pool().launch_template(
-                    self, 
-                    0,
-                    template, 
-                    workitem, 
-                    params)
-            end
+            #def launch_template (template, workitem)
+            #    @attributes = extract_attributes()
+            #    params = lookup_attributes(workitem)
+            #    extract_text_children.each_with_index do |value, index|
+            #        params[index.to_s] = value
+            #    end
+            #    get_expression_pool().launch_template(
+            #        self, 
+            #        get_next_sub_id,
+            #        template, 
+            #        workitem, 
+            #        params)
+            #end
 
             def extract_attributes ()
                 raise NotImplementedError.new("'abstract method' sorry")
@@ -244,6 +241,49 @@ module OpenWFE
                 raise NotImplementedError.new("'abstract method' sorry")
             end
 
+            #
+            # Expressions can get tagged. Tagged expressions can easily
+            # be cancelled (undone) or redone.
+            #
+            def consider_tag (workitem, new_expression)
+
+                tagname = new_expression.lookup_attribute(:tag, workitem)
+
+                return unless tagname
+
+                ldebug { "consider_tag() tag is '#{tagname}'" }
+
+                set_variable(tagname, Tag.new(self, workitem))
+                    #
+                    # keep copy of raw expression and workitem as applied
+
+                new_expression.attributes["tag"] = tagname
+                    #
+                    # making sure that the value of tag doesn't change anymore
+            end
+
+            #
+            # A small class wrapping a tag (a raw expression and the workitem
+            # it received at apply time.
+            #
+            class Tag
+
+                attr_reader \
+                    :raw_expression,
+                    :workitem
+
+                def flow_expression_id
+                    @raw_expression.fei
+                end
+                alias :fei :flow_expression_id
+
+                def initialize (raw_expression, workitem)
+
+                    @raw_expression = raw_expression.dup
+                    @workitem = workitem.dup
+                end
+            end
+
             #
             # Encapsulating 
             #     <parameter field="x" default="y" type="z" match="m" />

data/lib/openwfe/expressions/fe_reserve.rb

@@ -0,0 +1,141 @@
+#
+#--
+# 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 'thread'
+require 'openwfe/expressions/fe_when'
+
+
+module OpenWFE
+
+    #
+    # The 'reserve' expression ensures that its nested child expression
+    # executes while a reserved mutex is set.
+    #
+    # Thus
+    #
+    #     concurrence do
+    #         reserve :mutex => :m0 do
+    #             sequence do
+    #                 participant :alpha
+    #                 participant :bravo
+    #             end
+    #         end
+    #         reserve :mutex => :m0 do
+    #             participant :charly
+    #         end
+    #         participant :delta
+    #     end
+    #
+    # The sequence will not but run while the participant charly is active
+    # and vice versa. The participant delta is not concerned.
+    #
+    # The mutex is a regular variable name, thus a mutex named "//toto" could
+    # be used to prevent segemnts of totally different process instances from
+    # running.
+    #
+    class ReserveExpression < WhenExpression
+
+        #
+        # A mutex for the whole class, it's meant to prevent 'reserve'
+        # from reserving a workflow mutex simultaneaously.
+        #
+        @@mutex = Mutex.new
+
+        names :reserve
+
+        attr_accessor :mutex_name
+
+        def apply (workitem)
+
+            if @children.size < 1
+                reply_to_parent workitem
+                return
+            end
+
+            @mutex_name = lookup_attribute :mutex, workitem
+
+            super
+        end
+
+        def reply (workitem)
+
+            @@mutex.synchronize do
+
+                delete_variable @mutex_name \
+                    if @consequence_triggered
+                        #
+                        # unset mutex
+            end
+
+            super workitem
+        end
+
+        protected
+
+            def evaluate_condition
+
+                mutex = nil
+
+                @@mutex.synchronize do
+
+                    mutex = lookup_variable @mutex_name
+                    
+                    set_variable @mutex_name, fei.to_s \
+                        unless mutex
+                            #
+                            # reserve mutex
+                end
+
+                do_reply (mutex == nil)
+            end
+
+            def apply_consequence (workitem)
+
+                @consequence_triggered = true
+
+                store_itself()
+
+                get_expression_pool.apply(@children[0], workitem)
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_sequence.rb

@@ -40,7 +40,6 @@
 #
 
 require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/fe_utils'
 
 
 #