openwferu 0.9.16 → 0.9.17

data/lib/openwfe/expressions/fe_participant.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -128,12 +128,13 @@ module OpenWFE
 
         def apply (workitem)
 
-            conditional = eval_condition(:if, workitem, :unless)
+            conditional = eval_condition :if, workitem, :unless
 
-            if conditional == false
-                super_reply_to_parent workitem
-                return
-            end
+            return super_reply_to_parent(workitem) \
+                if conditional == false
+                    #
+                    # skip expression 
+                    # <participant ref="x" if="y" /> (where y evals to false)
 
             @participant_name = lookup_ref workitem
 
@@ -210,7 +211,7 @@ module OpenWFE
 
             cancel_participant
 
-            nil
+            @applied_workitem
         end
 
         #

data/lib/openwfe/expressions/fe_reserve.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -38,7 +38,6 @@
 #
 
 require 'thread'
-require 'openwfe/expressions/fe_when'
 
 
 module OpenWFE
@@ -66,73 +65,146 @@ module OpenWFE
     # 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
+    # be used to prevent segments of totally different process instances from
     # running.
     #
-    class ReserveExpression < WhenExpression
+    class ReserveExpression < FlowExpression
 
         #
         # A mutex for the whole class, it's meant to prevent 'reserve'
         # from reserving a workflow mutex simultaneaously.
         #
-        @@mutex = Mutex.new
+        #@@mutex = Mutex.new
 
         names :reserve
 
+        #
+        # The name of the mutex this expressions uses.
+        # It's a variable name, that means it can be prefixed with
+        # {nothing} (local scope), '/' (process scope) and '//' (engine /
+        # global scope).
+        #
         attr_accessor :mutex_name
 
+        #
+        # An instance variable for storing the applied workitem if the 'reserve'
+        # cannot be entered immediately.
+        #
+        attr_accessor :applied_workitem
+
+
         def apply (workitem)
 
-            if @children.size < 1
-                reply_to_parent workitem
-                return
-            end
+            return reply_to_parent(workitem) \
+                if @children.size < 1
 
             @mutex_name = lookup_string_attribute :mutex, workitem
 
-            super
+            FlowMutex.synchronize do
+
+                mutex = 
+                    lookup_variable(@mutex_name) || FlowMutex.new(@mutex_name)
+
+                mutex.register self, workitem
+            end
         end
 
         def reply (workitem)
 
-            @@mutex.synchronize do
+            lookup_variable(@mutex_name).release self
 
-                delete_variable @mutex_name \
-                    if @consequence_triggered
-                        #
-                        # unset mutex
-            end
+            reply_to_parent workitem
+        end
+
+        #
+        # Called by the FlowMutex to enter the 'reserved/critical' section.
+        #
+        def enter (workitem=nil)
+
+            get_expression_pool.apply(
+                @children[0], workitem || @applied_workitem)
+        end
+    end
+
+    #
+    # A FlowMutex is a process variable (thus serializable) that keeps
+    # track of the expressions in a critical section (1!) or waiting for
+    # entering it.
+    #
+    # The current syncrhonization scheme is 1 thread mutex for all the
+    # FlowMutex. Shouldn't be too costly and the operations under sync are
+    # quite tiny.
+    #
+    class FlowMutex
+
+        #
+        # Granularity level ? "big rock". Only one FlowMutex operation
+        # a a time for the whole business process engine...
+        #
+        @@class_mutex = Mutex.new
+
+        attr_accessor :mutex_name
+        attr_accessor :feis
+
+        def initialize (mutex_name)
+
+            @mutex_name = mutex_name
+            @feis = []
+        end
 
-            super workitem
+        def register (fexp, workitem)
+
+            @feis << fexp.fei
+
+            fexp.set_variable @mutex_name, self
+
+            if @feis.size == 1
+                #
+                # immediately let the expression enter the critical section
+                #
+                fexp.store_itself
+                fexp.enter workitem
+            else
+                #
+                # later...
+                #
+                fexp.applied_workitem = workitem
+                fexp.store_itself
+            end
         end
 
-        protected
+        def release (releaser)
+
+            next_fei = nil
 
-            def evaluate_condition
+            @@class_mutex.synchronize do
 
-                mutex = nil
+                current_fei = @feis.delete_at 0
 
-                @@mutex.synchronize do
+                releaser.set_variable @mutex_name, self
 
-                    mutex = lookup_variable @mutex_name
-                    
-                    set_variable @mutex_name, fei.to_s \
-                        unless mutex
-                            #
-                            # reserve mutex
-                end
+                log.warn "release() BAD! c:#{current_fei} r:#{releaser.fei}" \
+                    if releaser.fei != current_fei
 
-                do_reply (mutex == nil)
+                next_fei = @feis.first
             end
 
-            def apply_consequence (workitem)
+            return unless next_fei
 
-                @consequence_triggered = true
+            releaser.get_expression_pool.fetch_expression(next_fei).enter
+        end
 
-                store_itself()
+        #
+        # Used by the ReserveExpression when looking up for a FlowMutex
+        # and registering into it.
+        #
+        def self.synchronize (&block)
 
-                get_expression_pool.apply(@children[0], workitem)
+            @@class_mutex.synchronize do
+
+                block.call
             end
+        end
     end
 
 end

data/lib/openwfe/expressions/fe_save.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -128,25 +128,70 @@ module OpenWFE
     # Beware : you should not restore from a field that is not a hash. The
     # top level attributes (payload) of a workitem should always be a hash.
     #
+    # Since OpenWFEru 0.9.17, the 'set-fields' alias can be used for restore.
+    #
+    #     sequence do
+    #         set_fields :value => { 
+    #             "customer" => { "name" => "Zigue", "age" => 34 },
+    #             "approved" => false }
+    #         _print "${f:customer.name} (${f:customer.age}) ${f:approved}"
+    #     end
+    #
+    # Along with this new alias, the expression now behave much like the 'set'
+    # expression, but still, targets the whole workitem payload.
+    #
+    # Note that "set-fields" can be used outside of the body of a process
+    # definition (along with "set") to separate 'data preparation' from
+    # actual process definition.
+    #
+    #     class Test44b6 < ProcessDefinition
+    #         set_fields :value => { 
+    #             "customer" => { "name" => "Zigue", "age" => 34 },
+    #             "approved" => false }
+    #         sequence do
+    #             _print "${f:customer.name} (${f:customer.age}) ${f:approved}"
+    #         end
+    #     end
+    #
+    # Using set_fields at the beginning of a process can be useful for setting
+    # up forms (keys without values for now).
+    #
+    #     set_fields :value => {
+    #         "name" => "",
+    #         "address" => "",
+    #         "email" => ""
+    #     }
+    #
     class RestoreWorkItemExpression < FlowExpression
         include MergeMixin
+        include ValueMixin
 
-        names :restore
+        names :restore, :set_fields
 
-        def apply (workitem)
+        is_definition
+            # so that in can be placed outside of process definition bodies
+
+
+        def reply (workitem)
 
             from_field = lookup_string_attribute :from_field, workitem
             from_variable = lookup_string_attribute :from_variable, workitem
+
             merge_lead = lookup_sym_attribute :merge_lead, workitem
 
+            merge_lead = nil \
+                unless [ nil, :current, :restored ].include?(merge_lead)
+
+            value = workitem.attributes[FIELD_RESULT]
+
             source = if from_field
 
                 att = workitem.lookup_attribute from_field
 
-                lwarn do 
+                lwarn {
                     "apply() field '#{from_field}' is NOT a hash, " +
                     "restored anyway"
-                end unless att.kind_of?(Hash)
+                } unless att.kind_of?(Hash)
 
                 att
 
@@ -154,12 +199,17 @@ module OpenWFE
 
                 lookup_variable from_variable
 
+            elsif value
+
+                value
+
             else
 
                 nil
             end
 
             if source
+
                 workitem = if merge_lead
                     do_merge merge_lead, workitem, source
                 else

data/lib/openwfe/expressions/{fe_value.rb → fe_set.rb}

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -40,39 +40,11 @@
 require 'openwfe/workitem'
 require 'openwfe/flowexpressionid'
 require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/value'
 
 
 module OpenWFE
 
-    #
-    # A small mixin providing value for looking up the attributes
-    # variable/var/v and field/fld/f.
-    #
-    module ValueMixin
-
-        def lookup_variable_attribute (workitem)
-
-            lookup [ "variable", "var", "v" ], workitem
-        end
-
-        def lookup_field_attribute (workitem)
-
-            lookup [ "field", "fld", "f" ], workitem
-        end
-
-        private
-
-            def lookup (name_array, workitem)
-
-                name_array.each do |n|
-                    v = lookup_string_attribute n, workitem
-                    return v if v
-                end
-
-                nil
-            end
-    end
-
     #
     # The 'set' expression is used to set the value of a (process) variable or
     # a (workitem) field.
@@ -113,33 +85,6 @@ module OpenWFE
         names :set
 
 
-        def apply (workitem)
-
-            escape = lookup_boolean_attribute('escape', workitem, false)
-
-            if @children.length < 1
-
-                workitem.attributes[FIELD_RESULT] = \
-                    lookup_value(workitem, :escape => escape)
-
-                reply workitem
-                return
-            end
-
-            child = @children[0]
-
-            if child.kind_of?(OpenWFE::FlowExpressionId)
-
-                handle_child child, workitem
-                return
-            end
-
-            workitem.attributes[FIELD_RESULT] = \
-                fetch_text_content(workitem, escape)
-
-            reply workitem
-        end
-
         def reply (workitem)
 
             vkey = lookup_variable_attribute(workitem)
@@ -152,35 +97,13 @@ module OpenWFE
             if vkey
                 set_variable vkey, value
             elsif fkey
-                workitem.attributes[fkey] = value
+                workitem.set_attribute fkey, value
             else
                 raise "'variable' or 'field' attribute missing from 'set' expression"
             end
 
             reply_to_parent(workitem)
         end
-
-        protected 
-
-            def handle_child (child, workitem)
-
-                raw_child, _fei = get_expression_pool.fetch(child)
-
-                if raw_child.is_definition?
-
-                    #body_fei = get_expression_pool.evaluate child, workitem
-                    #workitem.attributes[FIELD_RESULT] = body_fei
-
-                    workitem.attributes[FIELD_RESULT] = raw_child
-                        #
-                        # storing the child raw expression
-
-                    reply workitem
-                else
-
-                    get_expression_pool.apply raw_child, workitem
-                end
-            end
     end
 
     #
@@ -194,6 +117,7 @@ module OpenWFE
 
         names :unset
 
+
         def apply (workitem)
 
             vkey = lookup_variable_attribute(workitem)
@@ -202,12 +126,12 @@ module OpenWFE
             if vkey
                 delete_variable(vkey)
             elsif fkey
-                workitem.attributes.delete(fkey)
+                workitem.unset_attribute fkey
             else
                 raise "attribute 'variable' or 'field' is missing for 'unset' expression"
             end
 
-            reply_to_parent(workitem)
+            reply_to_parent workitem
         end
     end