openwferu 0.9.15 → 0.9.16

data/README.txt

@@ -1,16 +1,18 @@
 = OpenWFEru, Standard Library Documentation
 
 == Prerequisites
-Ruby 1.8.5 or later
-RubyGems 0.9.4 or later
+
+Ruby 1.8.5 or later, RubyGems 0.9.4 or later
 
 == Installation
+
 Installation can be handled by Ruby gems.  This will pull in any libraries
 you will need to install
 
   gem install -y openwferu
 
 == Overview
+
 OpenWFEru is a Ruby port of the OpenWFE workflow engine 
 (http://www.openwfe.org).  It is a complete rewrite in Ruby 
 so does not need to use the Java-based engine from OpenWFE.

data/lib/openwfe/engine/engine.rb

@@ -86,7 +86,7 @@ module OpenWFE
             unless $OWFE_LOG
                 #puts "Creating logs in " + FileUtils.pwd
                 FileUtils.mkdir("logs") unless File.exist?("logs")
-                $OWFE_LOG = Logger.new("logs/openwferu.log", 10, 1024000)
+                $OWFE_LOG = Logger.new "logs/openwferu.log", 10, 1024000
                 $OWFE_LOG.level = Logger::INFO
             end
 
@@ -95,37 +95,37 @@ module OpenWFE
             # especially for the expstorage which 'observes' the expression
             # pool and thus needs to be instantiated after it.
 
-            build_scheduler()
+            build_scheduler
                 #
                 # for delayed or repetitive executions (it's the engine's clock)
                 # see http://openwferu.rubyforge.org/scheduler.html
 
-            build_expression_map()
+            build_expression_map
                 #
                 # mapping expression names ('sequence', 'if', 'concurrence', 
                 # 'when'...) to their implementations (SequenceExpression,
                 # IfExpression, ConcurrenceExpression, ...)
 
-            build_wfid_generator()
+            build_wfid_generator
                 #
                 # the workflow instance (process instance) id generator
                 # making sure each process instance has a unique identifier
 
-            build_expression_pool()
+            build_expression_pool
                 #
                 # the core (hairy ball) of the engine
 
-            build_expression_storage()
+            build_expression_storage
                 #
                 # the engine persistence (persisting the expression instances
                 # that make up process instances)
 
-            build_participant_map()
+            build_participant_map
                 #
                 # building the services that maps participant names to 
                 # participant implementations / instances.
 
-            build_error_journal()
+            build_error_journal
                 #
                 # builds the error journal (keeping track of failures
                 # in business process executions, and an opportunity to
@@ -212,22 +212,50 @@ module OpenWFE
         #
         # This method also accepts LaunchItem instances.
         #
+        # Since OpenWFEru 0.9.16, this reply method accepts InFlowWorkitem
+        # that don't belong to a process instance (ie whose flow_expression_id
+        # is nil). It will simply notify the participant_map of the reply
+        # for the given participant_name. If there is no participant_name
+        # specified for this orphan workitem, an exception will be raised.
+        #
         def reply (workitem)
 
-            if workitem.kind_of?(InFlowWorkItem)
+            if workitem.is_a?(InFlowWorkItem)
 
-                get_expression_pool.reply workitem.flow_expression_id, workitem
+                if workitem.flow_expression_id
+                    #
+                    # vanilla case, workitem coming back
+                    # (from listener probably)
 
-            elsif workitem.kind_of?(LaunchItem)
+                    return get_expression_pool.reply(
+                        workitem.flow_expression_id, workitem)
+                end
 
-                get_expression_pool.launch workitem
+                if workitem.participant_name
+                    #
+                    # a workitem that doesn't belong to a process instance
+                    # but bears a participant name.
+                    # Notify, there may be something listening on
+                    # this channel (see the 'listen' expression).
 
-            else
+                    return get_participant_map.onotify(
+                        workitem.participant_name, :reply, workitem)
+                end
 
                 raise \
-                    "engine.reply() " +
-                    "cannot handle instances of #{workitem.class}"
+                    "InFlowWorkitem doesn't belong to a process instance" +
+                    " nor to a participant"
             end
+
+            return get_expression_pool.launch(workitem) \
+                if workitem.is_a?(LaunchItem)
+                    #
+                    # launchitem coming from listener
+                    # let's attempt to launch a new process instance
+
+            raise \
+                "engine.reply() " +
+                "cannot handle instances of #{workitem.class}"
         end
 
         alias :forward :reply
@@ -254,7 +282,7 @@ module OpenWFE
         #
         def get_participant (participant_name)
 
-            get_participant_map.lookup_participant(participant_name)
+            get_participant_map.lookup_participant participant_name
         end
 
         #
@@ -263,7 +291,7 @@ module OpenWFE
         #
         def unregister_participant (participant_name)
 
-            get_participant_map.unregister_participant(participant_name)
+            get_participant_map.unregister_participant participant_name
         end
 
         #
@@ -568,7 +596,11 @@ module OpenWFE
         #
         def pause_process (wfid)
 
-            get_expression_pool.pause_process(wfid)
+            wfid = extract_wfid(wfid)
+
+            root_expression = get_expression_pool.fetch_root(wfid)
+
+            root_expression.set_variable(VAR_PAUSED, true)
         end
 
         #
@@ -578,7 +610,47 @@ module OpenWFE
         #
         def resume_process (wfid)
 
-            get_expression_pool.resume_process(wfid)
+            wfid = extract_wfid wfid
+
+            root_expression = get_expression_pool.fetch_root wfid
+
+            #
+            # remove 'paused' flag
+
+            root_expression.unset_variable(VAR_PAUSED)
+
+            #
+            # replay
+            #
+            # select PausedError instances in separate list
+
+            errors = get_error_journal.get_error_log wfid
+            error_class = PausedError.name
+            paused_errors = errors.select { |e| e.error_class == error_class }
+
+            return if paused_errors.size < 1
+
+            # replay select PausedError instances
+
+            paused_errors.each do |e|
+                replay_at_error e
+            end
+        end
+
+        #
+        # Takes care of removing an error from the error journal and
+        # they replays its process at that point.
+        #
+        def replay_at_error (error)
+
+            get_error_journal.remove_errors(
+                error.fei.parent_wfid, 
+                error)
+
+            get_expression_pool.queue_work(
+                error.message,
+                error.fei,
+                error.workitem)
         end
 
         #
@@ -605,6 +677,46 @@ module OpenWFE
             exp.lookup_variable var_name
         end
 
+        #
+        # Returns an array of wfid (workflow instance ids) whose root
+        # environment containes the given variable 
+        #
+        # If there are no matches, an empty array will be returned.
+        #
+        # Regular expressions are accepted as values.
+        #
+        # If no value is given, all processes with the given variable name
+        # set will be returned.
+        #
+        def lookup_processes (var_name, value=nil)
+
+            # TODO : maybe this would be better in the ExpressionPool
+
+            result = []
+
+            regexp = if value
+                if value.is_a?(Regexp)
+                    value
+                else
+                    Regexp.compile(value.to_s)
+                end
+            else
+                nil
+            end
+
+            get_expression_storage.each_of_kind(Environment) do |fei, env|
+
+                val = env.variables[var_name]
+
+                next unless val
+                next if regexp and (not regexp.match(val))
+
+                result.push env.fei.wfid
+            end
+
+            result
+        end
+
         protected
 
             #--
@@ -649,7 +761,7 @@ module OpenWFE
             #
             def build_expression_pool
 
-                init_service(S_EXPRESSION_POOL, ExpressionPool)
+                init_service S_EXPRESSION_POOL, ExpressionPool
             end
 
             #
@@ -661,7 +773,7 @@ module OpenWFE
             #
             def build_expression_storage
 
-                init_service(S_EXPRESSION_STORAGE, InMemoryExpressionStorage)
+                init_service S_EXPRESSION_STORAGE, InMemoryExpressionStorage
             end
 
             #
@@ -671,7 +783,7 @@ module OpenWFE
             #
             def build_participant_map
 
-                init_service(S_PARTICIPANT_MAP, ParticipantMap)
+                init_service S_PARTICIPANT_MAP, ParticipantMap
             end
             
             #
@@ -680,7 +792,7 @@ module OpenWFE
             #
             def build_scheduler
 
-                init_service(S_SCHEDULER, SchedulerService)
+                init_service S_SCHEDULER, SchedulerService
             end
 
             #
@@ -689,7 +801,7 @@ module OpenWFE
             #
             def build_error_journal
 
-                init_service(S_ERROR_JOURNAL, InMemoryErrorJournal)
+                init_service S_ERROR_JOURNAL, InMemoryErrorJournal
             end
 
             #
@@ -756,10 +868,16 @@ module OpenWFE
         #
         attr_reader :errors
 
+        #
+        # The time at which the process got launched.
+        #
+        attr_reader :launch_time
+
         def initialize
             @wfid = nil
             @expressions = []
             @errors = {}
+            @launch_time = nil
         end
 
         #
@@ -806,7 +924,7 @@ module OpenWFE
 
                 set_wfid fexp.fei.parent_wfid
 
-                #@expressions << fexp
+                @launch_time = fexp.apply_time if fexp.fei.expid == '0'
 
                 exps = @expressions
                 @expressions = []

data/lib/openwfe/engine/file_persisted_engine.rb

@@ -62,7 +62,7 @@ module OpenWFE
             #
             def build_expression_storage ()
 
-                init_service(S_EXPRESSION_STORAGE, YamlFileExpressionStorage)
+                init_service S_EXPRESSION_STORAGE, YamlFileExpressionStorage
             end
 
             #
@@ -70,7 +70,7 @@ module OpenWFE
             #
             def build_error_journal ()
 
-                init_service(S_ERROR_JOURNAL, YamlErrorJournal)
+                init_service S_ERROR_JOURNAL, YamlErrorJournal
             end
     end
 
@@ -88,7 +88,7 @@ module OpenWFE
 
             def build_expression_storage ()
 
-                @application_context[:expression_cache_size] = 1000
+                @application_context[:expression_cache_size] ||= 1000
 
                 init_service(
                     S_EXPRESSION_STORAGE, 

data/lib/openwfe/expool/errorjournal.rb

@@ -42,6 +42,7 @@ require 'fileutils'
 
 require 'openwfe/service'
 require 'openwfe/omixins'
+require 'openwfe/rudefinitions'
 
 
 module OpenWFE
@@ -151,9 +152,9 @@ module OpenWFE
 
             super
 
-            get_expression_pool.add_observer(:error) do |event, *args|
+            get_expression_pool.add_observer :error do |event, *args|
                 #
-                # logs each error occuring in the expression pool
+                # logs each error occurring in the expression pool
                 
                 begin
 
@@ -163,6 +164,16 @@ module OpenWFE
                     lwarn { "*** process error : \n" + args.join("\n") }
                 end
             end
+
+            get_expression_pool.add_observer :terminate do |event, *args|
+                #
+                # removes error log when a process terminates
+
+                fei = args[0].fei
+
+                remove_error_log fei.wfid \
+                    if fei.is_in_parent_process?
+            end
         end
 
         #
@@ -174,6 +185,9 @@ module OpenWFE
             get_error_log(wfid).size > 0
         end
 
+        #--
+        #
+        # Commented out : has no real value
         #
         # Replays the given process instance (wfid or fei) at its last
         # recorded error.
@@ -185,32 +199,30 @@ module OpenWFE
         #
         # Will replay a given process instance at its 1 to last error.
         #
-        def replay_at_last_error (wfid, offset=0)
-
-            wfid = to_wfid(wfid)
-
-            log = get_error_log(wfid)
-
-            index = (-1 - offset)
-
-            error = log[index]
-
-            raise "no error for process '#{wfid}' at offset #{offset}" \
-                unless error
-
-            replay_at_error error
-        end
+        #def replay_at_last_error (wfid, offset=0)
+        #    wfid = to_wfid(wfid)
+        #    log = get_error_log(wfid)
+        #    index = (-1 - offset)
+        #    error = log[index]
+        #    raise "no error for process '#{wfid}' at offset #{offset}" \
+        #        unless error
+        #    replay_at_error error
+        #end
+        #++
 
+        #--
+        #
+        # Moved to the engine itself.
         #
         # Replays at a specific error (fetched with read_error_log()).
         #
-        def replay_at_error (error)
-
-            get_expression_pool.queue_work(
-                error.message,
-                error.fei,
-                error.workitem)
-        end
+        #def replay_at_error (error)
+        #    get_expression_pool.queue_work(
+        #        error.message,
+        #        error.fei,
+        #        error.workitem)
+        #end
+        #++
 
         #
         # A utility method : given a list of errors, will make sure that for 
@@ -276,8 +288,12 @@ module OpenWFE
         #
         # Removes a list of errors from the error journal.
         #
+        # The 'errors' parameter may be a single error (instead of an array).
+        #
         def remove_errors (wfid, errors)
 
+            errors = Array(errors)
+
             log = get_error_log wfid
 
             errors.each do |e|
@@ -313,6 +329,9 @@ module OpenWFE
         def initialize (service_name, application_context)
 
             require 'openwfe/storage/yamlcustom'
+                # making sure this file has been required at this point
+                # this yamlcustom thing prevents the whole OpenWFE ecosystem
+                # to get serialized :)
 
             super
 
@@ -373,7 +392,9 @@ module OpenWFE
         #
         def remove_error_log (wfid)
 
-            File.delete(get_path(wfid))
+            path = get_path wfid
+
+            File.delete(path) if File.exist?(path)
         end
 
         #
@@ -381,6 +402,8 @@ module OpenWFE
         #
         def remove_errors (wfid, errors)
 
+            errors = Array(errors)
+
             # load all errors
 
             log = get_error_log wfid