openwferu 0.9.15 → 0.9.16

data/lib/openwfe/expool/yamlexpstorage.rb

@@ -41,6 +41,7 @@
 require 'openwfe/utils'
 require 'openwfe/storage/yamlcustom'
 require 'openwfe/storage/yamlfilestorage'
+require 'openwfe/expool/threadedexpstorage'
 
 require 'openwfe/expressions/flowexpression'
 require 'openwfe/expressions/raw_xml'
@@ -74,8 +75,6 @@ module OpenWFE
         #
         def each_of_kind (kind, &block)
 
-            return unless block
-
             each_object_path do |path|
 
                 #ldebug { "each_of_kind() path is #{path}" }
@@ -83,13 +82,13 @@ module OpenWFE
                 #next unless matches(path, kind)
                     # was not OK in case of <bob activity="clean office" />
 
-                expression = load_object(path)
+                expression = load_object path
 
                 next unless expression.is_a?(kind)
 
                 expression.application_context = @application_context
 
-                block.call expression
+                block.call expression.fei, expression
             end
         end
 
@@ -106,8 +105,10 @@ module OpenWFE
 
                 a = self.class.split_file_path path
                 next unless a
+
                 wfid = a[0]
                 next if wfid_prefix and ( ! wfid.match "^#{wfid_prefix}")
+
                 flow_expression = load_object path
 
                 block.call flow_expression.fei, flow_expression
@@ -180,152 +181,6 @@ module OpenWFE
             #++
     end
 
-    #
-    # This mixin gathers all the logic for a threaded expression storage,
-    # one that doesn't immediately stores workitems (removes overriding
-    # operations).
-    # Using this threaded storage brings a very important perf benefit.
-    #
-    module ThreadedStorageMixin
-
-        THREADED_FREQ = "427" # milliseconds
-            #
-            # the frequency at which the event queue should be processed
-
-        #
-        # Will take care of stopping the 'queue processing' thread.
-        #
-        def stop
-
-            get_scheduler.unschedule(@thread_id) if @thread_id
-
-            process_queue()
-                #
-                # flush every remaining events (especially the :delete ones)
-        end
-
-        #
-        # calls process_queue() before the call the super class each_of_kind()
-        # method
-        #
-        def each_of_kind (kind, &block)
-
-            #ldebug { "each_of_kind()" }
-
-            process_queue()
-            super
-        end
-
-        #
-        # calls process_queue() before the call the super class each()
-        # method
-        #
-        def each (wfid_prefix=nil, &block)
-
-            process_queue()
-            super
-        end
-
-        protected
-
-            #
-            # starts the thread that does the actual persistence.
-            #
-            def start_processing_thread
-
-                @events = {}
-                @op_count = 0
-
-                @thread_id = get_scheduler.schedule_every THREADED_FREQ do
-                    process_queue
-                end
-            end
-
-            #
-            # queues an event for later (well within a second) persistence
-            #
-            def queue (event, fei, fe=nil)
-                synchronize do
-
-                    old_size = @events.size
-                    @op_count += 1
-
-                    @events[fei] = [ event, fei, fe ]
-
-                    ldebug do 
-                        "queue() ops #{@op_count} "+
-                        "size #{old_size} -> #{@events.size}"
-                    end
-                end
-            end
-
-            #
-            # the actual "do persist" order
-            #
-            def process_queue
-
-                return unless @events.size > 0
-                    #
-                    # trying to exit as quickly as possible
-
-                ldebug do 
-                    "process_queue() #{@events.size} events #{@op_count} ops"
-                end
-
-                synchronize do
-                    @events.each_value do |v|
-                        event = v[0]
-                        begin
-                            if event == :update
-                                self[v[1]] = v[2]
-                            else
-                                safe_delete(v[1])
-                            end
-                        rescue Exception => e
-                            lwarn do
-                                "process_queue() ':#{event}' exception\n" + 
-                                OpenWFE::exception_to_s(e)
-                            end
-                        end
-                    end
-                    @op_count = 0
-                    @events.clear
-                end
-            end
-
-            #
-            # a call to delete that tolerates missing .yaml files
-            #
-            def safe_delete (fei)
-                begin
-                    self.delete(fei)
-                rescue Exception => e
-                #    lwarn do
-                #        "safe_delete() exception\n" + 
-                #        OpenWFE::exception_to_s(e)
-                #    end
-                end
-            end
-
-            #
-            # Adds the queue() method as an observer to the update and remove
-            # events of the expression pool.
-            # :update and :remove mean changes to expressions in the persistence
-            # that's why they are observed.
-            #
-            def observe_expool
-
-                get_expression_pool.add_observer(:update) do |event, fei, fe|
-                    ldebug { ":update  for #{fei.to_debug_s}" }
-                    queue(event, fei, fe)
-                end
-                get_expression_pool.add_observer(:remove) do |event, fei|
-                    ldebug { ":remove  for #{fei.to_debug_s}" }
-                    queue(event, fei)
-                end
-            end
-    end
-
     #
     # With this extension of YmalFileExpressionStorage, persistence occurs
     # in a separate thread, for a snappier response.

data/lib/openwfe/expressions/condition.rb

@@ -118,7 +118,7 @@ module OpenWFE
 
                 ldebug { "do_eval_condition() 0 for  '#{conditional}'" }
 
-                conditional = from_xml conditional
+                conditional = unescape conditional
 
                 ldebug { "do_eval_condition() 1 for  '#{conditional}'" }
 
@@ -146,12 +146,12 @@ module OpenWFE
                 (result == "true" or result == true)
             end
 
-            def from_xml (string)
+            #
+            # unescapes '>' and '<'
+            #
+            def unescape (s)
 
-                s = string
-                s.gsub!("&gt;", ">")
-                s.gsub!("&lt;", "<")
-                s
+                s.gsub("&amp;", "&").gsub("&gt;", ">").gsub("&lt;", "<")
             end
 
             #

data/lib/openwfe/expressions/environment.rb

@@ -158,7 +158,9 @@ module OpenWFE
         def reschedule (scheduler)
 
             @variables.each do |key, value|
-                ldebug { "reschedule()  - item of class #{value.class}" }
+
+                #ldebug { "reschedule()  - item of class #{value.class}" }
+
                 next unless value.kind_of? Schedulable
                 value.application_context = @application_context
                 value.reschedule(scheduler)
@@ -172,8 +174,11 @@ module OpenWFE
         # environment just before the engine environment).
         #
         def get_root_environment
+
             #ldebug { "get_root_environment\n#{self}" }
-            return self if not @parent_id
+
+            return self unless @parent_id
+
             get_parent.get_root_environment
         end
 

data/lib/openwfe/expressions/expressionmap.rb

@@ -79,6 +79,7 @@ module OpenWFE
             super
 
             @expressions = {}
+            @ancestors = {}
 
             register DefineExpression
 
@@ -111,6 +112,7 @@ module OpenWFE
 
             register RevalExpression
             register PrintExpression
+            register LogExpression
 
             register LoseExpression
             register ForgetExpression
@@ -204,6 +206,18 @@ module OpenWFE
                 name = OpenWFE::to_dash(name)
                 @expressions[name] = expression_class
             end
+            expression_class.ancestors.each do |ancestor|
+                (@ancestors[ancestor] ||= []) << expression_class
+            end
+        end
+
+        #
+        # Returns an array of expression classes that have the given 
+        # class/module among their ancestors.
+        #
+        def get_expression_classes (ancestor)
+
+            @ancestors[ancestor]
         end
 
         def to_s

data/lib/openwfe/expressions/fe_command.rb

@@ -98,7 +98,8 @@ module OpenWFE
             #
             def lookup_command_field (workitem)
 
-                lookup_attribute(A_COMMAND_FIELD, workitem, F_COMMAND)
+                lookup_attribute(
+                    A_COMMAND_FIELD, workitem, :default => F_COMMAND)
             end
 
             #

data/lib/openwfe/expressions/fe_concurrence.rb

@@ -139,15 +139,17 @@ module OpenWFE
         attr_accessor \
             :sync_expression
 
+
         def apply (workitem)
 
-            sync = lookup_attribute(:sync, workitem, :generic)
+            sync = lookup_sym_attribute(
+                :sync, workitem, :default => :generic)
 
             @sync_expression = 
                 get_expression_map.get_sync_class(sync).new(self, workitem)
 
             @children.each do |child|
-                @sync_expression.add_child(child)
+                @sync_expression.add_child child 
             end
 
             store_itself()
@@ -272,7 +274,7 @@ module OpenWFE
     #
     class SyncExpression < ObjectWithMeta
 
-        def initialize()
+        def initialize
 
             super
         end
@@ -313,12 +315,15 @@ module OpenWFE
             @count = determine_count(synchable, workitem)
             @cancel_remaining = cancel_remaining?(synchable, workitem)
 
-            merge = synchable.lookup_attribute(:merge, workitem, :first)
-            merge_type = synchable.lookup_attribute(:merge_type, workitem, :mix)
+            merge = synchable.lookup_sym_attribute(
+                :merge, workitem, :default => :first)
+
+            merge_type = synchable.lookup_sym_attribute(
+                :merge_type, workitem, :default => :mix)
 
             #synchable.ldebug { "new() merge_type is '#{merge_type}'" }
 
-            @merge_array = MergeArray.new(merge, merge_type)
+            @merge_array = MergeArray.new synchable.fei, merge, merge_type
 
             @unready_queue = []
         end
@@ -459,17 +464,17 @@ module OpenWFE
 
             def cancel_remaining? (synchable_expression, workitem)
 
-                s = synchable_expression.lookup_attribute(
-                    :remaining, workitem, :cancel)
+                s = synchable_expression.lookup_sym_attribute(
+                    :remaining, workitem, :default => :cancel)
 
-                return s == :cancel.to_s
+                (s == :cancel)
             end
 
             def determine_count (synchable_expression, workitem)
 
-                s = synchable_expression.lookup_attribute(:count, workitem)
-                return -1 if not s
-                i = s.to_i
+                c = synchable_expression.lookup_attribute :count, workitem
+                return -1 if not c
+                i = c.to_i
                 return -1 if i < 1
                 i
             end
@@ -484,18 +489,21 @@ module OpenWFE
                 include MergeMixin
 
                 attr_accessor \
+                    :synchable_fei,
                     :workitem,
                     :workitems_by_arrival,
                     :workitems_by_altitude,
                     :merge,
                     :merge_type
 
-                def initialize (merge, merge_type)
+                def initialize (synchable_fei, merge, merge_type)
+
+                    @synchable_fei = synchable_fei
 
-                    @merge = merge.strip.downcase.intern
-                    @merge_type = merge_type.strip.downcase.intern
+                    @merge = merge
+                    @merge_type = merge_type
 
-                    ensure_merge_settings()
+                    ensure_merge_settings
 
                     @workitem = nil
 
@@ -539,7 +547,8 @@ module OpenWFE
                     end
 
                     #key = synchable.children.index wi.last_expression_id
-                    key = wi.last_expression_id.child_id
+                    #key = wi.last_expression_id.child_id
+                    key = get_child_id wi
 
                     @workitem.attributes[key.to_s] = 
                         OpenWFE::fulldup(wi.attributes)
@@ -548,7 +557,8 @@ module OpenWFE
                 def push_by_arrival (wi)
 
                     #index = synchable.children.index wi.last_expression_id
-                    index = Integer(wi.last_expression_id.child_id)
+                    #index = Integer(wi.last_expression_id.child_id)
+                    index = Integer(get_child_id(wi))
 
                     @workitems_by_arrival << wi
                     @workitems_by_altitude[index] = wi
@@ -610,6 +620,18 @@ module OpenWFE
                         @merge_type == :isolate
                     end
 
+                    #
+                    # Returns the child id of the expression that just
+                    # replied with the given workitem.
+                    #
+                    def get_child_id (workitem)
+
+                        return workitem.fei.child_id \
+                            if workitem.fei.wfid == @synchable_fei.wfid
+
+                        workitem.fei.last_sub_instance_id
+                    end
+
                     #
                     # Making sure @merge and @merge_type are set to
                     # appropriate values.

data/lib/openwfe/expressions/fe_cron.rb

@@ -84,7 +84,7 @@ module OpenWFE
             @counter = 0
 
             if @children.size < 1
-                reply_to_parent(workitem)
+                reply_to_parent workitem
                 return
             end
 
@@ -104,6 +104,8 @@ module OpenWFE
 
             @children = nil
 
+            determine_scheduler_tags
+
             #
             # schedule self
             
@@ -114,23 +116,18 @@ module OpenWFE
             # (have to do it after the reschedule, so that the schedule
             # info is stored within the variable)
 
-            set_variable(@name, self)
+            set_variable @name, self
 
             #
             # resume flow
             
-            reply_to_parent(workitem)
+            reply_to_parent workitem
         end
 
         def reply (workitem)
             # discard silently... should never get called though
         end
 
-        #def cancel ()
-        #end
-            #
-            # implemented in parent TimeExpression class
-
         #
         # This is the method called each time the scheduler triggers
         # this cron. The contained segment of process will get 
@@ -179,17 +176,23 @@ module OpenWFE
             if @tab
                 get_scheduler.schedule(
                     @tab, 
-                    { :schedulable => self, :job_id => @scheduler_job_id })
+                    { 
+                        :schedulable => self, 
+                        :job_id => @scheduler_job_id,
+                        :tags => @scheduler_tags })
             else
                 get_scheduler.schedule_every(
                     @every, 
-                    { :schedulable => self, :job_id => @scheduler_job_id })
+                    { 
+                        :schedulable => self, 
+                        :job_id => @scheduler_job_id,
+                        :tags => @scheduler_tags })
             end
 
             ldebug { "reschedule() name is   '#{@name}'" }
             ldebug { "reschedule() job id is '#{@scheduler_job_id}'" }
 
-            #store_itself()
+            #store_itself
                 #
                 # done by the containing environment itself
         end

data/lib/openwfe/expressions/fe_cursor.rb

@@ -83,9 +83,6 @@ module OpenWFE
             :current_child_id,
             :current_child_fei
 
-        #
-        # apply / reply
-
         def apply (workitem)
 
             @loop_id = 0
@@ -161,8 +158,10 @@ module OpenWFE
         # takes care of cancelling the current child if necessary
         #
         def cancel
+
             get_expression_pool.cancel(@current_child_fei) \
                 if @current_child_fei
+
             super
         end
 

data/lib/openwfe/expressions/fe_define.rb

@@ -52,21 +52,18 @@ module OpenWFE
 
         names :define, :process_definition, :workflow_definition
 
+        attr_accessor :body_fei
 
-        attr_accessor :body_fei, :eval_only
-
-        #
+        #--
         # Evaluates the definition, but doesn't apply its body, will 
         # simply return the body fei.
         #
-        def evaluate (workitem)
-
-            @eval_only = true
-
-            apply workitem
-
-            @body_fei
-        end
+        #def evaluate (workitem)
+        #    @eval_only = true
+        #    apply workitem
+        #    @body_fei
+        #end
+        #++
 
         #
         # Called at the end of the 'evaluation', the 'apply' operation on
@@ -74,19 +71,20 @@ module OpenWFE
         #
         def reply_to_parent (workitem)
 
-            return if @eval_only
+            #return if @eval_only
 
-            unless @body_fei
-                super workitem
-                return
-            end
+            #puts "/// \n   bf #{@body_fei} \n   wi.fei #{workitem.fei}"
 
-            fei = @body_fei
-            @body_fei = nil
+            return super(workitem) \
+                if @body_fei == nil or @body_fei == workitem.fei
+                #unless @body_fei
 
-            store_itself()
+            #_fei = @body_fei
+            #@body_fei = nil
+            #store_itself
+            #get_expression_pool.apply _fei, workitem
 
-            get_expression_pool.apply fei, workitem
+            get_expression_pool.apply @body_fei, workitem
         end
 
         #
@@ -113,7 +111,10 @@ module OpenWFE
 
         protected
 
-            def get_to_next_child
+            #
+            # Determines the flowExpressionId of the next child to apply.
+            #
+            def next_child (current_fei)
 
                 next_fei = super
 
@@ -121,26 +122,28 @@ module OpenWFE
 
                 rawchild = get_expression_pool.fetch_expression next_fei
 
+                return next_child(next_fei) unless rawchild
+
                 unless rawchild.is_definition?
-                    @body_fei = next_fei unless @body_fei
-                    return get_to_next_child
+
+                    unless @body_fei
+                        @body_fei = next_fei
+                        store_itself
+                    end
+                    return next_child(next_fei)
                 end
 
                 exp_class = get_expression_map.get_class rawchild
 
                 if exp_class == DefineExpression
-                    #
-                    # binds the FlowExpressionId of the current child
-                    # as a variable and recurses to the next child
-                    #
                     set_variable rawchild.definition_name, next_fei
-                    return get_to_next_child
+                    return next_child(next_fei)
                 end
 
-                #
-                # our next child will simply get applied
-
                 next_fei
+                    #
+                    # expression is a 'set', a 'filter-definition' or
+                    # something like that, let it get applied
             end
     end