openwferu 0.9.6 → 0.9.7

data/lib/openwfe/expressions/environment.rb

@@ -53,6 +53,8 @@ module OpenWFE
     class Environment < FlowExpression
         include Schedulable
 
+        names :environment
+
         attr_accessor \
             :variables
 
@@ -66,13 +68,13 @@ module OpenWFE
 
         def [] (key)
 
-            if OpenWFE::starts_with(key, "//")
-                return get_expression_pool()\
-                    .get_engine_environment()[key[2..-1]]
-            end
-            if OpenWFE::starts_with(key, "/")
-                return get_root_environment()[key[1..-1]]
-            end
+            #if OpenWFE::starts_with(key, "//")
+            #    return get_expression_pool()\
+            #        .get_engine_environment()[key[2..-1]]
+            #end
+            #if OpenWFE::starts_with(key, "/")
+            #    return get_root_environment()[key[1..-1]]
+            #end
 
             value = @variables[key]
 
@@ -80,39 +82,44 @@ module OpenWFE
                 if @variables.has_key?(key) or is_engine_environment?
                 #if value or is_engine_environment?
 
-            return get_parent()[key] if @parent_id
+            return get_parent[key] if @parent_id
 
-            return get_expression_pool().fetch_engine_environment()[key]
+            return get_expression_pool.fetch_engine_environment[key]
         end
 
         def []= (key, value)
 
-            if OpenWFE::starts_with(key, "//")
-                key = key[2..-1]
-                get_expression_pool().fetch_engine_environment()[key] = value
-            elsif OpenWFE::starts_with(key, "/")
-                key = key[1..-1]
-                get_root_environment()[key] = value
-            else
-                @variables[key] = value
-                store_itself()
-
-                #ldebug { "[]= #{@fei.to_debug_s}  :  '#{key}' -> '#{value}'" }
-            end
+            #if OpenWFE::starts_with(key, "//")
+            #    key = key[2..-1]
+            #    get_expression_pool().fetch_engine_environment()[key] = value
+            #elsif OpenWFE::starts_with(key, "/")
+            #    key = key[1..-1]
+            #    get_root_environment()[key] = value
+            #else
+            #    @variables[key] = value
+            #    store_itself()
+            #    #ldebug { "[]= #{@fei.to_debug_s}  :  '#{key}' -> '#{value}'" }
+            #end
+
+            @variables[key] = value
+            store_itself()
         end
 
         def delete (key)
 
-            if OpenWFE::starts_with(key, "//")
-                key = key[2..-1]
-                get_expression_pool().fetch_engine_environment().delete(key)
-            elsif OpenWFE::starts_with(key, "/")
-                key = key[1..-1]
-                get_root_environment().delete(key)
-            else
-                @variables.delete(key)
-                store_itself()
-            end
+            #if OpenWFE::starts_with(key, "//")
+            #    key = key[2..-1]
+            #    get_expression_pool().fetch_engine_environment().delete(key)
+            #elsif OpenWFE::starts_with(key, "/")
+            #    key = key[1..-1]
+            #    get_root_environment().delete(key)
+            #else
+            #    @variables.delete(key)
+            #    store_itself()
+            #end
+
+            @variables.delete key
+            store_itself()
         end
 
         #
@@ -167,13 +174,16 @@ module OpenWFE
             store_itself()
         end
 
-        protected
+        #
+        # Returns the top environment for the process instance.
+        #
+        def get_root_environment ()
+
+            #ldebug { "get_root_environment()\n#{self}" }
 
-            def get_root_environment ()
-                #ldebug { "get_root_environment()\n#{self}" }
-                return self if not @parent_id
-                return get_parent().get_root_environment()
-            end
+            return self if not @parent_id
+            return get_parent().get_root_environment()
+        end
     end
 
 end

data/lib/openwfe/expressions/expressionmap.rb

@@ -39,7 +39,7 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/service'
+#require 'openwfe/util/model'
 require 'openwfe/expressions/environment'
 require 'openwfe/expressions/fe_define'
 require 'openwfe/expressions/fe_misc'
@@ -48,7 +48,9 @@ require 'openwfe/expressions/fe_sequence'
 require 'openwfe/expressions/fe_subprocess'
 require 'openwfe/expressions/fe_concurrence'
 require 'openwfe/expressions/fe_participant'
-require 'openwfe/expressions/fe_time'
+require 'openwfe/expressions/fe_sleep'
+require 'openwfe/expressions/fe_cron'
+require 'openwfe/expressions/fe_when'
 require 'openwfe/expressions/fe_losfor'
 require 'openwfe/expressions/fe_cursor'
 require 'openwfe/expressions/fe_iterator'
@@ -62,69 +64,52 @@ module OpenWFE
     # The mapping between expression names like 'sequence', 'participant', etc
     # and classes like 'ParticipantExpression', 'SequenceExpression', etc.
     #
-    class ExpressionMap < Service
+    class ExpressionMap
 
-        def initialize (serviceName, applicationContext)
-            super(serviceName, applicationContext)
+        def initialize ()
 
-            @map = {}
-            @sync_map = {}
+            super
 
-            @map["process-definition"] = DefineExpression
-            @map["workflow-definition"] = DefineExpression
-            @map["define"] = DefineExpression
+            @expressions = {}
 
-            @map["sequence"] = SequenceExpression
-            @map["participant"] = ParticipantExpression
+            register DefineExpression
 
-            @map["concurrence"] = ConcurrenceExpression
-            @sync_map["generic"] = GenericSyncExpression
+            register SequenceExpression
+            register ParticipantExpression
 
-            @map["subprocess"] = SubProcessRefExpression
+            register ConcurrenceExpression
+            register GenericSyncExpression
 
-            @map["set"] = SetValueExpression
-            @map["unset"] = UnsetValueExpression
+            register SubProcessRefExpression
 
-            @map["if"] = IfExpression
-            @map["equals"] = EqualsExpression
+            register SetValueExpression
+            register UnsetValueExpression
 
-            @map["sleep"] = SleepExpression
-            @map["cron"] = CronExpression
-            @map["when"] = WhenExpression
+            register IfExpression
+            register EqualsExpression
 
-            @map["reval"] = RevalExpression
-            @map["print"] = PrintExpression
+            register SleepExpression
+            register CronExpression
+            register WhenExpression
 
-            @map["lose"] = LoseExpression
-            @map["forget"] = ForgetExpression
+            register RevalExpression
+            register PrintExpression
 
-            @map["cursor"] = CursorExpression
-            @map["loop"] = LoopExpression
+            register LoseExpression
+            register ForgetExpression
 
-            @map["back"] = CursorCommandExpression
-            @map["skip"] = CursorCommandExpression
-            @map["break"] = CursorCommandExpression
-            @map["cancel"] = CursorCommandExpression
-            @map["rewind"] = CursorCommandExpression
-            @map["continue"] = CursorCommandExpression
+            register CursorExpression
+            register LoopExpression
 
-            @map["iterator"] = IteratorExpression
+            register CursorCommandExpression
 
-            @map["field"] = FqvExpression
-            @map["quote"] = FqvExpression
-            @map["variable"] = FqvExpression
-            @map["f"] = FqvExpression
-            @map["q"] = FqvExpression
-            @map["v"] = FqvExpression
+            register IteratorExpression
 
-            #@map["do"] = DoExpression
-            #@map["undo"] = UndoExpression
-            #@map["redo"] = RedoExpression
+            register FqvExpression
 
-            @map["cancel-process"] = CancelProcessExpression
-            #@map["cancel"] = CancelExpression
+            register CancelProcessExpression
 
-            @map["environment"] = Environment
+            register Environment
                 #
                 # only used by get_expression_names()
         end
@@ -133,31 +118,27 @@ module OpenWFE
         # Returns the expression class corresponding to the given 
         # expression name
         #
-        def get_class (expressionname)
-            return @map[expressionname]
+        def get_class (expression_name)
+
+            expression_name = OpenWFE::symbol_to_name(expression_name)
+
+            @expressions[expression_name]
         end
 
-        def get_sync_class (expressionname)
-            return @sync_map[expressionname]
+        def get_sync_class (expression_name)
+
+            get_class(expression_name)
         end
 
         #
         # Returns true if the given expression name ('sequence', 
         # 'process-definition', ...) is a DefineExpression.
         #
-        def is_definition? (expressionname)
-            c = get_class(expressionname)
-            return \
-                (c == OpenWFE::DefineExpression or
-                 c == OpenWFE::SetValueExpression)
-        end
+        def is_definition? (expression_name)
 
-        #
-        # Returns the list of expression names registered in this
-        # expression map.
-        #
-        def expression_names
-            return @map.keys
+            c = get_class(expression_name)
+
+            c == DefineExpression
         end
 
         #
@@ -165,12 +146,37 @@ module OpenWFE
         # from the given expression_class.
         #
         def get_expression_names (expression_class)
+
+            return expression_class.expression_names \
+                if expression_class.method_defined? :expression_names
+
             names = []
-            @map.each do |name, exp_class|
-                names << name \
-                    if exp_class.ancestors.include? expression_class
+            @expressions.each do |k, v|
+                names << k if v.ancestors.include? expression_class
+            end
+            names
+        end
+
+        #
+        # Registers an Expression class within this expression map.
+        # This method is usually never called from out of the ExpressionMap
+        # class, but, who knows, it could prove useful one day as a 'public'
+        # method.
+        #
+        def register (expression_class)
+
+            expression_class.expression_names.each do |name|
+                name = OpenWFE::to_dash(name)
+                @expressions[name] = expression_class
+            end
+        end
+
+        def to_s
+            s = ""
+            @expressions.keys.sort.each do |name|
+                s << "- '#{name}' -> '#{@expressions[name].to_s}'\n"
             end
-            return names
+            s
         end
     end
 

data/lib/openwfe/expressions/fe_cancel.rb

@@ -78,6 +78,8 @@ module OpenWFE
     class CancelProcessExpression < FlowExpression
         include ConditionMixin
 
+        names :cancel_process, :cancel_flow
+
         #
         # apply / reply
 

data/lib/openwfe/expressions/fe_concurrence.rb

@@ -130,6 +130,8 @@ module OpenWFE
     class ConcurrenceExpression < SequenceExpression
         include ConditionMixin
 
+        names :concurrence
+
         attr_accessor \
             :sync_expression
 
@@ -190,11 +192,20 @@ module OpenWFE
     # A base for sync expressions, currently empty.
     # That may change.
     #
-    class SyncExpression
+    class SyncExpression < ObjectWithMeta
 
         def initialize()
             super()
         end
+
+        def self.names (*exp_names)
+            exp_names = exp_names.collect do |n|
+                n.to_s
+            end
+            meta_def :expression_names do
+                exp_names
+            end
+        end
     end
 
     #
@@ -203,6 +214,8 @@ module OpenWFE
     #
     class GenericSyncExpression < SyncExpression
 
+        names :generic
+
         attr_accessor \
             :remaining_children,
             :count,

data/lib/openwfe/expressions/fe_cron.rb

@@ -0,0 +1,186 @@
+#
+#--
+# Copyright (c) 2006-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/rudefinitions'
+require 'openwfe/utils'
+require 'openwfe/util/otime'
+require 'openwfe/util/scheduler'
+require 'openwfe/expressions/fe_sleep'
+
+
+#
+# expressions like 'sleep' and 'cron'
+#
+
+module OpenWFE
+
+    #
+    # 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
+
+        names :cron
+
+        attr_accessor \
+            :raw_child, :tab, :name, :counter
+
+        def apply (workitem)
+
+            @counter = 0
+
+            if @children.size < 1
+                reply_to_parent(workitem)
+                return
+            end
+
+            @applied_workitem = workitem.dup
+            @applied_workitem.flow_expression_id = nil
+
+            @tab = lookup_attribute(:tab, workitem)
+            @name = lookup_attribute(:name, workitem)
+
+            @raw_child, _fei = get_expression_pool.fetch(@children[0])
+            @raw_child.parent_id = nil
+
+            clean_children()
+
+            @children = nil
+
+            #
+            # schedule self
+            
+            reschedule(get_scheduler)
+
+            #
+            # store self as a variable
+            # (have to do it after the reschedule, so that the schedule
+            # info is stored within the variable)
+
+            set_variable(@name, self) if @name
+
+            #
+            # resume flow
+            
+            reply_to_parent(workitem)
+        end
+
+        def reply (workitem)
+            # discard silently... should never get called though
+        end
+
+        #def cancel ()
+        #end
+            #
+            # 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
+
+            ldebug { "trigger() cron : #{@fei.to_debug_s}" }
+
+            @raw_child.application_context = @application_context
+
+            begin
+
+                get_expression_pool.launch_template(
+                    @fei.wfid, @counter, @raw_child, @applied_workitem.dup)
+
+                #
+                # update count and store self
+
+                @counter += 1
+
+                set_variable(@name, self) if @name
+
+            rescue
+                lerror do 
+                    "trigger() cron caught exception\n"+
+                    OpenWFE::exception_to_s($!)
+                end
+            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)
+
+            #return unless @applied_workitem
+
+            @scheduler_job_id = @name.dup
+
+            @scheduler_job_id = "#{@fei.wfid}__#{@scheduler_job_id}" \
+                if not OpenWFE::starts_with(@name, "//")
+
+            get_scheduler.schedule(@tab, @scheduler_job_id, self, nil)
+
+            ldebug { "reschedule() job id is '#{@scheduler_job_id}'" }
+
+            #store_itself()
+                #
+                # done by the containing environment itself
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_cursor.rb

@@ -69,6 +69,8 @@ module OpenWFE
     #
     class CursorExpression < WithTemplateExpression
 
+        names :cursor
+
         attr_accessor \
             :loop_id,
             :current_child_id,
@@ -213,6 +215,8 @@ module OpenWFE
     #
     class LoopExpression < CursorExpression
 
+        names :loop
+
         def is_loop
             return true
         end
@@ -224,6 +228,8 @@ module OpenWFE
     class CursorCommandExpression < FlowExpression
         include ConditionMixin
 
+        names :back, :skip, :continue, :break, :cancel, :rewind
+
         def apply (workitem)
 
             conditional = eval_condition(:if, workitem)

data/lib/openwfe/expressions/fe_define.rb

@@ -47,6 +47,8 @@ module OpenWFE
 
     class DefineExpression < FlowExpression
 
+        names :define, :process_definition, :workflow_definition
+
         def evaluate (workitem)
 
             #ldebug { "evaluate()  #{@fei.to_s}" }

data/lib/openwfe/expressions/fe_fqv.rb

@@ -54,6 +54,8 @@ module OpenWFE
     #
     class FqvExpression < FlowExpression
 
+        names :f, :q, :v, :field, :quote, :variable
+
         #
         # apply / reply
 

data/lib/openwfe/expressions/fe_iterator.rb

@@ -64,6 +64,8 @@ module OpenWFE
     #
     class IteratorExpression < WithTemplateExpression
 
+        names :iterator
+
         attr_accessor \
             :iterator
 

data/lib/openwfe/expressions/fe_losfor.rb

@@ -52,6 +52,8 @@ module OpenWFE
     #
     class LoseExpression < FlowExpression
 
+        names :lose
+
         def apply (workitem)
             get_expression_pool.apply(children[0], workitem) \
                 if (@children and @children.length > 0)
@@ -68,6 +70,8 @@ module OpenWFE
     #
     class ForgetExpression < FlowExpression
 
+        names :forget
+
         def apply (workitem)
 
             if (@children and @children.length > 0)

data/lib/openwfe/expressions/fe_misc.rb

@@ -48,6 +48,8 @@ module OpenWFE
 
     class PrintExpression < FlowExpression
 
+        names :print
+
         #
         # apply / reply
 
@@ -80,10 +82,16 @@ module OpenWFE
     # Evals some Ruby code contained within the process definition 
     # or within the workitem.
     # 
-    # The code is evaluated at a SAFE level of 1.
+    # The code is evaluated at a SAFE level of 3.
+    #
+    # If the :ruby_eval_allowed isn't set to true 
+    # (<tt>engine.application_context[:ruby_eval_allowed] = true</tt>), this
+    # expression will throw an exception at apply.
     #
     class RevalExpression < FlowExpression
 
+        names :reval
+
         #
         # See for an explanation on Ruby safety levels :
         # http://www.rubycentral.com/book/taint.html
@@ -92,6 +100,13 @@ 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
+
             escape = lookup_boolean_attribute('escape', workitem, false)
 
             code = OpenWFE::lookup_vf_attribute(self, workitem, 'code')