openwferu 0.9.3 → 0.9.4

data/lib/openwfe/expressions/fe_time.rb

@@ -43,6 +43,8 @@ require 'openwfe/rudefinitions'
 require 'openwfe/utils'
 require 'openwfe/util/otime'
 require 'openwfe/util/scheduler'
+require 'openwfe/expressions/timeout'
+require 'openwfe/expressions/fe_condition'
 
 
 #
@@ -71,24 +73,31 @@ module OpenWFE
         def cancel ()
             synchronize do
 
-                ldebug { "cancel() @scheduler_job_id is #{@scheduler_job_id}" }
+                ldebug { "cancel()..." }
 
-                get_scheduler.unschedule(@scheduler_job_id) \
-                    if @scheduler_job_id
+                unschedule()
 
                 return super()
             end
         end
+
+        def unschedule ()
+
+            ldebug { "unschedule() @scheduler_job_id is #{@scheduler_job_id}" }
+
+            get_scheduler.unschedule(@scheduler_job_id) \
+                if @scheduler_job_id
+        end
     end
 
     #
     # The 'sleep' expression expects one attribute, either 'for', either
     # 'until'.
     #
-    #  <sequence>
-    #      <sleep for="10m12s" />
-    #      <participant ref="alpha" />
-    #  </sequence>
+    #     <sequence>
+    #         <sleep for="10m12s" />
+    #         <participant ref="alpha" />
+    #     </sequence>
     #
     # will wait for 10 minutes and 12 seconds before sending a workitem
     # to participant 'alpha'.
@@ -160,7 +169,7 @@ module OpenWFE
                 scheduler.schedule_at(@awakening_time, self, nil)
 
             ldebug do 
-                "[re]schedule() @scheduler_job_id is #{@scheduler_job_id} "+
+                "[re]schedule() @scheduler_job_id is '#{@scheduler_job_id}' "+
                 " (scheduler #{scheduler.object_id})"
             end
 
@@ -168,11 +177,23 @@ module OpenWFE
         end
     end
 
+    #
+    # Scheduling subprocesses for repeating execution
     #
     #     <cron tab="0 9-17 * * mon-fri" name="//reminder">
     #         <send-reminder/>
     #     </cron>
     #
+    # In this short process definition snippet, the subprocess "send-reminder"
+    # will get triggered once per hour (minute 0) from 0900 to 1700 and
+    # this, from monday to friday.
+    #
+    # The 'name' of the cron indicates also at which level the cron should
+    # be bound. A double slash means the cron is bound at engine level (and
+    # will continue until it is unbound, as long as the engine is up, if the
+    # engine is a persisted one, the cron will continue when the engine
+    # restarts).
+    #
     class CronExpression < TimeExpression
 
         attr_accessor \
@@ -225,6 +246,11 @@ module OpenWFE
             #
             # implemented in parent TimeExpression class
 
+        #
+        # This is the method called each time, the scheduler triggers
+        # this cron. The contained segment of process will get 
+        # executed.
+        #
         def trigger (params)
             #
             # launch raw child
@@ -244,11 +270,21 @@ module OpenWFE
             end
         end
 
+        #
+        # This method is called at the first schedule of this expression
+        # or each time the engine is restarted and this expression has
+        # to be rescheduled.
+        #
         def reschedule (scheduler)
 
-            @scheduler_id = get_scheduler.schedule(@tab, @name, self, nil)
+            @scheduler_job_id = @name.dup
+
+            @scheduler_job_id = "#{@fei.wfid}__#{@scheduler_job_id}" \
+                if not OpenWFE::starts_with(@name, "//")
 
-            ldebug { "reschedule() job id is #{@scheduler_id}" }
+            get_scheduler.schedule(@tab, @scheduler_job_id, self, nil)
+
+            ldebug { "reschedule() job id is '#{@scheduler_job_id}'" }
 
             #store_itself()
                 #
@@ -256,5 +292,143 @@ module OpenWFE
         end
     end
 
+    #
+    # The 'when' expression will trigger a consequence when a condition
+    # is met, like in
+    #
+    #     <when test="${variable:over} == true">
+    #         <participant ref="toto" />
+    #     </when>
+    #
+    # where the participant "toto" will receive a workitem when the (local)
+    # variable "over" has the value true.
+    #
+    class WhenExpression < TimeExpression
+        include ConditionMixin, TimeoutMixin
+
+        attr_accessor \
+            :frequency,
+            :consequence_triggered
+
+        DEFAULT_FREQUENCY = "20s"
+
+        def apply (workitem)
+
+            if @children.size < 1
+                reply_to_parent(workitem)
+                return
+            end
+
+            @applied_workitem = workitem.dup
+
+            @frequency = 
+                lookup_attribute(:frequency, workitem, DEFAULT_FREQUENCY)
+            @frequency = 
+                OpenWFE::parse_time_string(@frequency)
+
+            determine_timeout()
+
+            @consequence_triggered = false
+
+            trigger(nil)
+        end
+
+        def reply (workitem)
+
+            ldebug do 
+                "reply() @consequence_triggered is '#{@consequence_triggered}'"
+            end
+
+            if @consequence_triggered
+                reply_to_parent(workitem)
+                return
+            end
+
+            result = OpenWFE::get_result(workitem)
+
+            if result
+                apply_consequence(workitem)
+            else
+                reschedule(get_scheduler)
+            end
+        end
+
+        def cancel ()
+            to_unschedule()
+            super()
+        end
+
+        def trigger (params)
+
+            ldebug { "trigger() params is #{params}" }
+
+            if params == :do_timeout!
+                #
+                # do timeout...
+                #
+                reply_to_parent(@applied_workitem)
+                return
+            end
+
+            @scheduler_job_id = nil
+
+            evaluate_condition()
+        end
+
+        def reschedule (scheduler)
+
+            @scheduler_job_id = 
+                scheduler.schedule_in(@frequency, self, nil)
+
+            ldebug { "reschedule() @scheduler_job_id is #{@scheduler_job_id}" }
+
+            to_reschedule(scheduler)
+        end
+
+        def reply_to_parent (workitem)
+
+            unschedule()
+            unschedule_timeout()
+
+            super(workitem)
+        end
+
+        protected
+
+            def evaluate_condition
+
+                if @children.size > 1
+                    #
+                    # trigger the evaluation of the first (condition) child
+
+                    store_itself()
+
+                    get_expression_pool.launch_template(
+                        self, @children[0], @applied_workitem)
+                else
+                    #
+                    # eval the attribute condition immediately
+
+                    c = eval_condition(:test, @applied_workitem)
+
+                    OpenWFE::set_result(@applied_workitem, c)
+
+                    reply(@applied_workitem)
+                end
+            end
+
+            def apply_consequence (workitem)
+
+                @consequence_triggered = true
+
+                store_itself()
+
+                i = 1
+                i = 0 if @children.size == 1
+
+                get_expression_pool.apply(@children[i], workitem)
+            end
+    end
+
 end
 

data/lib/openwfe/expressions/fe_utils.rb

@@ -137,5 +137,15 @@ module OpenWFE
         workitem.attributes[FIELD_RESULT] = result
     end
 
+    #
+    # Just a shortcut (for consistency) of
+    #
+    #     workitem.attributes["__result__"]
+    #
+    def OpenWFE.get_result (workitem)
+
+        workitem.attributes[FIELD_RESULT]
+    end
+
 end
 

data/lib/openwfe/expressions/flowexpression.rb

@@ -254,7 +254,6 @@ module OpenWFE
         #
         def lookup_attribute (attname, workitem, default=nil)
 
-            #attname = attname.to_s
             attname = symbol_to_attname(attname) \
                 if attname.kind_of? Symbol
 
@@ -262,7 +261,10 @@ module OpenWFE
 
             text = @attributes[attname]
 
+            default = default.to_s if default
+
             return default if not text
+
             return OpenWFE::dosub(text, self, workitem)
         end
 

data/lib/openwfe/expressions/raw_prog.rb

@@ -369,7 +369,7 @@ module OpenWFE
         # with 'do' and 'redo' that are.
         #
         KEYWORDS = [
-            :if, :do, :redo, :undo, :print, :sleep, :loop, :break
+            :if, :do, :redo, :undo, :print, :sleep, :loop, :break, :when
         ]
 
         #

data/lib/openwfe/expressions/timeout.rb

@@ -59,35 +59,69 @@ module OpenWFE
 
         attr_accessor \
             :timeout_at,
-            :scheduler_job_id
+            :timeout_job_id
         
         def determine_timeout
 
+            #@timeout_at = nil
+            #@timeout_job_id = nil
+
             timeout = lookup_attribute(:timeout, @applied_workitem)
             return unless timeout
 
             timeout = OpenWFE::parse_time_string(timeout)
             @timeout_at = Time.new.to_f + timeout
-
-            reschedule(get_scheduler)
         end
 
+        #
+        # Overrides the parent method to make sure a potential
+        #
         def reschedule (scheduler)
+            to_reschedule(scheduler)
+        end
+
+        #
+        # Overrides the parent method to make sure a potential
+        # timeout schedules gets removed.
+        #
+        def reply_to_parent (workitem)
+            unschedule_timeout()
+            super(workitem)
+        end
+
+        protected
 
-            return unless @timeout_at
+            #
+            # prefixed with "to_" for easy mix in
+            #
+            def to_reschedule (scheduler)
 
-            @scheduler_job_id = 
-                scheduler.schedule_at(@timeout_at, self, nil)
+                return if @timeout_job_id
+                    #
+                    # already rescheduled
 
-            ldebug do 
-                "reschedule() will timeout at "+
-                "#{OpenWFE::to_iso8601_date(@timeout_at)}"
+                return unless @timeout_at
+                    #
+                    # no need for a timeout
+
+                @timeout_job_id = 
+                    scheduler.schedule_at(@timeout_at, self, :do_timeout!)
+
+                ldebug do 
+                    "to_reschedule() will timeout at "+
+                    "#{OpenWFE::to_iso8601_date(@timeout_at)}"
+                end
+
+                #store_itself()
+                    #
+                    # done in the including expression
             end
 
-            #store_itself()
-                #
-                # done in the including expression
-        end
+            def unschedule_timeout ()
+
+                get_scheduler.unschedule(@timeout_job_id) \
+                    if @timeout_job_id
+            end
     end
 
 end

data/lib/openwfe/flowexpressionid.rb

@@ -123,7 +123,12 @@ module OpenWFE
             fei = FlowExpressionId.new()
 
             ss = string.split(" ")
-            #puts "\n#{ss}"
+
+            #require 'pp'
+            #puts
+            #pp ss
+
+            ss = ss[1..-1] if ss[0] == "("
 
             fei.owfe_version = ss[1]
 
@@ -138,6 +143,9 @@ module OpenWFE
             fei.expression_name = ss[7]
             fei.expression_id = ss[8][0..-2]
 
+            fei.expression_id = fei.expression_id[0..-2] \
+                if fei.expression_id[-1, 1] == ")"
+
             return fei
         end
     end

data/lib/openwfe/participants/csvparticipant.rb

@@ -0,0 +1,127 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# $Id$
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/utils'
+require 'openwfe/util/dollar'
+require 'openwfe/util/csvtable'
+require 'openwfe/participants/participant'
+
+include OpenWFE
+
+
+module OpenWFE
+
+    #
+    # Using CSV files to transform workitems
+    # This concept is called "decision participant" in OpenWFEja, here
+    # it's simply called "csv participant".
+    #
+    # See CsvTable for an explanation of the core concept behind a
+    # CsvParticipant
+    #
+    # An example :
+    #     
+    #     class TestDefinition0 < ProcessDefinition
+    #         def make
+    #             process_definition :name => "test0", :revision => "0" do
+    #                 sequence do
+    #                     set :field => "weather", :value => "cloudy"
+    #                     set :field => "month", :value => "may"
+    #                     decision
+    #                     _print "${f:take_umbrella?}"
+    #                 end
+    #             end
+    #         end
+    #     end
+    #     
+    #     
+    #     csvParticipant = CsvParticipant.new(
+    #     """
+    #     in:weather, in:month, out:take_umbrella?
+    #     ,,
+    #     raining,    ,         yes
+    #     sunny,      ,         no
+    #     cloudy,     june,     yes
+    #     cloudy,     may,      yes
+    #     cloudy,     ,         no
+    #     """)
+    #     
+    #     engine.register_participant("decision", csvParticipant)
+    #     
+    #     # ...
+    #     
+    #     engine.launch(new OpenWFE::LaunchItem(TestDefinition0)
+    #
+    # Note that the CsvParticipant constructor also accepts a block.
+    #
+    class CsvParticipant
+        include LocalParticipant
+
+        attr_accessor \
+            :csv_table
+
+        #
+        # Builds a new CsvParticipant instance, csv_data or the block
+        # may contain a File instance, a String or an Array of Array of 
+        # String instances.
+        #
+        def initialize (csv_data=nil, &block)
+
+            super()
+
+            csv_data = block.call if block
+
+            @csv_table = CsvTable.new(csv_data)
+        end
+
+        #
+        # This is the method called by the engine (actually the 
+        # ParticipantExpression) when handling a workitem to this participant.
+        #
+        def consume (workitem)
+            fe = get_flow_expression(workitem)
+            workitem = @csv_table.transform_wi(fe, workitem)
+            reply_to_engine(workitem)
+        end
+    end
+
+end
+

data/lib/openwfe/participants/participant.rb

@@ -39,6 +39,7 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/logging'
 require 'openwfe/contextual'
 require 'openwfe/rudefinitions'
 

data/lib/openwfe/participants/participants.rb

@@ -80,21 +80,44 @@ module OpenWFE
     # After the block executes, the BlockParticipant immediately replies
     # to the engine.
     #
+    # You can pass a block with two arguments : flow_expression and workitem
+    # to BlockParticipant, it will automatically adapt.
+    #
+    #     engine.register_participant("the_boss") do |fexp, wi|
+    #         puts "the boss received a workitem from exp #{fexp.fei.to_s}"
+    #     end
+    #
+    # Having the FlowExpression instance at hand allows for advanced tricks,
+    # beware...
+    #
     class BlockParticipant 
         include LocalParticipant
 
-        def initialize (block)
-            @block = block
+        def initialize (block0=nil, &block1)
+            @block = if block1
+                block1
+            else
+                block0
+            end
+            raise "Missing a block parameter" \
+                unless @block
         end
 
         def consume (workitem)
 
-            @block.call workitem
+            if @block.arity == 1
+                @block.call workitem
+            elsif @block.arity > 1
+                @block.call get_flow_expression(workitem), workitem
+            else
+                @block.call
+            end
 
             reply_to_engine(workitem) \
                 if workitem.kind_of? InFlowWorkItem
             # else it's a cancel item
         end
     end
+
 end
 

data/lib/openwfe/rest/controlclient.rb

@@ -37,9 +37,9 @@
 # "hecho en Costa Rica"
 #
 
-require 'definitions'
-require 'restclient'
-require 'xmlcodec'
+require 'openwfe/rest/xmlcodec'
+require 'openwfe/rest/restclient'
+require 'openwfe/rest/definitions'
 
 
 module OpenWFE

data/lib/openwfe/rest/worklistclient.rb

@@ -37,9 +37,9 @@
 # "hecho en Costa Rica"
 #
 
-require 'definitions'
-require 'restclient'
-require 'xmlcodec'
+require 'openwfe/rest/xmlcodec'
+require 'openwfe/rest/definitions'
+require 'openwfe/rest/restclient'
 
 
 module OpenWFE
@@ -68,11 +68,9 @@ module OpenWFE
         end
 
         #
-        # A synonym for listStores()
+        # An alias for list_stores()
         #
-        def get_store_names ()
-            return listStores()
-        end
+        alias :get_store_names :list_stores
 
         #
         # Returns the headers of a given store.
@@ -161,7 +159,7 @@ module OpenWFE
 
                 #puts "  .id is #{h.flowExpressionId}"
 
-                return get_and_lock_workitem(storeName, h.flowExpressionId) \
+                return get_and_lock_workitem(storeName, h.flow_expression_id) \
                     if ok
             end
 

data/lib/openwfe/rest/xmlcodec.rb

@@ -40,10 +40,10 @@
 #require 'base64'
 require 'rexml/document'
 
-require 'definitions'
-require 'utils'
-require 'workitem'
-require 'flowexpressionid'
+require 'openwfe/utils'
+require 'openwfe/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/rest/definitions'
 
 
 module OpenWFE
@@ -215,7 +215,7 @@ module OpenWFE
                 return Integer(xmlElt.text) if xmlElt.name == E_INTEGER
                 return Integer(xmlElt.text) if xmlElt.name == E_LONG
                 return Float(xmlElt.text) if xmlElt.name == E_DOUBLE
-                return parseBoolean(xmlElt.text) if xmlElt.name == E_BOOLEAN
+                return parse_boolean(xmlElt.text) if xmlElt.name == E_BOOLEAN
 
                 return xmlElt if xmlElt.name == E_XML
 
@@ -224,7 +224,7 @@ module OpenWFE
                 #
                 # composite types
 
-                return decodeList(xmlElt) if xmlElt.name == E_LIST
+                return decode_list(xmlElt) if xmlElt.name == E_LIST
 
                 if xmlElt.name == E_SMAP or xmlElt.name == E_MAP