openwferu 0.9.4 → 0.9.5

data/examples/mano_tracker.rb

@@ -45,7 +45,8 @@
 # for the context of this example
 #
 
-require 'openwfe/engine/engine'
+#require 'openwfe/engine/engine'
+require 'openwfe/engine/file_persisted_engine'
 require 'openwfe/expressions/raw_prog'
 require 'openwfe/participants/storeparticipant'
 
@@ -84,9 +85,14 @@ CREATIVES = [ "Jamie", "Jeff", "John", "Jeremy" ]
 #
 # instantiate the engine (a transient one is sufficient for the example)
 
-$engine = OpenWFE::engine.new
-    #
-    # setting up a transient engine
+#$engine = OpenWFE::Engine.new
+    # no persistence
+
+#$engine = OpenWFE::FilePersistedEngine.new
+    # persistence, but no caching (worst performance)
+
+$engine = OpenWFE::CachedFilePersistedEngine.new
+    # persistence and performance
 
 $analyst_stores = {}
 $creative_stores = {}
@@ -95,8 +101,9 @@ $creative_stores = {}
 
 def add_stores (names, store_map)
     names.each do |name|
-        hp = OpenWFE::HashParticipant.new
-        $engine.register_participant(name, hp)
+        #hp = OpenWFE::HashParticipant.new
+        #$engine.register_participant(name, hp)
+        hp = $engine.register_participant(name, OpenWFE::YamlParticipant)
         store_map[name] = hp
     end
 end

data/examples/quotereporter.rb

@@ -53,9 +53,10 @@ class QuoteLookupFlow < OpenWFE::ProcessDefinition
                 #participant :ref => "puts_workitem"
                 #participant :ref => :puts_workitem
                 #participant "puts_workitem"
-                participant :puts_workitem
+                #participant :puts_workitem
+                puts_workitem
                     #
-                    # the four notations are equivalent
+                    # the five notations are equivalent
             end
         end
     end

data/lib/openwfe/engine/engine.rb

@@ -67,15 +67,31 @@ module OpenWFE
 
             @application_context[@service_name] = self
 
+            $OWFE_LOG = Logger.new("engine.log") unless $OWFE_LOG
+
+            # build order matters.
+            #
+            # especially for the expstorage which 'observes' the expression
+            # pool and thus needs to be instantiated after it.
+
             build_scheduler()
 
             build_expression_map()
-            build_expression_storage()
+
             build_expression_pool()
+            build_expression_storage()
 
             build_participant_map()
 
-            $OWFE_LOG = Logger.new("engine.log") unless $LOG
+            #
+            # engine components are ready for operation, it's time to 
+            # check persisted expressions (if any) to see if something
+            # has to be rescheduled (like a long time sleep expression or
+            # a cron)
+
+            get_expression_pool.reschedule()
+
+            linfo { "new() --- engine started --- #{self.object_id}" }
         end
 
         #
@@ -84,7 +100,13 @@ module OpenWFE
         # either a String containing the URL of the process definition
         # to launch (with an empty LaunchItem created on the fly).
         #
-        def launch (launch_object)
+        # If async is set to true, the process will be launched asynchronously
+        # (in his own thread).
+        #
+        # Returns a FlowExpressionId instance or a tuple FlowExpressionId / 
+        # Thread object if async is set to true.
+        #
+        def launch (launch_object, async=false)
 
             launchitem = nil
 
@@ -102,7 +124,7 @@ module OpenWFE
                 end
             end
 
-            get_expression_pool.launch(launchitem)
+            get_expression_pool.launch(launchitem, async)
         end
 
         #
@@ -120,6 +142,10 @@ module OpenWFE
         # This method is a shortcut to the ParticipantMap method
         # with the same name.
         #
+        # Returns the participant instance.
+        #
+        # see ParticipantMap#register_participant
+        #
         def register_participant (regex, participant=nil, &block)
 
             get_participant_map.register_participant(regex, participant, &block)
@@ -180,6 +206,7 @@ module OpenWFE
             end
             
             def build_scheduler ()
+                #ldebug { "build_scheduler()" }
                 init_service(S_SCHEDULER, SchedulerService)
             end
 

data/lib/openwfe/engine/file_persisted_engine.rb

@@ -51,16 +51,42 @@ module OpenWFE
     #
     class FilePersistedEngine < Engine
 
-      #
-      # Overrides the method already found in Engine with a persisted 
-      # expression storage
-      #
-      def build_expression_storage ()
+        protected
 
-          @application_context[:work_directory] = "./work"
+            #
+            # Overrides the method already found in Engine with a persisted 
+            # expression storage
+            #
+            def build_expression_storage ()
 
-          init_service(S_EXPRESSION_STORAGE, YamlFileExpressionStorage)
-      end
-  
+                @application_context[:work_directory] = "./work"
+
+                init_service(S_EXPRESSION_STORAGE, YamlFileExpressionStorage)
+            end
+    end
+
+    #
+    # An engine with a cache in front of its file persisted expression storage.
+    #
+    class CachedFilePersistedEngine < Engine
+
+        protected
+
+            def build_expression_storage ()
+
+                @application_context[:expression_cache_size] = 1000
+                @application_context[:work_directory] = "./work"
+
+                init_service(
+                    S_EXPRESSION_STORAGE, 
+                    CacheExpressionStorage)
+
+                #init_service(
+                #    S_EXPRESSION_STORAGE + ".1",
+                #    YamlFileExpressionStorage)
+                init_service(
+                    S_EXPRESSION_STORAGE + ".1",
+                    ThreadedYamlFileExpressionStorage)
+            end
     end
 end

data/lib/openwfe/expool/expressionpool.rb

@@ -49,8 +49,7 @@ require 'openwfe/service'
 require 'openwfe/logging'
 require 'openwfe/rudefinitions'
 require 'openwfe/flowexpressionid'
-require 'openwfe/util/stoppable'
-require 'openwfe/util/lru_cache'
+require 'openwfe/util/lru'
 require 'openwfe/util/observable'
 require 'openwfe/expressions/environment'
 require 'openwfe/expressions/raw_xml'
@@ -72,7 +71,7 @@ module OpenWFE
         def initialize (application_context=nil)
             super()
             @application_context = application_context
-            @monitors = LRUCache.new(MAX_MONITORS)
+            @monitors = LruHash.new(MAX_MONITORS)
         end
 
         def [] (key)
@@ -127,7 +126,6 @@ module OpenWFE
             ServiceMixin, 
             MonitorMixin, 
             OwfeServiceLocator, 
-            Stoppable, 
             Observable
 
         @@last_given_instance_id = -1
@@ -144,16 +142,14 @@ module OpenWFE
 
             @observers = {}
 
-            reschedule_a_bit_later
+            @stopped = false
         end
 
         #
         # Makes sure to call the do_stop() method of the Stoppable mixin
         #
         def stop
-            # would an alias be better ?
-            do_stop
-            
+            @stopped = true
             onotify :stop
         end
 
@@ -169,24 +165,42 @@ module OpenWFE
         #
         # Instantiates a workflow definition and launches it.
         #
-        def launch (launchitem)
+        # If async is set to true, the launch will occur in its own thread.
+        #
+        # Returns the FlowExpressionId instance of the root expression of
+        # the newly launched flow.
+        # If async is set to true, returns a tuple FlowExpressionId /
+        # Thread instance used.
+        #
+        def launch (launchitem, async=false)
 
             onotify :launch, launchitem.workflow_definition_url
 
-            rawExpression = buildRawExpression(launchitem)
+            raw_expression = buildRawExpression(launchitem)
 
             wi = build_workitem(launchitem)
 
-            rawExpression.apply(wi)
+            fei = raw_expression.fei
+
+            if async
+
+                t = OpenWFE::call_in_thread "launch()", self do
+                    raw_expression.apply(wi)
+                end
+
+                return fei, t
+            end
 
-            return wi.flow_expression_id
+            raw_expression.apply(wi)
+
+            return fei
         end
 
         #
         # launches a subprocess
         #
-        def launch_template \
-            (requesting_expression, template, workitem, params=nil)
+        def launch_template (
+            requesting_expression, sub_id, template, workitem, params=nil)
 
             #ldebug { "launch_template() of class #{template.class}" }
 
@@ -205,18 +219,28 @@ module OpenWFE
             rawexp = rawexp.dup()
             rawexp.fei = rawexp.fei.dup()
 
-            if requesting_expression.kind_of? FlowExpressionId
+            if requesting_expression == nil
+
+                rawexp.parent_id = nil
+                rawexp.fei.workflow_instance_id = new_workflow_instance_id()
+
+            elsif requesting_expression.kind_of? FlowExpressionId
+
                 rawexp.parent_id = requesting_expression
                 rawexp.fei.workflow_instance_id = \
-                    "#{requesting_expression.workflow_instance_id}.0"
+                    "#{requesting_expression.workflow_instance_id}.#{sub_id}"
+
             elsif requesting_expression.kind_of? String
+
                 rawexp.parent_id = nil
                 rawexp.fei.workflow_instance_id = \
-                    "#{requesting_expression}.0"
+                    "#{requesting_expression}.${sub_id}"
+
             else # kind is FlowExpression
+
                 rawexp.parent_id = requesting_expression.fei
                 rawexp.fei.workflow_instance_id = \
-                    "#{requesting_expression.fei.workflow_instance_id}.0"
+                    "#{requesting_expression.fei.workflow_instance_id}.#{sub_id}"
             end
 
             #ldebug do
@@ -242,11 +266,11 @@ module OpenWFE
 
             workitem.flow_expression_id = rawexp.fei
 
-            rawexp.apply(workitem)
+            fei = rawexp.fei
 
-            # why not : launch in a thread and reply immediately
+            rawexp.apply(workitem)
 
-            return workitem.flow_expression_id
+            return fei
         end
 
         #
@@ -254,9 +278,15 @@ module OpenWFE
         # returns its body fei
         #
         def evaluate (rawExpression, workitem)
+
             exp = rawExpression.instantiate_real_expression(workitem)
             fei = exp.evaluate(workitem)
-            remove(rawExpression)
+
+            #remove(rawExpression)
+                #
+                # not necessary, the raw expression gets overriden by
+                # the real expression
+
             return fei
         end
 
@@ -305,6 +335,19 @@ module OpenWFE
             return inflowitem
         end
 
+        #
+        # Given any expression of a process, cancels the complete process.
+        #
+        def cancel_flow (exp)
+
+            ldebug { "cancel_flow() from  #{exp}" }
+
+            root = fetch_root(exp)
+            cancel(root)
+        end
+
+        alias :cancel_process :cancel_flow
+
         #
         # Forgets the given expression (makes sure to substitute its
         # parent_id with the GONE_PARENT_ID constant)
@@ -326,13 +369,12 @@ module OpenWFE
         #
         def reply_to_parent (exp, workitem)
 
-            exp, fei = fetch(exp)
+            ldebug { "reply_to_parent() for #{exp.fei.to_debug_s}" }
 
-            workitem.last_expression_id = fei
+            workitem.last_expression_id = exp.fei
 
-            onotify :reply_to_parent, fei, workitem
+            onotify :reply_to_parent, exp.fei, workitem
 
-            #remove(exp, workitem)
             remove(exp)
 
             #
@@ -383,9 +425,15 @@ module OpenWFE
         #
         def update (flowExpression)
 
+            t = Timer.new
+
             onotify :update, flowExpression.fei, flowExpression
 
-            get_expression_storage()[flowExpression.fei] = flowExpression
+            #get_expression_storage()[flowExpression.fei] = flowExpression
+
+            ldebug { "update() took #{t.duration} ms" }
+
+            return flowExpression
         end
 
         #
@@ -399,6 +447,9 @@ module OpenWFE
             synchronize do
 
                 fei = exp
+
+                #ldebug { "fetch() exp is of kind #{exp.class}" }
+
                 if exp.kind_of? FlowExpression
                     fei = exp.fei 
                 elsif not exp.kind_of? FlowExpressionId
@@ -424,6 +475,19 @@ module OpenWFE
             return exp
         end
 
+        #
+        # Fetches the root expression of a process (given any of its
+        # expressions).
+        #
+        def fetch_root (exp)
+            exp = fetch_expression(exp)
+            return exp unless exp.parent_id
+            return fetch_root(fetch_expression(exp.parent_id))
+        end
+
+        #
+        # Returns the engine environment (the top level environment)
+        #
         def fetch_engine_environment ()
             synchronize do
 
@@ -446,22 +510,26 @@ module OpenWFE
         #
         def remove (exp)
 
-            exp, fei = fetch(exp)
+            #exp, fei = fetch(exp)
+
+            if exp.kind_of? FlowExpressionId
+                exp, _fei = fetch(exp)
+            end
 
             return if not exp
 
-            ldebug { "remove()  fe  #{fei.to_debug_s}" }
+            ldebug { "remove()  fe  #{exp.fei.to_debug_s}" }
 
-            onotify :remove, fei
+            onotify :remove, exp.fei
 
             synchronize do
 
-                @monitors.delete(fei)
+                @monitors.delete(exp.fei)
 
-                #get_expression_storage().remove(fei, workitem)
-                get_expression_storage().delete(fei)
+                #get_expression_storage().delete(fei)
 
                 if exp.owns_its_environment?
+
                     remove_environment(exp.environment_id)
                 end
 
@@ -474,19 +542,12 @@ module OpenWFE
         # to reschedule ones like 'sleep' or 'cron'.
         #
         def reschedule
+
+            return if @stopped
+
             synchronize do
 
-                #if is_stopped?
-                #    linfo { "reschedule() skipped as expool is stopped" }
-                #    return
-                #end
-                #if get_scheduler.is_stopped?
-                #    linfo do 
-                #        "reschedule() skipped as scheduler "+
-                #        "#{get_scheduler.object_id} is stopped"
-                #    end
-                #    return
-                #end
+                t = OpenWFE::Timer.new
 
                 ldebug { "reschedule() initiating..." }
 
@@ -499,7 +560,7 @@ module OpenWFE
                     fe.reschedule(get_scheduler)
                 end
 
-                ldebug { "reschedule() done." }
+                ldebug { "reschedule() done. (took #{t.duration} ms)" }
             end
         end
 
@@ -527,25 +588,6 @@ module OpenWFE
 
         protected
 
-            def reschedule_a_bit_later
-                Thread.new do
-                    #
-                    # Just leaving some time for the initialize() to finish
-                    # and let the expression pool get registered in
-                    # the application context
-                    #
-                    begin
-                        sleep(0.001)
-                        reschedule()
-                    rescue
-                        lwarn do 
-                            "reschedule() failed\n"+ 
-                            OpenWFE::exception_to_s($!)
-                        end
-                    end
-                end
-            end
-
             def evaluate_definition (raw_definition, workitem)
                 expression = raw_definition.instantiate(workitem)
             end
@@ -558,7 +600,9 @@ module OpenWFE
 
                 env.unbind()
 
-                get_expression_storage().delete(environment_id)
+                #get_expression_storage().delete(environment_id)
+
+                onotify :remove, environment_id
             end
 
             def build_workitem (launchitem)
@@ -613,7 +657,7 @@ module OpenWFE
 
                 if sDefinition.kind_of? Class
 
-                    return sDefinition.do_make(get_expression_map)
+                    return sDefinition.do_make()
                 end
 
                 raise \
@@ -640,9 +684,14 @@ module OpenWFE
             def new_workflow_instance_id ()
 
                 synchronize do
+
                     wfid = OpenWFE::current_time_millis()
-                    wfid = wfid + 1 if wfid == @@last_given_instance_id
+
+                    wfid = @@last_given_instance_id + 1 \
+                        if wfid <= @@last_given_instance_id
+
                     @@last_given_instance_id = wfid
+
                     return wfid.to_s
                 end
             end