openwferu 0.9.2 → 0.9.3

data/lib/openwfe/expressions/fe_raw.rb

@@ -68,17 +68,21 @@ module OpenWFE
             new_environment() if not @environment_id
         end
 
-        def instantiate_real_expression (workitem)
+        def instantiate_real_expression \
+            (workitem, exp_class=nil, attributes=nil)
 
-            attributes = extract_attributes()
+            exp_class = expression_class() unless exp_class
 
-            eclass = expression_class()
+            raise "unknown expression '#{expression_name}'" \
+                unless exp_class
 
-            raise "unknown expression '#{expression_name}'" if not eclass
+            #ldebug do 
+            #    "instantiate_real_expression() exp_class is #{exp_class}"
+            #end
 
-            ldebug { "instantiate_real_expression() eclass is #{eclass}" }
+            attributes = extract_attributes() unless attributes
 
-            expression = eclass.new(
+            expression = exp_class.new(
                 @fei, 
                 @parent_id, 
                 @environment_id, 
@@ -94,14 +98,41 @@ module OpenWFE
 
         def apply (workitem)
 
-            template = lookup_variable(expression_name())
+            exp_name = expression_name()
+
+            exp_class = nil
+            attributes = nil
+
+            template = lookup_variable(exp_name)
+                #
+                # is it a subprocess ?
+
+            template = get_participant_map.lookup_participant(exp_name) \
+                unless template
+                    #
+                    # is it a directly a participant ?
+
+            if template 
 
-            if template and template.kind_of? OpenWFE::FlowExpressionId
-                launch_template(template, workitem)
-            else
-                expression = instantiate_real_expression(workitem)
-                expression.apply(workitem)
+                if template.kind_of? OpenWFE::FlowExpressionId
+                    launch_template(template, workitem)
+                    return
+                end
+
+                if template.kind_of? OpenWFE::Participant
+                    exp_class = OpenWFE::ParticipantExpression
+                    attributes = extract_attributes()
+                    attributes["ref"] = exp_name
+                end
             end
+
+            #
+            # the classical case...
+
+            expression = instantiate_real_expression(
+                workitem, exp_class, attributes)
+
+            expression.apply(workitem)
         end
 
         #def reply (workitem)

data/lib/openwfe/expressions/fe_subprocess.rb

@@ -78,6 +78,8 @@ module OpenWFE
 
             template_fei = lookup_variable(ref)
 
+            #template_fei = lookup_participant(ref) if not template_fei
+
             raise "did not find any subprocess named '#{ref}'" \
                 if not template_fei
 
@@ -96,6 +98,14 @@ module OpenWFE
 
         #def reply (workitem)
         #end
+
+        #protected
+        #    def lookup_participant (ref)
+        #        participant = get_participant_map.lookup_participant(ref)
+        #        return nil unless participant
+        #        #
+        #        # builds a participant expression on the fly
+        #    end
     end
 
 end

data/lib/openwfe/expressions/fe_time.rb

@@ -39,8 +39,9 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/otime'
 require 'openwfe/rudefinitions'
+require 'openwfe/utils'
+require 'openwfe/util/otime'
 require 'openwfe/util/scheduler'
 
 
@@ -57,14 +58,12 @@ module OpenWFE
     # localization for <sleep/> and <cron/>.
     #
     class TimeExpression < FlowExpression
+        include Schedulable
 
         attr_accessor \
+            :applied_workitem,
             :scheduler_job_id
 
-        def get_scheduler
-            return @application_context[S_SCHEDULER]
-        end
-
         #
         # Makes sure to cancel any scheduler job associated with this
         # expression
@@ -95,10 +94,8 @@ module OpenWFE
     # to participant 'alpha'.
     #
     class SleepExpression < TimeExpression
-        include Schedulable
 
         attr_accessor \
-            :sleeping_workitem,
             :awakening_time
 
         def apply (workitem)
@@ -123,19 +120,9 @@ module OpenWFE
                 end
 
                 @awakening_time = tuntil
-                @sleeping_workitem = workitem.dup
-
-                ldebug do 
-                    "apply() " + 
-                    "will sleep until '#{tuntil}' " +
-                    "(#{OpenWFE::to_iso8601_date(tuntil)})"
-                end
-
-                @scheduler_job_id = get_scheduler.schedule_at(tuntil, self, nil)
+                @applied_workitem = workitem.dup
 
-                ldebug { "apply() @scheduler_job_id is #{@scheduler_job_id}" }
-
-                store_itself()
+                reschedule(get_scheduler)
             end
         end
 
@@ -149,16 +136,124 @@ module OpenWFE
         #
         def trigger (params)
             ldebug do 
-                "trigger() #{@fei.to_debug_s} waking up (#{Time.new.to_f})"
+                "trigger() #{@fei.to_debug_s} waking up (#{Time.new.to_f}) "+
+                "(scheduler #{get_scheduler.object_id})"
             end
-            reply_to_parent(@sleeping_workitem)
+            reply_to_parent(@applied_workitem)
+        end
+
+        #
+        # [Re]schedules this expression, effectively registering it within
+        # the scheduler.
+        # This method is called when the expression is applied and each
+        # time the owning engine restarts.
+        #
+        def reschedule (scheduler)
+
+            ldebug do 
+                "[re]schedule() " + 
+                "will sleep until '#{@awakening_time}' " +
+                "(#{OpenWFE::to_iso8601_date(@awakening_time)})"
+            end
+
+            @scheduler_job_id = 
+                scheduler.schedule_at(@awakening_time, self, nil)
+
+            ldebug do 
+                "[re]schedule() @scheduler_job_id is #{@scheduler_job_id} "+
+                " (scheduler #{scheduler.object_id})"
+            end
+
+            store_itself()
         end
     end
 
     #
-    # TODO #6929 : implement me
+    #     <cron tab="0 9-17 * * mon-fri" name="//reminder">
+    #         <send-reminder/>
+    #     </cron>
     #
     class CronExpression < TimeExpression
+
+        attr_accessor \
+            :raw_child, :tab, :name
+
+        def apply (workitem)
+
+            if @children.size < 1
+                reply_to_parent(workitem)
+                return
+            end
+
+            @applied_workitem = workitem.dup
+            @applied_workitem.flow_expression_id = nil
+
+            @tab = lookup_attribute(:tab, workitem)
+            @name = lookup_attribute(:name, workitem)
+
+            @raw_child, _fei = get_expression_pool.fetch(@children[0])
+            @raw_child.parent_id = nil
+
+            clean_children()
+
+            @children = nil
+
+            #
+            # schedule self
+            
+            reschedule(get_scheduler)
+
+            #
+            # store self as a variable
+            # (have to do it after the reschedule, so that the schedule
+            # info is stored within the variable)
+
+            set_variable(@name, self)
+
+            #
+            # resume flow
+            
+            reply_to_parent(workitem)
+        end
+
+        def reply (workitem)
+            # discard silently... should never get called though
+        end
+
+        #def cancel ()
+        #end
+            #
+            # implemented in parent TimeExpression class
+
+        def trigger (params)
+            #
+            # launch raw child
+
+            ldebug { "trigger() cron : #{@fei.to_debug_s}" }
+
+            @raw_child.application_context = @application_context
+
+            begin
+                get_expression_pool.launch_template(
+                    @fei.wfid, @raw_child, @applied_workitem.dup)
+            rescue
+                lerror do 
+                    "trigger() cron caught exception\n"+
+                    OpenWFE::exception_to_s($!)
+                end
+            end
+        end
+
+        def reschedule (scheduler)
+
+            @scheduler_id = get_scheduler.schedule(@tab, @name, self, nil)
+
+            ldebug { "reschedule() job id is #{@scheduler_id}" }
+
+            #store_itself()
+                #
+                # done by the containing environment itself
+        end
     end
 
 end

data/lib/openwfe/expressions/fe_value.rb

@@ -43,6 +43,7 @@ require 'openwfe/workitem'
 require 'openwfe/flowexpressionid'
 require 'openwfe/expressions/flowexpression'
 require 'openwfe/expressions/fe_utils'
+require 'openwfe/expressions/fe_condition'
 
 
 #
@@ -187,6 +188,7 @@ module OpenWFE
     #     <if/>
     #
     class IfExpression < FlowExpression
+        include ConditionMixin
 
         attr_accessor \
             :condition_replied
@@ -195,11 +197,19 @@ module OpenWFE
 
             reply_to_parent(workitem) if @children.length < 1
 
-            @condition_replied = false
+            test = eval_condition(:test, workitem)
+
+            @condition_replied = (test != nil)
+                #
+                # if the "test" attribute is not used, test will be null
 
             store_itself()
 
-            get_expression_pool.apply(@children[0], workitem)
+            if test != nil
+                apply_consequence(test, workitem, 0)
+            else
+                get_expression_pool.apply(@children[0], workitem)
+            end
         end
 
         def reply (workitem)
@@ -215,11 +225,7 @@ module OpenWFE
 
             store_itself()
 
-            if result
-                apply_consequence(1, workitem)
-            else
-                apply_consequence(2, workitem)
-            end
+            apply_consequence(result, workitem)
         end
 
         def reply_to_parent(workitem)
@@ -229,7 +235,20 @@ module OpenWFE
 
         protected
 
-            def apply_consequence (index, workitem)
+            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

data/lib/openwfe/expressions/flowexpression.rb

@@ -346,19 +346,24 @@ module OpenWFE
         end
 
         #
-        # takes care of removing all the children
+        # Takes care of removing all the children of this expression, if any.
         #
         def clean_children
-            @children.each do |children_fei|
-                get_expression_pool.remove(children_fei)
+
+            return unless @children
+
+            @children.each do |child_fei|
+                get_expression_pool.remove(child_fei) \
+                    if child_fei.kind_of? FlowExpressionId
             end
         end
 
         #
-        # currently only used by dollar.rb and its ${r:some_ruby_code},
-        # returns the binding in this flow expression
+        # Currently only used by dollar.rb and its ${r:some_ruby_code},
+        # returns the binding in this flow expression.
         #
         def get_binding
+
             return binding()
         end
 
@@ -369,15 +374,17 @@ module OpenWFE
         # just included the MonitorMixin. No hassle.
         #
         def synchronize
+
             get_expression_pool.get_monitor(@fei).synchronize do
                 yield
             end
         end
 
         #
-        # some eye candy
+        # Some eye candy
         #
         def to_s
+
             s = "* #{@fei.to_debug_s}"
 
             if @parent_id

data/lib/openwfe/expressions/raw_prog.rb

@@ -125,11 +125,11 @@ module OpenWFE
             ind = tab * indentation
 
             s << ind
-            s << OpenWFE.make_safe(@name)
+            s << OpenWFE::make_safe(@name)
 
             sa = ""
             @attributes.each do |k, v|
-                sa << ", :#{k} => '#{v}'"
+                sa << ", :#{OpenWFE::to_underscore(k)} => '#{v}'"
             end
             s << sa[1..-1] if sa.length > 0
 
@@ -225,14 +225,16 @@ module OpenWFE
             methodname = m.to_s
 
             expname = OpenWFE.to_expression_name(methodname)
-            if not @exp_names.include? expname
-                #raise "No expression named '#{methodname}' (#{expname}) found"
-                #raise "No expression named '#{expname}' found"
-                params = args[0]
-                params = {} if not params
-                params["ref"] = methodname
-                return make_expression("subprocess", params, &block)
-            end
+
+            #if not @exp_names.include? expname
+            #    #raise "No expression named '#{methodname}' (#{expname}) found"
+            #    #raise "No expression named '#{expname}' found"
+            #    params = args[0]
+            #    params = {} if not params
+            #    params["ref"] = methodname
+            #    return make_expression("subprocess", params, &block)
+            #end
+
             make_expression(expname, args[0], &block)
         end
 
@@ -367,7 +369,7 @@ module OpenWFE
         # with 'do' and 'redo' that are.
         #
         KEYWORDS = [
-            :if, :do, :redo, :undo, :print
+            :if, :do, :redo, :undo, :print, :sleep, :loop, :break
         ]
 
         #