ruote 0.9.18

data/lib/openwfe/expressions/fe_sleep.rb

@@ -0,0 +1,166 @@
+#
+#--
+# Copyright (c) 2006-2008, 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'rufus/otime'
+require 'openwfe/expressions/time'
+
+
+module OpenWFE
+
+    #
+    # The 'sleep' expression expects one attribute, either 'for', either
+    # 'until'.
+    #
+    #     <sequence>
+    #         <sleep for="10m12s" />
+    #         <participant ref="alpha" />
+    #     </sequence>
+    #
+    # will wait for 10 minutes and 12 seconds before sending a workitem
+    # to participant 'alpha'.
+    #
+    # In a Ruby process definition, that might look like :
+    #
+    #     sleep :for => "3m"
+    #     sleep "3m"
+    #         #
+    #         # both meaning 'sleep for 3 minutes'
+    #
+    #     sleep :until => "Mon Dec 03 10:41:58 +0900 2007"
+    #         #
+    #         # sleep until the given point in time
+    #
+    # If the 'until' attribute points to a time in the past, the sleep
+    # expression will simply let the process resume.
+    # 
+    #
+    class SleepExpression < TimeExpression
+
+        names :sleep
+
+        attr_accessor :awakening_time
+
+        def apply (workitem)
+
+            sfor = lookup_string_attribute(:for, workitem)
+            suntil = lookup_string_attribute(:until, workitem)
+
+            sfor = fetch_text_content(workitem) \
+                if sfor == nil and suntil == nil
+
+            #ldebug { "apply() sfor is '#{sfor}'" }
+            #ldebug { "apply() suntil is '#{suntil}'" }
+
+            tuntil = nil
+
+            if suntil
+
+                tuntil = suntil
+
+            elsif sfor
+
+                tfor = Rufus::parse_time_string(sfor)
+                #ldebug { "apply() tfor is '#{tfor}'" }
+                tuntil = Time.new.to_f + tfor
+            end
+
+            #ldebug { "apply() tuntil is '#{tuntil}'" }
+
+            return reply_to_parent(workitem) \
+                if not tuntil
+
+            @awakening_time = tuntil
+            @applied_workitem = workitem.dup
+
+            determine_scheduler_tags
+
+            reschedule(get_scheduler)
+        end
+
+        #
+        # This is the method called by the Scheduler instance attached to
+        # the workflow engine when the 'sleep' of this expression is 
+        # over
+        #
+        def trigger (params)
+
+            ldebug do 
+                "trigger() #{@fei.to_debug_s} waking up (#{Time.new.to_f}) "+
+                "(scheduler #{get_scheduler.object_id})"
+            end
+
+            reply_to_parent(@applied_workitem)
+        end
+
+        #
+        # [Re]schedules this expression, effectively registering it within
+        # the scheduler.
+        # This method is called when the expression is applied and each
+        # time the owning engine restarts.
+        #
+        def reschedule (scheduler)
+
+            return unless @awakening_time
+
+            ldebug do 
+                "[re]schedule() " + 
+                "will sleep until '#{@awakening_time}' " +
+                "(#{Rufus::to_iso8601_date(@awakening_time)})"
+            end
+
+            @scheduler_job_id = "sleep_#{self.fei.to_s}"
+            
+            scheduler.schedule_at(
+                @awakening_time,
+                { 
+                    :schedulable => self, 
+                    :job_id => @scheduler_job_id,
+                    :tags => @scheduler_tags })
+
+            ldebug do 
+                "[re]schedule() @scheduler_job_id is '#{@scheduler_job_id}' "+
+                " (scheduler #{scheduler.object_id})"
+            end
+
+            store_itself
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_step.rb

@@ -0,0 +1,159 @@
+#
+#--
+# Copyright (c) 2008, 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/expressions/flowexpression'
+
+
+module OpenWFE
+
+    #
+    # This expression takes its root in this "trouble ticket blog post" :
+    #
+    #     http://jmettraux.wordpress.com/2008/01/04/the-trouble-ticket-process/
+    #
+    # In this post, the "step" was implemented directly in the OpenWFEru
+    # process definition language.
+    #
+    # It's been turned into an expression and it's not limited anymore to
+    # the concept "state is a participant, transition points to a subprocess",
+    # state can now point to a subprocess as well as to a participant, idem
+    # for a transition.
+    #
+    # In other words, this "step" expression allows you to write
+    # state-transition process definitions in OpenWFEru (the Ruote workflow
+    # engine). But don't abuse it. Classical OpenWFEru constructs can
+    # do most of the job.
+    #
+    # An interesting aspect of the "step" expression is that it can remove
+    # the need for some "if" expression constructs (well the fact
+    #
+    #     class ProcDef0 < OpenWFE::ProcessDefinition
+    #
+    #       sequence do
+    #
+    #         step "Alfred", :outcomes => [ 'blue_pen', 'red_pen' ]
+    #           # Alfred gets to choose between a blue pen and a red pen
+    #
+    #         participant "Bob"
+    #           # flow resumes with Bob in a classical way (sequence)
+    #       end
+    #
+    #       define "blue_pen" do
+    #         # ... Alfred buying a blue pen
+    #       end
+    #       define "red_pen" do
+    #         # ... Alfred buying a red pen
+    #       end
+    #     end
+    #
+    # in XML it would look like :
+    #
+    #     <sequence>
+    #        <step ref="Alfred" outcomes="blue_pen, red_pen" />
+    #        <participant ref="Bob" />
+    #     </sequence>
+    #
+    # You can specify a default outcome (else if the outcome doesn't correspond
+    # to a participant or a subprocess, the flow will cease) :
+    #
+    #     <step ref="toto" outcomes="left, right" default="right" />
+    #
+    # For some more discussions about Ruote and state-transition see
+    #
+    #     http://groups.google.com/group/openwferu-dev/t/16e713c1313cb2fa
+    #
+    class StepExpression < FlowExpression
+
+        names :step
+
+        attr_accessor :outcomes
+        attr_accessor :default
+
+
+        def apply (workitem)
+
+            step = lookup_attribute(:ref, workitem) || @children.first
+
+            # keeping track of outcomes and default as found at apply time
+
+            @outcomes = lookup_array_attribute(
+                :outcomes, workitem, :to_s => true)
+
+            @default = lookup_attribute(
+                :default, workitem, :to_s => true)
+
+            store_itself
+
+            # launching the 'step' itself
+
+            template = [
+                step.to_s, # expression name
+                lookup_attributes(workitem), # attributes
+                [], # children
+            ]
+
+            get_expression_pool.tlaunch_child(
+                self, template, 0, workitem, true) #, vars=nil
+        end
+
+        def reply (workitem)
+
+            outcome = workitem.fields.delete 'outcome'
+            outcome = outcome.to_s if outcome
+
+            #p [ outcome, @outcomes, @default ]
+
+            outcome = @default \
+                if @outcomes and (not @outcomes.include?(outcome))
+
+            return reply_to_parent(workitem) \
+                unless outcome
+
+            template = [
+                outcome.to_s, # expression name
+                {}, # attributes
+                [], # children
+            ]
+
+            get_expression_pool.substitute_and_apply self, template, workitem
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_subprocess.rb

@@ -0,0 +1,168 @@
+#
+#--
+# Copyright (c) 2006-2008, 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/utils'
+
+
+module OpenWFE
+
+    #
+    # This expression is used to launch/call a subprocess.
+    #
+    # For example :
+    #
+    #     <process-definition name="subtest0" revision="0">
+    #         <sequence>
+    #             <subprocess ref="sub0" a="A" b="B" c="C" />
+    #             <sub0 a="A" b="B" c="C" />
+    #         </sequence>
+    #     
+    #         <process-definition name="sub0">
+    #             <print>${a}${b}${c}</print>
+    #         </process-definition>
+    #     
+    #     </process-definition>
+    #
+    # It's totally OK to have URLs as referenced processes :
+    #
+    #     require 'openwfe/def'
+    #
+    #     class AnotherDefinition0 < OpenWFE::ProcessDefinition
+    #        sequence do
+    #            participant :ref => "toto"
+    #            subprocess :ref => "http://company.process.server/def0.rb"
+    #        end
+    #     end
+    #
+    # (but the engine parameter :remove_definitions_allowed must be set to true,
+    # as it's dangerous to fetch process definitions from other [untrusted]
+    # hosts)
+    #
+    # The 'subprocess' expression accepts a 'forget' attribute :
+    #
+    #     class AnotherDefinition1 < OpenWFE::ProcessDefinition
+    #         sequence do
+    #             subprocess :ref => "my_subprocess", :forget => true
+    #             participant :ref => "ringo"
+    #         end
+    #         process-definition :name => "my_subprocess" do
+    #             participant :ref => "fake steve jobs"
+    #         end
+    #     end
+    #
+    # The 'subprocess' expression accepts an 'if' (or 'unless') attribute :
+    #
+    #     subprocess :ref => "interview_process", :if => "${f:screened}"
+    #         # will trigger the subprocess only if the field screened
+    #         # contains the string 'true' or the boolean 'true'
+    #
+    #     interview_process :if => "${f:screened}"
+    #         # idem
+    #
+    #     interview_process :unless => "${f:has_had_problem_with_justice_?}"
+    #         # well...
+    #
+    class SubProcessRefExpression < FlowExpression
+        include ConditionMixin
+
+        names :subprocess
+
+        attr_accessor :subprocess_fei
+
+
+        def apply (workitem)
+
+            conditional = eval_condition(:if, workitem, :unless)
+
+            return reply_to_parent(workitem) \
+                if conditional == false
+
+            ref = lookup_ref workitem
+
+            raise "'subprocess' expression misses a 'ref', 'field-ref' or 'variable-ref' attribute" unless ref
+
+            template_uri = OpenWFE::parse_known_uri ref 
+
+            template = template_uri || lookup_variable(ref)
+
+            raise "did not find any subprocess named '#{ref}'" \
+                if not template
+
+            forget = lookup_boolean_attribute :forget, workitem
+
+            params = lookup_attributes workitem
+
+            text = fetch_text_content workitem, false
+            params["0"] = text if text
+
+            #puts
+            #puts " ... params are #{params.keys.join(', ')}"
+            #puts " ... values are #{params.values.join(', ')}"
+
+            #requester = if forget
+            #    @fei.workflow_instance_id
+            #else
+            #    @fei
+            #end
+            #sub_fei = get_expression_pool.launch_template(
+            #    requester, nil, get_next_sub_id, template, workitem, params)
+
+            sub_fei = get_expression_pool.launch_subprocess(
+                self, template, forget, workitem, params)
+
+            if forget
+                reply_to_parent workitem.dup
+            else
+                @subprocess_fei = sub_fei.dup
+                store_itself # to keep track of @subprocess_fei
+            end
+        end
+
+        #
+        # Takes care of cancelling the subprocess as well if any
+        #
+        def cancel
+
+            return nil unless @subprocess_fei
+            get_expression_pool.cancel @subprocess_fei
+        end
+    end
+
+end
+