openwferu 0.9.10.653 → 0.9.11

data/lib/openwfe/expressions/expressionmap.rb

@@ -63,6 +63,8 @@ require 'openwfe/expressions/fe_do'
 require 'openwfe/expressions/fe_save'
 require 'openwfe/expressions/fe_filter_definition'
 require 'openwfe/expressions/fe_filter'
+require 'openwfe/expressions/fe_listen'
+require 'openwfe/expressions/fe_timeout'
 
 
 module OpenWFE
@@ -122,6 +124,7 @@ module OpenWFE
             register IteratorExpression
 
             register FqvExpression
+            register AttributeExpression
 
             register CancelProcessExpression
 
@@ -134,6 +137,10 @@ module OpenWFE
             register FilterDefinitionExpression
             register FilterExpression
 
+            register ListenExpression
+
+            register TimeoutExpression
+
             register Environment
                 #
                 # only used by get_expression_names()

data/lib/openwfe/expressions/fe_cancel.rb

@@ -85,7 +85,7 @@ module OpenWFE
 
         def apply (workitem)
 
-            conditional = eval_condition(:if, workitem)
+            conditional = eval_condition(:if, workitem, :unless)
                 #
                 # for example : <cancel-process if="${approved} == false"/>
 

data/lib/openwfe/expressions/fe_concurrence.rb

@@ -215,7 +215,7 @@ module OpenWFE
 
         names :concurrent_iterator
 
-        #attr_accessor :iterator
+        attr_accessor :template
 
         def apply (workitem)
 
@@ -224,7 +224,7 @@ module OpenWFE
                 return
             end
 
-            template = @children[0]
+            @template = @children[0]
 
             @children.clear
 
@@ -232,6 +232,11 @@ module OpenWFE
 
             iterator = Iterator.new(self, workitem)
 
+            if not iterator.has_next?
+                reply_to_parent workitem
+                return
+            end
+
             while iterator.has_next?
 
                 wi = workitem.dup
@@ -246,8 +251,11 @@ module OpenWFE
                 @children << rawexp.fei
             end
 
-            get_expression_pool.remove(template)
+            super
+        end
 
+        def reply_to_parent (workitem)
+            get_expression_pool.remove(@template)
             super
         end
 
@@ -369,7 +377,7 @@ module OpenWFE
             def do_reply (synchable, workitem)
 
                 synchable.ldebug do 
-                    "#{self.class}.do_reply() from"+
+                    "#{self.class}.do_reply() from " +
                     "#{workitem.last_expression_id.to_debug_s}"
                 end
 
@@ -398,7 +406,8 @@ module OpenWFE
                 #
                 # over-if
 
-                conditional = synchable.eval_condition("over-if", workitem)
+                conditional = 
+                    synchable.eval_condition("over-if", workitem, "over-unless")
 
                 if conditional
                     treat_remaining_children(synchable)

data/lib/openwfe/expressions/fe_cron.rb

@@ -168,7 +168,9 @@ module OpenWFE
             @scheduler_job_id = "#{@fei.wfid}__#{@scheduler_job_id}" \
                 if not OpenWFE::starts_with(@name, "//")
 
-            get_scheduler.schedule(@tab, @scheduler_job_id, self, nil)
+            get_scheduler.schedule(
+                @tab, 
+                { :schedulable => self, :job_id => @scheduler_job_id })
 
             ldebug { "reschedule() job id is '#{@scheduler_job_id}'" }
 

data/lib/openwfe/expressions/fe_cursor.rb

@@ -335,7 +335,7 @@ module OpenWFE
 
         def apply (workitem)
 
-            conditional = eval_condition(:if, workitem)
+            conditional = eval_condition(:if, workitem, :unless)
                 #
                 # for example : <break if="${approved} == true"/>
 

data/lib/openwfe/expressions/fe_fqv.rb

@@ -39,12 +39,15 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/rest/xmlcodec'
 require 'openwfe/expressions/flowexpression'
 
 
 #
 # 'f', 'q' and 'v' expressions
 #
+# 'a' as well
+#
 
 module OpenWFE
 
@@ -115,5 +118,60 @@ module OpenWFE
             end
     end
 
+    #
+    # The 'a' or 'attribute' expression. Directly describing some
+    # variable or list content in XML or in YAML.
+    #
+    #     _set :field => "list" do
+    #         _a """
+    #             <list>
+    #                 <string>a</string>
+    #                 <string>b</string>
+    #                 <string>c</string>
+    #             </list>
+    #         """
+    #     end
+    #
+    # or
+    #
+    #     _set :field => "list" do
+    #         _attribute """
+    #     --- 
+    #     - a
+    #     - b
+    #     - c
+    #         """
+    #      end
+    #
+    # Note that it's actually easier to write :
+    #
+    #     _set :filed => "list" do
+    #         reval "[ 'a', 'b', 'c' ]"
+    #     end
+    #
+    # but it's less secure.
+    #
+    class AttributeExpression < FlowExpression
+
+        names :a, :attribute
+
+        def apply workitem
+
+            text = fetch_text_content workitem
+            text = text.strip
+
+            result = if text[0, 3] == "---"
+                YAML.load text
+            else
+                d = REXML::Document.new text
+                XmlCodec::decode_attribute d.root
+            end
+
+            workitem.set_result(result) if result != nil
+
+            reply_to_parent workitem
+        end
+    end
+
 end
 

data/lib/openwfe/expressions/fe_if.rb

@@ -100,7 +100,7 @@ module OpenWFE
 
             workitem.unset_result
 
-            test = eval_condition(:test, workitem)
+            test = eval_condition(:test, workitem, :not)
 
             if @children.length < 1
                 workitem.set_result test if test

data/lib/openwfe/expressions/fe_iterator.rb

@@ -77,6 +77,11 @@ module OpenWFE
 
             @iterator = Iterator.new(self, workitem)
 
+            if not @iterator.has_next?
+                reply_to_parent workitem
+                return
+            end
+
             reply workitem
         end
 

data/lib/openwfe/expressions/fe_listen.rb

@@ -0,0 +1,224 @@
+#
+#--
+# 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: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/expressions/timeout'
+require 'openwfe/expressions/condition'
+require 'openwfe/expressions/flowexpression'
+
+
+module OpenWFE
+
+    #
+    # The "listen" expression can be viewed in two ways :
+    #
+    # 1)
+    # It's a hook into the participant map to intercept apply or reply
+    # operations on participants.
+    #
+    # 2)
+    # It allows OpenWFE[ru] to be a bit closer to the 'ideal' process-calculus
+    # world (http://en.wikipedia.org/wiki/Process_calculi)
+    #
+    # Anyway...
+    #
+    #     <listen to="alice">
+    #         <subprocess ref="notify_bob" />
+    #     </listen>
+    #
+    # Whenever a workitem is dispatched (applied) to the participant 
+    # named "alice", the subprocess named "notify_bob" is triggered (once).
+    #
+    #     listen :to => "^channel_.*", :upon => "reply" do
+    #         sequence do
+    #             participant :ref => "delta"
+    #             participant :ref => "echo"
+    #         end
+    #     end
+    #
+    # After the listen has been applied, the first workitem coming back from 
+    # a participant whose named starts with "channel_" will trigger a sequence
+    # with the participants 'delta' and 'echo'.
+    #
+    #     listen :to => "alpha", :where => "${f:color} == red" do
+    #         participant :ref => "echo"
+    #     end
+    #
+    # Will send a copy of the first workitem meant for participant "alpha" to 
+    # participant "echo" if this workitem's color field is set to 'red'.
+    #
+    #     listen :to => "alpha", :once => "false" do
+    #         send_email_to_stakeholders
+    #     end
+    #
+    # This is some kind of a server : each time a workitem is dispatched to
+    # participant "alpha", the subprocess (or participant) named 
+    # 'send_email_to_stakeholders') will receive a copy of that workitem.
+    # Use with care.
+    #
+    #     listen :to => "alpha", :once => "false", :timeout => "1M2w" do
+    #         send_email_to_stakeholders
+    #     end
+    #
+    # The 'listen' expression understands the 'timeout' attribute. It can thus
+    # be instructed to stop listening after a certain amount of time (here,
+    # after one month and two weeks).
+    #
+    class ListenExpression < FlowExpression
+        include TimeoutMixin, ConditionMixin
+
+        names :listen
+
+        attr_accessor \
+            :participant_regex, 
+            :once, 
+            :upon,
+            :call_count
+
+        def apply (workitem)
+
+            if @children.size < 1
+                reply_to_parent workitem
+                return
+            end
+
+            @participant_regex = lookup_attribute :to, workitem
+
+            raise "attribute 'to' is missing for expression 'listen'" \
+                unless @participant_regex
+
+            @once = lookup_boolean_attribute :once, workitem, true
+
+            ldebug { "apply() @once is #{@once}" }
+
+            @upon = lookup_attribute(:upon, workitem, "apply")[0, 5].downcase
+            @upon = if @upon == "reply"
+                :reply
+            else
+                :apply
+            end
+
+            @call_count = 0
+
+            determine_timeout()
+            reschedule(get_scheduler)
+
+            store_itself
+        end
+
+        def cancel
+            stop_observing
+        end
+
+        def reply_to_parent (workitem)
+            stop_observing
+            super
+        end
+
+        #
+        # Only called in case of timeout.
+        #
+        def trigger (params)
+            reply_to_parent workitem
+        end
+
+        #
+        # This is the method called when a 'listenable' workitem comes in
+        #
+        def call (channel, *args)
+            synchronize do
+
+                upon = args[0]
+
+                return if upon != @upon
+
+                workitem = args[1].dup
+
+                conditional = eval_condition(:where, workitem)
+                    #
+                    # note that the values if the incoming workitem (not the
+                    # workitem at apply time) are used for the evaluation
+                    # of the condition (if necessary).
+
+                return if conditional == false
+
+                return if @once and @call_count > 0
+
+                ldebug { "call() through for #{workitem.fei.to_s}" }
+
+                @call_count += 1
+                store_itself()
+
+                #ldebug { "call() @call_count is #{@call_count}" }
+
+                parent = if @once
+                    self
+                else
+                    nil
+                end
+
+                get_expression_pool.launch_template(
+                    parent, @call_count - 1, @children[0], workitem, nil)
+            end
+        end
+
+        #
+        # Registers for timeout and start observing the participant
+        # activity.
+        #
+        def reschedule (scheduler)
+
+            to_reschedule(scheduler)
+            start_observing
+        end
+
+        protected
+
+            def start_observing
+                get_participant_map.add_observer @participant_regex, self
+            end
+
+            def stop_observing
+                get_participant_map.remove_observer self
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_misc.rb

@@ -87,6 +87,32 @@ module OpenWFE
     # (<tt>engine.application_context[:ruby_eval_allowed] = true</tt>), this
     # expression will throw an exception at apply.
     #
+    # some examples :
+    #
+    #     <reval>
+    #         workitem.customer_name = "doug"
+    #         # or for short 
+    #         wi.customer_address = "midtown 21_21 design"
+    #     </reval>
+    #
+    # in a Ruby process definition :
+    #
+    #     sequence do
+    #         _set :field => "customer" do
+    #             reval """
+    #                 {
+    #                     :name => "Cheezburger",
+    #                     :age => 34,
+    #                     :comment => "I can haz ?",
+    #                     :timestamp => Time.now.to_s
+    #                 }
+    #             """
+    #         end
+    #     end
+    #
+    # Don't embed too much Ruby into your process definitions, it might
+    # hurt...
+    #
     class RevalExpression < FlowExpression
 
         names :reval
@@ -99,12 +125,8 @@ module OpenWFE
 
         def apply (workitem)
 
-            if @application_context[:ruby_eval_allowed] != true
-                #lwarn { "apply() :ruby_eval_allowed not set to true" }
-                #reply_to_parent(workitem)
-                #return
-                raise "evaluation of ruby code is not allowed"
-            end
+            raise "evaluation of ruby code is not allowed" \
+                if @application_context[:ruby_eval_allowed] != true
 
             escape = lookup_boolean_attribute('escape', workitem, false)
 
@@ -115,13 +137,14 @@ module OpenWFE
 
             code = code.to_s
 
-            #result = eval(code)
-            result = OpenWFE::eval_safely(code, SAFETY_LEVEL, binding())
+            wi = workitem
+
+            result = OpenWFE::eval_safely code, SAFETY_LEVEL, binding()
 
             workitem.set_result(result) \
                 if result != nil  # 'false' is a valid result
 
-            reply_to_parent(workitem)
+            reply_to_parent workitem
         end
     end
 

data/lib/openwfe/expressions/fe_participant.rb

@@ -82,7 +82,7 @@ module OpenWFE
     # The Participant expressions includes the FilterMixin and thus
     # understands and applies the "filter" attribute.
     #
-    # Since OpenWFE 0.9.9, the attributes of the participant expression are
+    # Since OpenWFEru 0.9.9, the attributes of the participant expression are
     # set inside a hash field named 'params' just available to the participant.
     # Thus in
     #
@@ -95,6 +95,17 @@ module OpenWFE
     # When the workitem gets back from the participant, the field 'params' is 
     # deleted.
     #
+    # The participant expressions include the TimeoutMixin, it means that
+    # a timeout can be stated :
+    #
+    #     <participant ref="toto" timeout="2w1d" />
+    #
+    # If after 2 weeks and 1 day (15 days), participant "toto" hasn't replied,
+    # the workitem will get cancelled and the flow will resume (behind the 
+    # scene, participant "toto", will receive a CancelItem instance bearing
+    # the same FlowExpressionId as the initial workitem and the participant
+    # implementation is responsible for the cancel application).
+    #
     class ParticipantExpression < FlowExpression
         include FilterMixin
         include TimeoutMixin
@@ -105,7 +116,6 @@ module OpenWFE
             :participant_name,
             :applied_workitem
 
-
         def apply (workitem)
 
             remove_timedout_flag workitem
@@ -117,8 +127,7 @@ module OpenWFE
             @participant_name = fetch_text_content workitem \
                 unless @participant_name
 
-            determine_timeout()
-            reschedule(get_scheduler)
+            schedule_timeout()
 
             filter_in workitem
 
@@ -127,10 +136,19 @@ module OpenWFE
             workitem.params = lookup_attributes workitem
 
             get_participant_map.dispatch @participant_name, workitem
+            get_participant_map.onotify @participant_name, :apply, workitem
+                #
+                # these two pmap calls were combined, but with the :reply
+                # notification in reply_to_parent() it feels more
+                # elegant like that
         end
 
         def reply_to_parent (workitem)
 
+            get_participant_map.onotify @participant_name, :reply, workitem
+                #
+                # for 'listen' expressions waiting for replies
+
             unschedule_timeout()
 
             workitem.attributes.delete "params"
@@ -147,6 +165,8 @@ module OpenWFE
         #
         def cancel
 
+            unschedule_timeout()
+
             wi = super()
 
             return wi unless @applied_workitem
@@ -157,7 +177,7 @@ module OpenWFE
             cancelitem = OpenWFE::CancelItem.new(@applied_workitem)
             get_participant_map.dispatch(@participant_name, cancelitem)
 
-            return nil
+            nil
         end
 
         #
@@ -170,7 +190,7 @@ module OpenWFE
 
             begin
 
-                @scheduler_job_id = nil
+                #@scheduler_job_id = nil
                     #
                     # so that cancel won't unschedule without need 
 

data/lib/openwfe/expressions/fe_sleep.rb

@@ -137,13 +137,11 @@ module OpenWFE
                 "(#{OpenWFE::to_iso8601_date(@awakening_time)})"
             end
 
-            if already_scheduled?
-                ldebug { "[re]schedule() already scheduled" }
-                return
-            end
-
-            @scheduler_job_id = 
-                scheduler.schedule_at(@awakening_time, self, nil)
+            @scheduler_job_id = "sleep_#{self.fei.to_s}"
+            
+            scheduler.schedule_at(
+                @awakening_time,
+                { :schedulable => self, :job_id => @scheduler_job_id })
 
             ldebug do 
                 "[re]schedule() @scheduler_job_id is '#{@scheduler_job_id}' "+