openwferu 0.9.2 → 0.9.3

data/lib/openwfe/expool/expstorage.rb

@@ -71,6 +71,7 @@ module OpenWFE
         
         #
         # call the add method for each registered storage
+        #
         def []= (fei, flowExpression)
             @journal[fei] = flowExpression if @journal
             @cache[fei] = flowExpression if @cache
@@ -79,10 +80,11 @@ module OpenWFE
         
         #
         # remove the expressionid from each registered storage
-        def remove (fei, workitem)
-            @journal.remove(fei, workitem) if @journal
-            @cache.remove(fei, workitem) if @cache
-            @persistence.remove(fei,workitem)
+        #
+        def delete (fei)
+            @journal.delete(fei) if @journal
+            @cache.delete(fei) if @cache
+            @persistence.delete(fei)
         end
         
         #
@@ -119,7 +121,8 @@ module OpenWFE
         
         #
         # interface method to remove an entry for the given expression_id
-        def remove (fei, workitem)
+        #
+        def delete (fei)
             @cache.delete(fei)
         end
         
@@ -151,16 +154,13 @@ module OpenWFE
         include ServiceMixin
         
         def initialize (service_name, application_context)
-            @service_name = service_name
-            @application_context = application_context
+            service_init(service_name, application_context)
         end
 
-        def remove (fei, workitem)
-            delete(fei)
-        end
+        alias :purge :clear
 
-        def purge
-            self.clear
+        def each_of_kind (kind)
+            # TODO : implement with a filter
         end
         
         def to_s

data/lib/openwfe/expool/journalexpstorage.rb

@@ -258,7 +258,7 @@ module OpenWFE
         
         #
         # interface method: remove the expressionid and persist the related workitem
-        def remove (fei, workitem=nil)
+        def remove (fei)
             write_to_journal(JournalEntry.new(:del, fei, nil))
         end
         

data/lib/openwfe/expool/yamlexpstorage.rb

@@ -40,8 +40,10 @@
 # John Mettraux at openwfe.org
 #
 
-require 'find'
+#require 'find'
 
+require 'openwfe/utils'
+require 'openwfe/rudefinitions'
 require 'openwfe/storage/yamlfilestorage'
 
 require 'openwfe/expressions/flowexpression'
@@ -84,6 +86,7 @@ module OpenWFE
     # yaml expression storage
     #
     class YamlFileExpressionStorage  < YamlFileStorage
+        include OwfeServiceLocator
         
         def initialize (service_name, application_context)
             path = if (@application_context) 
@@ -93,35 +96,68 @@ module OpenWFE
             end
             super(service_name, application_context, path + "/expool")
         end
-        
-        def compute_file_path (fei)
-            
-            return @basepath + "/engine_env.yaml" \
-                if fei.workflow_instance_id == "0"
-                
-            wfid = fei.parent_workflow_instance_id
-            
-            @basepath + "/" +
-            wfid[-1, 1] + "/" +
-            wfid[-2, 1] + "/" +
-            wfid + "/" +
-            fei.workflow_instance_id + "__" +
-            fei.expression_id + "_" + 
-            fei.expression_name + ".yaml"
-        end        
+
+        #
+        # Iterates on each expression that is of the given kind.
+        # Used for example by the expression pool when rescheduling.
+        #
+        def each_of_kind (kind, &block)
+
+            return unless block
+
+            exp_names = get_expression_map.get_expression_names(kind)
+            #require 'pp'
+            #pp exp_names
+
+            each_object_path do |path|
+
+                #ldebug { "each_of_kind() path is #{path}" }
+
+                next unless matches(path, exp_names)
+
+                expression = load_object(path)
+                expression.application_context = @application_context
+
+                block.call expression
+            end
+        end
 
         def to_s
             s = "\n\n==== #{self.class} ===="
             s << "\n"
-            Find.find(@basepath) do |path|
-                if not File.stat(path).directory?
-                    s << path
-                    s << "\n"
-                end
+            each_expression_path do |path|
+                s << path
+                s << "\n"
             end
             s << "==== . ====\n"
             return s
         end
+
+        protected
+            
+            def compute_file_path (fei)
+                
+                return @basepath + "/engine_environment.yaml" \
+                    if fei.workflow_instance_id == "0"
+                    
+                wfid = fei.parent_workflow_instance_id
+                
+                @basepath + "/" +
+                wfid[-1, 1] + "/" +
+                wfid[-2, 1] + "/" +
+                wfid + "/" +
+                fei.workflow_instance_id + "__" +
+                fei.expression_id + "_" + 
+                fei.expression_name + ".yaml"
+            end        
+
+            def matches (path, exp_names)
+                exp_names.each do |exp_name|
+                    return true \
+                        if OpenWFE::ends_with(path, "_#{exp_name}.yaml")
+                end
+                return false
+            end
         
     end
 end

data/lib/openwfe/expressions/environment.rb

@@ -40,6 +40,7 @@
 #
 
 require 'openwfe/utils'
+require 'openwfe/util/scheduler'
 require 'openwfe/expressions/flowexpression'
 
 
@@ -50,6 +51,7 @@ module OpenWFE
     # It's an expression as it's storable in the expression pool.
     #
     class Environment < FlowExpression
+        include Schedulable
 
         attr_accessor \
             :variables
@@ -122,8 +124,11 @@ module OpenWFE
         def unbind ()
 
             @variables.each do |key, value|
-                get_expression_pool().remove(value) \
-                    if value.kind_of? OpenWFE::FlowExpressionId
+                if value.kind_of? FlowExpressionId
+                    get_expression_pool().remove(value)
+                elsif value.kind_of? FlowExpression
+                    value.cancel
+                end
             end
         end
 
@@ -134,6 +139,31 @@ module OpenWFE
             return @fei == get_expression_pool().engine_environment_id
         end
 
+        #
+        # Should never get used, only the reschedule() method is relevant
+        # for the Schedulable aspect of an environment expression.
+        #
+        def trigger (params)
+            raise "an environment should never get directly triggered"
+        end
+
+        #
+        # Will reschedule any 'Schedulable' variable found in this environment
+        # this method especially targets cron expressions that are stored
+        # as variables and need to be rescheduled upon engine restart.
+        #
+        def reschedule (scheduler)
+
+            @variables.each do |key, value|
+                ldebug { "reschedule()  - item of class #{value.class}" }
+                next unless value.kind_of? Schedulable
+                value.application_context = @application_context
+                value.reschedule(scheduler)
+            end
+
+            store_itself()
+        end
+
         protected
 
             def get_root_environment ()

data/lib/openwfe/expressions/expressionmap.rb

@@ -40,6 +40,7 @@
 #
 
 require 'openwfe/service'
+require 'openwfe/expressions/environment'
 require 'openwfe/expressions/fe_define'
 require 'openwfe/expressions/fe_misc'
 require 'openwfe/expressions/fe_value'
@@ -113,6 +114,10 @@ module OpenWFE
             @map["f"] = FqvExpression
             @map["q"] = FqvExpression
             @map["v"] = FqvExpression
+
+            @map["environment"] = Environment
+                #
+                # only used by get_expression_names()
         end
 
         #
@@ -146,6 +151,18 @@ module OpenWFE
             return @map.keys
         end
 
+        #
+        # Returns an array of expression names whose class are assignable
+        # from the given expression_class.
+        #
+        def get_expression_names (expression_class)
+            names = []
+            @map.each do |name, exp_class|
+                names << name \
+                    if exp_class.ancestors.include? expression_class
+            end
+            return names
+        end
     end
 
 end

data/lib/openwfe/expressions/fe_condition.rb

@@ -0,0 +1,122 @@
+#
+#--
+# 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/workitem'
+#require 'openwfe/flowexpressionid'
+
+
+module OpenWFE
+
+    #
+    # A ConditionMixin is a mixin for flow expressions like 'if' and 'break' for
+    # example.
+    # It allows for shorter notations like
+    #
+    #     <if test="${f:approved} == true"/>
+    #
+    # or
+    #
+    #     _loop do
+    #         participant :graphical_designer
+    #         participant :business_analyst
+    #         _break :if => "${f:approved}"
+    #     end
+    #
+    module ConditionMixin
+
+        def eval_condition (attname, workitem)
+
+            conditional = lookup_attribute(attname, workitem)
+            rconditional = lookup_attribute("r"+attname.to_s, workitem)
+
+            if rconditional and not conditional
+                return instance_eval(rconditional)
+            end
+
+            return nil unless conditional
+
+            #ldebug { "eval_condition() 0 for  '#{conditional}'" }
+
+            conditional = from_xml(conditional)
+
+            #ldebug { "eval_condition() 1 for  '#{conditional}'" }
+
+            conditional = do_quote(conditional)
+
+            ldebug { "eval_condition() 2 for  '#{conditional}'" }
+
+            return true if conditional == '"true"'
+            return false if conditional == '"false"'
+
+            return instance_eval(conditional)
+        end
+
+        private
+
+            def from_xml (string)
+
+                s = string
+                s.gsub!("&gt;", ">")
+                s.gsub!("&lt;", "<")
+                s
+            end
+
+            def do_quote (string)
+
+                i = string.index("==")
+                i = string.index("!=") unless i
+                i = string.index("<") unless i
+                i = string.index(">") unless i
+
+                return '"' + string + '"' unless i
+
+                '"' +
+                string[0..i-1].strip +
+                '" ' +
+                string[i..i+2] +
+                ' "' +
+                string[i+2..-1].strip +
+                '"'
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_cursor.rb

@@ -40,6 +40,7 @@
 #
 
 require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/fe_condition'
 
 
 #
@@ -216,17 +217,25 @@ module OpenWFE
     # 'skip', 'continue', and the like
     #
     class CursorCommandExpression < FlowExpression
+        include ConditionMixin
 
         def apply (workitem)
 
-            command = @fei.expression_name
+            conditional = eval_condition(:if, workitem)
+                #
+                # for example : <break if="${approved} == true"/>
+
+            if conditional == nil or conditional
 
-            step = lookup_attribute(A_STEP, workitem, "1")
-            step = Integer(step)
+                command = @fei.expression_name
 
-            command = "#{command} #{step}" if step != 1
+                step = lookup_attribute(A_STEP, workitem, "1")
+                step = Integer(step)
 
-            workitem.attributes[F_COMMAND] = command
+                command = "#{command} #{step}" if step != 1
+
+                workitem.attributes[F_COMMAND] = command
+            end
 
             reply_to_parent(workitem)
         end

data/lib/openwfe/expressions/fe_participant.rb

@@ -39,7 +39,9 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/utils'
 require 'openwfe/rudefinitions'
+require 'openwfe/expressions/timeout'
 require 'openwfe/expressions/fe_utils'
 
 
@@ -56,6 +58,7 @@ module OpenWFE
     # tied to the engine.
     #
     class ParticipantExpression < FlowExpression
+        include TimeoutMixin
 
         attr_accessor \
             :participant_name,
@@ -66,22 +69,70 @@ module OpenWFE
 
         def apply (workitem)
 
-            @applied_workitem = workitem
-            #puts  "apply() \n#{@applied_workitem}"
-            #ldebug { "apply() \n#{@applied_workitem}" }
+            @applied_workitem = workitem.dup
 
             @participant_name = OpenWFE::lookup_ref(self, workitem)
 
             @participant_name = OpenWFE::fetch_text_content(self, workitem) \
                 unless @participant_name
 
+            determine_timeout()
+
             store_itself()
 
-            get_participant_map.dispatch(participant_name, workitem)
+            get_participant_map.dispatch(@participant_name, workitem)
         end
 
         #def reply (workitem)
         #end
+
+        #
+        # The cancel() method of a ParticipantExpression is particular : it
+        # will emit a CancelItem instance towards the participant itself
+        # to notify it of the cancellation.
+        #
+        def cancel
+
+            wi = super()
+
+            if @scheduler_job_id
+                get_scheduler.unschedule(@scheduler_job_id)
+            end
+
+            return wi unless @applied_workitem
+
+            #
+            # have to cancel the workitem on the participant side
+
+            cancelitem = OpenWFE::CancelItem.new(@applied_workitem)
+            get_participant_map.dispatch(@participant_name, cancelitem)
+
+            return nil
+        end
+
+        #
+        # Upon timeout, the ParticipantExpression will cancel itself and
+        # the flow will resume.
+        #
+        def trigger (scheduler)
+
+            ldebug { "trigger() timeout requested for #{@fei.to_debug_s}" }
+
+            begin
+
+                @scheduler_job_id = nil
+                    #
+                    # so that cancel won't unschedule without need 
+
+                cancel()
+                reply_to_parent(@applied_workitem)
+            rescue
+                lerror do
+                    "trigger() problem while timing out\n"+
+                    OpenWFE::exception_to_s($!)
+                end
+            end
+        end
     end
 
 end