openwferu 0.9.7 → 0.9.8

data/lib/openwfe/expool/journal.rb

@@ -59,7 +59,7 @@ module OpenWFE
         include MonitorMixin, OwfeServiceLocator
         include JournalReplay
 
-        attr_reader :workdir
+        attr_reader :workdir, :donedir
 
         FREQ = "1m"
             #
@@ -72,16 +72,18 @@ module OpenWFE
             @buckets = {}
 
             @workdir = OpenWFE::get_work_directory + "/journal"
-            FileUtils.makedirs(@workdir) unless File.exist?(@workdir)
+            @donedir = @workdir + "/done"
+
+            FileUtils.makedirs(@donedir) unless File.exist?(@donedir)
 
             get_expression_pool.add_observer(:all) do |event, *args|
                 #ldebug { ":#{event}  for #{args[0].to_debug_s}" }
                 queue_event(event, *args)
             end
 
-            #@thread_id = get_scheduler.schedule_every(FREQ) do
-            #    flush_buckets()
-            #end
+            @thread_id = get_scheduler.schedule_every(FREQ) do
+                flush_buckets()
+            end
         end
 
         #
@@ -94,28 +96,64 @@ module OpenWFE
 
         protected
 
+            #
+            # Queues the events before a flush.
+            #
+            # If the event is a :terminate, the individual bucket will get
+            # flushed.
+            #
             def queue_event (event, *args)
+                synchronize do
+
+                    return if event == :stop
+                    return if event == :launch
+                    return if event == :reschedule
 
-                return if event == :stop
-                return if event == :launch
+                    wfid = args[0].parent_wfid
+                    #puts "__#{wfid} : #{event}"
 
-                wfid = args[0].parent_wfid
-                #puts "__#{wfid} : #{event}"
+                    e = serialize_event(event, *args)
 
-                e = serialize_event(event, *args)
+                    bucket = get_bucket(wfid) 
+                    bucket << e
 
-                bucket = get_bucket(wfid) 
-                bucket << e
+                    if event == :terminate
 
-                if event == :terminate
-                    bucket.flush
-                    @buckets.delete(wfid)
+                        bucket.flush
+                        @buckets.delete(wfid)
+
+                        if @application_context[:keep_journals] == true
+                            #
+                            # 'move' journal to the done/ subdir of journal/
+                            #
+                            FileUtils.cp(
+                                bucket.get_path,
+                                @donedir + "/" + bucket.get_file_name)
+                        end
+
+                        FileUtils.rm bucket.get_path
+                    end
                 end
             end
 
+            #
+            # Makes sure that all the buckets are persisted to disk
+            #
             def flush_buckets
+
+                count = 0
+
                 synchronize do
+
+                    @buckets.each do |k, v|
+                        v.flush
+                        count += 1
+                    end
+                    @buckets.clear
                 end
+
+                linfo { "flush_buckets() flushed #{count} buckets" } \
+                    if count > 0
             end
 
             def get_bucket (wfid)
@@ -133,7 +171,6 @@ module OpenWFE
             # events waiting to get written in the journal
             #
             class Bucket
-                include MonitorMixin
 
                 attr_reader :wfid, :events
 
@@ -145,9 +182,7 @@ module OpenWFE
                 end
 
                 def << (event)
-                    synchronize do
-                        @events << event
-                    end
+                    @events << event
                 end
 
                 def size
@@ -156,17 +191,20 @@ module OpenWFE
                 alias :length :size
 
                 def flush
-                    synchronize do
-
-                        fn = @workdir + "/" + @wfid.to_s + ".journal"
-
-                        File.open(fn, "w+") do |f|
-                            @events.each do |e|
-                                f.puts e
-                            end
+                    File.open(get_path, "w+") do |f|
+                        @events.each do |e|
+                            f.puts e
                         end
-                        @events.clear
                     end
+                    @events.clear
+                end
+
+                def get_path
+                    @workdir + "/" + get_file_name
+                end
+
+                def get_file_name
+                    @wfid.to_s + ".journal"
                 end
             end
 

data/lib/openwfe/expool/journal_replay.rb

@@ -45,77 +45,219 @@ require 'openwfe/flowexpressionid'
 module OpenWFE
     
     #
-    # Keeping a replayable track of the events in an OpenWFEru engine
+    # The code decicated to replay and reconstitute journal.
     #
     module JournalReplay
 
-        def replay (file_path)
+        #
+        # Replays a given journal file.
+        #
+        # The offset can be determined by running the analyze() method.
+        #
+        # If 'trigger_action' is set to true, the apply or reply or cancel
+        # action found at the given offset will be triggered.
+        #
+        def replay (file_path, offset, trigger_action=false)
 
-            events = File.open(file_path) do |f|
-                s = YAML.load_stream f
-                s.documents
+            states = decompose(file_path)
+
+            state = nil
+
+            states.each do |s|
+                state = s if s.offset == offset
+            end
+
+            raise "cannot replay offset #{offset}" unless state
+
+            #puts "expstorage size 0 = #{get_expression_storage.size}"
+
+            state.static.each do |update|
+                flow_expression = update[3]
+                flow_expression.application_context = @application_context
+                get_expression_pool.update(flow_expression)
             end
 
-            #
-            # what to do with Sleep and When ?
+            get_expression_pool.reschedule
 
-            events = events[0..-20]
+            #puts "expstorage size 1 = #{get_expression_storage.size}"
 
-            participants = {}
+            return unless trigger_action
 
-            seen = {}
-            static = []
-            events.reverse.each do |e|
+            state.dynamic.each do |ply|
 
-                etype = e[0]
-                fei = e[2]
+                message = ply[0]
+                fei = ply[2]
+                wi = ply[3]
 
-                next if etype == :apply
-                next if etype == :reply
-                next if etype == :reply_to_parent
-                next if seen[fei]
+                if wi
+                    #
+                    # apply, reply, reply_to_parent
+                    #
+                    get_expression_pool.send message, fei, wi
+                else
+                    #
+                    # cancel
+                    #
+                    get_expression_pool.send message, fei
+                end
+            end
+        end
+
+        #
+        # Outputs a report of the each of the main events that the journal 
+        # traced.
+        #
+        # The output goes to the stdout.
+        #
+        # The output can be used to determine an offset number for a replay()
+        # of the journal.
+        #
+        def analyze (file_path)
 
-                seen[fei] = true
+            states = decompose(file_path)
 
-                next if etype == :remove
+            states.each do |state|
 
-                static << e
+                next if state.dynamic.length < 1
 
-                participants[fei] = true \
-                    if e[3].is_a? OpenWFE::ParticipantExpression
+                puts
+                puts state.to_s
+                puts
             end
+        end
+
+        #
+        # Decomposes the given file_path into a list of states
+        #
+        def decompose (file_path)
 
-            seen = {}
-            dynamic = []
-            events.reverse.each do |e|
-                etype = e[0]
-                fei = e[2]
-                next if etype == :update
-                next if etype == :remove
-                #next if etype == :reply_to_parent
-                next if seen[fei]
-                next unless participants[fei]
-                seen[fei] = true
-                dynamic << e
+            do_decompose(load_events(file_path), [], nil, 0)
+        end
+
+        protected
+
+            def do_decompose (events, result, previous_state, offset)
+
+                current_state = extract_state(events, offset)
+
+                return result unless current_state
+
+                result << current_state
+
+                do_decompose(events, result, current_state, offset + 1)
             end
 
-            puts
-            puts "static :"
-            static.each do |e|
-                puts " - #{e[0]}   #{e[2].to_short_s}"
+            def load_events (file_path)
+
+                File.open(file_path) do |f|
+                    s = YAML.load_stream f
+                    s.documents
+                end
             end
 
-            puts
-            puts "participants :"
-            participants.each do |fei, v|
-                puts " - #{fei.to_short_s}"
+            def extract_state (file, offset)
+
+                events = if file.is_a?(String)
+                    load_events(file)
+                else
+                    file
+                end
+
+                #
+                # what to do with Sleep and When ?
+
+                off = -1
+                off = off - offset if offset
+
+                return nil if (events.size + off < 0)
+
+                events = events[0..off]
+
+                date = events[-1][1]
+
+                participants = {}
+
+                seen = {}
+                static = []
+                events.reverse.each do |e|
+
+                    etype = e[0]
+                    fei = e[2]
+
+                    next if etype == :apply
+                    next if etype == :reply
+                    next if etype == :reply_to_parent
+                    next if seen[fei]
+
+                    seen[fei] = true
+
+                    next if etype == :remove
+
+                    static << e
+
+                    participants[fei] = true \
+                        if e[3].is_a? OpenWFE::ParticipantExpression
+                end
+
+                seen = {}
+                dynamic = []
+                events.reverse.each do |e|
+                    etype = e[0]
+                    fei = e[2]
+                    next if etype == :update
+                    next if etype == :remove
+                    #next if etype == :reply_to_parent
+                    next if seen[fei]
+                    next unless participants[fei]
+                    seen[fei] = true
+                    dynamic << e
+                end
+
+                ExpoolState.new(offset, date, static, dynamic, participants)
             end
 
-            puts
-            puts "dynamic :"
-            dynamic.each do |e|
-                puts " - #{e[0]}   #{e[2].to_short_s}"
+            class ExpoolState
+
+                attr_accessor \
+                    :offset,
+                    :date,
+                    :static,
+                    :dynamic,
+                    :participants
+
+                def initialize (offset, date, static, dynamic, participants)
+
+                    @offset = offset
+                    @date = date
+                    @static = static
+                    @dynamic = dynamic
+                    @participants = participants
+                end
+
+                def to_s
+
+                    s = " ===== offset : #{@offset}  #{@date} =====\n"
+
+                    s << "\n"
+                    s << "static :\n"
+                    @static.each do |e|
+                        s << " - #{e[0]}   #{e[2].to_short_s}\n"
+                    end
+
+                    s << "\n"
+                    s << "dynamic :\n"
+                    @dynamic.each do |e|
+                        s << " - #{e[0]}   #{e[2].to_short_s}\n"
+                    end
+
+                    #s << "\n"
+                    #s <<  "participants :\n"
+                    #@participants.each do |fei, v|
+                    #    s << " - #{fei.to_short_s}\n"
+                    #end
+
+                    s
+                end
             end
-        end
     end
 end

data/lib/openwfe/expool/wfidgen.rb

@@ -65,13 +65,22 @@ module OpenWFE
 
             load_last()
 
-            @last_f = File.open(@last_fn, "w")
+            begin
+                @last_f = File.open(@last_fn, "w+")
+            rescue Exception => e
+                lwarn do
+                    "new() failed to open #{@last_fn}, continuing anyway...\n"+
+                    OpenWFE::exception_to_s(e)
+                end
+            end
         end
 
         #
         # Returns a new workflow instance id
         #
-        def generate
+        # The launchitem parameter is not used by this generator.
+        #
+        def generate (launchitem=nil)
             wfid = nil
             @mutex.synchronize do
                 wfid = now
@@ -115,7 +124,7 @@ module OpenWFE
         # file is closed.
         #
         def stop
-            @last_f.close
+            @last_f.close if @last_f
         end
 
         protected
@@ -126,6 +135,7 @@ module OpenWFE
             end
 
             def save_last
+                return unless @last_f
                 @last_f.pos = 0
                 @last_f.puts @last
             end
@@ -135,7 +145,7 @@ module OpenWFE
 
                     if File.exist?(@last_fn)
                         begin
-                            s = File.open(@last_fn, "r+") do |f|
+                            s = File.open(@last_fn, "r") do |f|
                                 f.readline
                             end
                             @last = Integer(s)
@@ -216,7 +226,40 @@ module OpenWFE
         end
 
         def self.from_time (t)
-            to_string (t.to_f * 10 * 1000).to_i
+            to_string(t.to_f * 10 * 1000).to_i
+        end
+    end
+
+    #
+    # This wfid generator returns as wfid the value found in a given
+    # field of the launchitem (if any).
+    #
+    # If there is no launchitem or no field, a Kotoba wfid is returned.
+    #
+    # This generator is useful for engines that have to use workflow
+    # instance ids generated by other systems.
+    #
+    class FieldWfidGenerator < KotobaWfidGenerator
+
+        def initialize (service_name, application_context, field_name)
+
+            super(service_name, application_context)
+
+            @field_name = field_name
+        end
+
+        def generate (launchitem=nil)
+
+            return super unless launchitem
+
+            wfid = launchitem.attributes[@field_name]
+
+            return wfid.to_s if wfid
+
+            super
+                #
+                # if the field is not present in the launchitem, will
+                # return a Kotoba wfid
         end
     end
 
@@ -263,7 +306,9 @@ module OpenWFE
         #
         # Generates a brand new UUID
         #
-        def generate
+        # The launchitem parameter is not used by this generator.
+        #
+        def generate (launchitem=nil)
             return `#{@command}`.chomp
         end
 

data/lib/openwfe/expressions/condition.rb

@@ -61,17 +61,23 @@ module OpenWFE
     #
     module ConditionMixin
 
+        #
+        # This is the method brought to expression classes including this
+        # mixin. Easy evaluation of a conditon expressed in an attribute.
+        #
         def eval_condition (attname, workitem)
 
+            #attname = pick_attribute(attname) \
+            #    if attname.is_a?(Array)
+
             conditional = lookup_attribute(attname, workitem)
             rconditional = lookup_attribute("r"+attname.to_s, workitem)
 
-            if rconditional and not conditional
-                #return instance_eval(rconditional)
-                return do_eval(rconditional)
-            end
+            return do_eval(rconditional) \
+                if rconditional and not conditional
 
-            return nil unless conditional
+            return nil \
+                unless conditional
 
             #ldebug { "eval_condition() 0 for  '#{conditional}'" }
 
@@ -91,6 +97,44 @@ module OpenWFE
             return (result == "true" or result == true)
         end
 
+        #
+        # Returns nil if the cited attname (without or without 'r' prefix)
+        # is not present.
+        #
+        # Attname may be a String or a Symbol, or an Array of String or Symbol
+        # instances.
+        #
+        # Returns the Symbol the attribute if present.
+        #
+        def determine_condition_attribute (attname)
+
+            attname = [ attname ] unless attname.is_a?(Array)
+
+            attname.each do |aname|
+                aname = aname.intern if aname.is_a?(String)
+                return aname if has_attribute(aname)
+                return aname if has_attribute("r" + aname.to_s)
+            end
+
+            nil
+        end
+
+        protected
+
+            #
+            # If the attribute name is a list of attribute names, pick
+            # the first one present.
+            #
+            #def pick_attribute (attnames)
+            #    attnames.each do |attname|
+            #        return attname if has_attribute(attname)
+            #        return attname if has_attribute("r" + attname.to_s)
+            #    end
+            #    return attnames[0]
+            #        #
+            #        # some kind of a default (for error messages)
+            #end
+
         private
 
             def from_xml (string)

data/lib/openwfe/expressions/environment.rb

@@ -48,7 +48,7 @@ module OpenWFE
 
     #
     # An environment is a store for variables.
-    # It's an expression as it's storable in the expression pool.
+    # It's an expression thus it's storable in the expression pool.
     #
     class Environment < FlowExpression
         include Schedulable
@@ -68,19 +68,10 @@ module OpenWFE
 
         def [] (key)
 
-            #if OpenWFE::starts_with(key, "//")
-            #    return get_expression_pool()\
-            #        .get_engine_environment()[key[2..-1]]
-            #end
-            #if OpenWFE::starts_with(key, "/")
-            #    return get_root_environment()[key[1..-1]]
-            #end
-
             value = @variables[key]
 
             return value \
                 if @variables.has_key?(key) or is_engine_environment?
-                #if value or is_engine_environment?
 
             return get_parent[key] if @parent_id
 
@@ -88,38 +79,19 @@ module OpenWFE
         end
 
         def []= (key, value)
+            synchronize do
 
-            #if OpenWFE::starts_with(key, "//")
-            #    key = key[2..-1]
-            #    get_expression_pool().fetch_engine_environment()[key] = value
-            #elsif OpenWFE::starts_with(key, "/")
-            #    key = key[1..-1]
-            #    get_root_environment()[key] = value
-            #else
-            #    @variables[key] = value
-            #    store_itself()
-            #    #ldebug { "[]= #{@fei.to_debug_s}  :  '#{key}' -> '#{value}'" }
-            #end
-
-            @variables[key] = value
-            store_itself()
+                @variables[key] = value
+                store_itself()
+            end
         end
 
         def delete (key)
+            synchronize do
 
-            #if OpenWFE::starts_with(key, "//")
-            #    key = key[2..-1]
-            #    get_expression_pool().fetch_engine_environment().delete(key)
-            #elsif OpenWFE::starts_with(key, "/")
-            #    key = key[1..-1]
-            #    get_root_environment().delete(key)
-            #else
-            #    @variables.delete(key)
-            #    store_itself()
-            #end
-
-            @variables.delete key
-            store_itself()
+                @variables.delete key
+                store_itself()
+            end
         end
 
         #