openwferu 0.9.13 → 0.9.14

data/examples/bigflow.rb

@@ -0,0 +1,19 @@
+#
+# just a sample
+#
+
+class BigFlow0 < OpenWFE::ProcessDefinition
+
+    sequence do
+        alpha
+        concurrence do
+            bravo
+            cursor do
+                alpha
+                bravo
+            end
+            alpha :activity => "brush teeth"
+        end
+        bravo
+    end
+end

data/examples/csv_weather.rb

@@ -0,0 +1,23 @@
+
+require 'rubygems'
+require 'openwfe/extras/util/csvtable'
+
+include OpenWFE::Extras
+
+$table = CsvTable.new("http://spreadsheets.google.com/pub?key=pCkopoeZwCNsMWOVeDjR1TQ&output=csv&gid=0")
+
+def decide (hash)
+
+    $table.transform hash
+
+    puts " weather : #{hash['weather']}, month : #{hash['month']}"
+    puts "     =>  take umbrella ? #{hash['take_umbrella?']}"
+    puts
+end
+
+puts
+
+decide({ "weather" => "raining", "month" => "december" })
+decide({ "weather" => "sunny", "month" => "december" })
+decide({ "weather" => "cloudy", "month" => "may" })
+

data/examples/engine_template.rb

@@ -201,6 +201,13 @@ end
     # the workitem to it over TCP
 
 
+engine.reschedule
+    #
+    # this method has to be called after all the participants have been
+    # added, it looks for temporal expressions (sleep, cron, ...) to 
+    # reschedule.
+
+
 #
 # === joining the engine's scheduler thread
 #

data/lib/openwfe/contextual.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"

data/lib/openwfe/engine/engine.rb

@@ -143,6 +143,7 @@ module OpenWFE
         # have been added.
         #
         def reschedule
+
             get_expression_pool.reschedule()
         end
 
@@ -158,6 +159,7 @@ module OpenWFE
         # This method can be useful in some scenarii though.
         #
         def pre_launch_check (launchitem)
+
             get_expression_pool.prepare_raw_expression(launchitem)
         end
 
@@ -174,31 +176,28 @@ module OpenWFE
         # Returns the FlowExpressionId instance of the expression at the
         # root of the newly launched process.
         #
-        def launch (launch_object)
-
-            launchitem = if launch_object.kind_of?(OpenWFE::LaunchItem)
-
-                launch_object
-
-            elsif launch_object.kind_of?(Class)
-
-                LaunchItem.new launch_object
-
-            elsif launch_object.kind_of? String
-
-                li = OpenWFE::LaunchItem.new
-
-                if launch_object[0, 1] == '<'
-                    li.workflowDefinitionUrl = "field:__definition"
-                    li['definition'] = launch_object
-                else
-                    li.workflowDefinitionUrl = launch_object
-                end
+        # Options for scheduled launches like :at, :in and :cron are accepted
+        # via the 'options' optional parameter.
+        # For example :
+        #
+        #     engine.launch(launch_item)
+        #         # will launch immediately
+        #
+        #     engine.launch(launch_item, :in => "1d20m")
+        #         # will launch in one day and twenty minutes
+        #
+        #     engine.launch(launch_item, :at => "Tue Sep 11 20:23:02 +0900 2007")
+        #         # will launch at that point in time
+        #
+        #     engine.launch(launch_item, :cron => "0 5 * * *")
+        #         # will launch that same process every day,
+        #         # five minutes after midnight (see "man 5 crontab")
+        #
+        def launch (launch_object, options={})
 
-                li
-            end
+            launchitem = extract_launchitem launch_object
 
-            fei = get_expression_pool.launch launchitem
+            fei = get_expression_pool.launch launchitem, options
 
             fei.dup
                 #
@@ -231,6 +230,9 @@ module OpenWFE
             end
         end
 
+        alias :forward :reply
+        alias :proceed :reply
+
         #
         # Registers a participant in this [embedded] engine.
         # This method is a shortcut to the ParticipantMap method
@@ -422,18 +424,18 @@ module OpenWFE
             t = Thread.new { Thread.stop }
 
             to = get_expression_pool.add_observer(:terminate) do |c, fe, wi|
-                t.wakeup if fe.fei.workflow_instance_id == wfid
+                t.wakeup if (fe.fei.workflow_instance_id == wfid and t.alive?)
             end
-            te = get_expression_pool.add_observer(:error) do |c, fei, m, wi, se|
-                t.wakeup if fei.parent_wfid == wfid
+            te = get_expression_pool.add_observer(:error) do |c, fei, m, i, e|
+                t.wakeup if (fei.parent_wfid == wfid and t.alive?)
             end
 
-            ldebug { "wait_for() #{wfid}" }
+            linfo { "wait_for() #{wfid}" }
 
             t.join
 
-            get_expression_pool.remove_observer to, :terminate
-            get_expression_pool.remove_observer te, :error
+            get_expression_pool.remove_observer(to, :terminate)
+            get_expression_pool.remove_observer(te, :error)
                 #
                 # it would work as well without specifying the channel,
                 # but it's thus a little bit faster
@@ -448,7 +450,7 @@ module OpenWFE
         # located (waiting certainly) and the errors the process currently
         # has (hopefully none).
         #
-        def get_process_status (wfid=nil)
+        def list_process_status (wfid=nil)
 
             wfid = to_wfid(wfid) if wfid
 
@@ -475,6 +477,21 @@ module OpenWFE
             result
         end
 
+        #
+        # list_process_status() will be deprecated at release 1.0.0
+        #
+        alias :get_process_status :list_process_status
+
+        #
+        # Returns the process status of one given process instance.
+        #
+        def process_status (wfid)
+
+            wfid = to_wfid(wfid)
+
+            list_process_status(wfid).values[0]
+        end
+
         #--
         # METHODS FROM THE EXPRESSION POOL
         #
@@ -546,6 +563,48 @@ module OpenWFE
             get_expression_pool.forget(exp_or_fei)
         end
 
+        #
+        # Pauses a process (sets its /__paused__ variable to true).
+        #
+        def pause_process (wfid)
+
+            get_expression_pool.pause_process(wfid)
+        end
+
+        #
+        # Restarts a process : removes its 'paused' flag (variable) and makes
+        # sure to 'replay' events (replies) that came for it while it was
+        # in pause.
+        #
+        def resume_process (wfid)
+
+            get_expression_pool.resume_process(wfid)
+        end
+
+        #
+        # Looks up a process variable in a process.
+        # If fei_or_wfid is not given, will simply look in the 
+        # 'engine environment' (where the top level variables '//' do reside).
+        #
+        def lookup_variable (var_name, fei_or_wfid=nil)
+
+            return get_expression_pool.fetch_engine_environment[var_name] \
+                unless fei_or_wfid
+
+            exp = if fei_or_wfid.is_a?(String)
+
+                get_expression_pool.fetch_root(fei_or_wfid)
+
+            else
+
+                get_expression_pool.fetch_expression(fei_or_wfid)
+            end
+
+            raise "no expression found for '#{fei_or_wfid.to_s}'" unless exp
+
+            exp.lookup_variable var_name
+        end
+
         protected
 
             #--
@@ -633,6 +692,38 @@ module OpenWFE
                 init_service(S_ERROR_JOURNAL, InMemoryErrorJournal)
             end
 
+            #
+            # Turns the raw launch request info into a LaunchItem instance.
+            #
+            def extract_launchitem (launch_object)
+
+                if launch_object.kind_of?(OpenWFE::LaunchItem)
+
+                    launch_object
+
+                elsif launch_object.kind_of?(Class)
+
+                    LaunchItem.new launch_object
+
+                elsif launch_object.kind_of?(String)
+
+                    li = OpenWFE::LaunchItem.new
+
+                    #if launch_object[0, 1] == '<' or launch_object.match("\n")
+                    if launch_object[0, 1] == '<' or launch_object.index("\n")
+
+                        li.workflow_definition_url = "field:__definition"
+                        li['__definition'] = launch_object
+
+                    else
+
+                        li.workflow_definition_url = launch_object
+                    end
+
+                    li
+                end
+            end
+
     end
 
     #
@@ -659,7 +750,7 @@ module OpenWFE
         attr_reader :expressions
 
         #
-        # a hash whose values are ProcessError instances, the keys
+        # A hash whose values are ProcessError instances, the keys
         # are FlowExpressionId instances (fei) (identifying the expressions
         # that are concerned with the error)
         #
@@ -671,6 +762,15 @@ module OpenWFE
             @errors = {}
         end
 
+        #
+        # Returns true if the process is in pause.
+        #
+        def paused?
+
+            exp = @expressions[0]
+            exp != nil and exp.paused?
+        end
+
         #
         # this method is used by Engine.get_process_status() when
         # it prepares its results.
@@ -695,7 +795,8 @@ module OpenWFE
             @expressions.each do |fexp|
                 s << "         #{fexp.fei}\n"
             end
-            s << "      errors : #{@errors.size}"
+            s << "      errors : #{@errors.size}\n"
+            s << "      paused : #{paused?}"
             s
         end
 
@@ -751,8 +852,8 @@ module OpenWFE
     def pretty_print_process_status (ps)
 
         s = ""
-        s << "process_id          | name              | rev     | brn | err\n"
-        s << "--------------------+-------------------+---------+-----+-----\n"
+        s << "process_id          | name              | rev     | brn | err | paused? \n"
+        s << "--------------------+-------------------+---------+-----+-----+---------\n"
 
         ps.keys.sort.each do |wfid|
 
@@ -769,6 +870,8 @@ module OpenWFE
             s << "%3s" % status.expressions.size.to_s[0, 3]
             s << " | "
             s << "%3s" % status.errors.size.to_s[0, 3]
+            s << " | "
+            s << "%5s" % status.paused?.to_s
             s << "\n"
         end
         s

data/lib/openwfe/engine/file_persisted_engine.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -64,8 +62,6 @@ module OpenWFE
             #
             def build_expression_storage ()
 
-                @application_context[:work_directory] = "./work"
-
                 init_service(S_EXPRESSION_STORAGE, YamlFileExpressionStorage)
             end
 
@@ -93,7 +89,6 @@ module OpenWFE
             def build_expression_storage ()
 
                 @application_context[:expression_cache_size] = 1000
-                @application_context[:work_directory] = "./work"
 
                 init_service(
                     S_EXPRESSION_STORAGE, 

data/lib/openwfe/exceptions.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: workitem.rb 3555 2006-11-13 00:47:53Z jmettraux $
-#
 
 #
 # Made in Japan

data/lib/openwfe/expool/errorjournal.rb

@@ -80,10 +80,15 @@ module OpenWFE
         #
         attr_reader :stacktrace
 
+        #
+        # The error class (String) of the top level error
+        #
+        attr_reader :error_class
+
         def initialize (*args)
 
             @date = Time.new
-            @fei, @message, @workitem, @stacktrace = args
+            @fei, @message, @workitem, @error_class, @stacktrace = args
         end
 
         #
@@ -103,13 +108,34 @@ module OpenWFE
         def to_s
             s = ""
             s << "-- #{self.class.name} --\n"
-            s << "     date :       #{@date}\n"
-            s << "     fei :        #{@fei}\n"
-            s << "     message :    #{@message}\n"
-            s << "     workitem :   ...\n"
-            s << "     stacktrace : #{@stacktrace[0, 80]}\n"
+            s << "     date :        #{@date}\n"
+            s << "     fei :         #{@fei}\n"
+            s << "     message :     #{@message}\n"
+            s << "     workitem :    ...\n"
+            s << "     error_class : #{@error_class}\n"
+            s << "     stacktrace :  #{@stacktrace[0, 80]}\n"
             s
         end
+
+        #
+        # Returns a hash
+        #
+        def hash
+            to_s.hash
+                #
+                # a bit costly but as it's only used by resume_process()...
+        end
+
+        #
+        # Returns true if the other instance is a ProcessError and is the
+        # same error as this one.
+        #
+        def == (other)
+            return false unless other.is_a?(ProcessError)
+            return to_s == other.to_s
+                #
+                # a bit costly but as it's only used by resume_process()...
+        end
     end
 
     #
@@ -129,7 +155,13 @@ module OpenWFE
                 #
                 # logs each error occuring in the expression pool
                 
-                record_error(ProcessError.new(*args))
+                begin
+
+                    record_error(ProcessError.new(*args))
+
+                rescue Exception => e
+                    lwarn { "*** process error : \n" + args.join("\n") }
+                end
             end
         end
 
@@ -241,6 +273,18 @@ module OpenWFE
             @per_processes.delete(wfid)
         end
 
+        #
+        # Removes a list of errors from the error journal.
+        #
+        def remove_errors (wfid, errors)
+
+            log = get_error_log wfid
+
+            errors.each do |e|
+                log.delete e
+            end
+        end
+
         #
         # Reads all the error logs currently stored.
         # Returns a hash wfid --> error list.
@@ -332,6 +376,38 @@ module OpenWFE
             File.delete(get_path(wfid))
         end
 
+        #
+        # Removes a list of errors from this error journal.
+        #
+        def remove_errors (wfid, errors)
+
+            # load all errors
+
+            log = get_error_log wfid
+
+            # remove the given errors
+
+            errors.each do |e|
+                log.delete e
+            end
+
+            # rewrite error file
+
+            path = get_path wfid
+
+            if log.size > 0
+
+                File.open(path, "w") do |f|
+                    log.each do |e|
+                        f.puts e.to_yaml
+                    end
+                end
+            else
+
+                File.delete path
+            end
+        end
+
         #
         # Reads all the error logs currently stored.
         # Returns a hash wfid --> error list.