openwferu 0.9.1 → 0.9.2

data/lib/openwfe/expool/yamlexpstorage.rb

@@ -0,0 +1,127 @@
+#
+#--
+# Copyright (c) 2006-2007, Nicolas Modryzk and 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"
+#
+# Nicolas Modrzyk at openwfe.org
+# John Mettraux at openwfe.org
+#
+
+require 'find'
+
+require 'openwfe/storage/yamlfilestorage'
+
+require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/raw_xml'
+    #
+    # making sure classes in those files are loaded
+    # before their yaml persistence is tuned
+    # (else the reopening of the class is interpreted as
+    # a definition of the class...)
+
+
+module OpenWFE
+    
+    #
+    # reopening some classes in order to facilitate their
+    # yaml serialization
+    #
+    
+    # opening for tuning yaml persistence
+    #
+    class FlowExpression
+        def to_yaml_properties
+            l = super()
+            l.delete("@application_context")
+            return l
+        end
+    end
+    
+    # opening for tuning yaml persistence
+    #
+    class XmlRawExpression
+        def to_yaml_properties
+            l = super()
+            l.delete("@raw_representation")
+            return l
+        end
+    end
+    
+    #
+    # yaml expression storage
+    #
+    class YamlFileExpressionStorage  < YamlFileStorage
+        
+        def initialize (service_name, application_context)
+            path = if (@application_context) 
+                @application_context[:file_expression_storage_path] 
+            else 
+                DEFAULT_FILE_STORAGE_PATH 
+            end
+            super(service_name, application_context, path + "/expool")
+        end
+        
+        def compute_file_path (fei)
+            
+            return @basepath + "/engine_env.yaml" \
+                if fei.workflow_instance_id == "0"
+                
+            wfid = fei.parent_workflow_instance_id
+            
+            @basepath + "/" +
+            wfid[-1, 1] + "/" +
+            wfid[-2, 1] + "/" +
+            wfid + "/" +
+            fei.workflow_instance_id + "__" +
+            fei.expression_id + "_" + 
+            fei.expression_name + ".yaml"
+        end        
+
+        def to_s
+            s = "\n\n==== #{self.class} ===="
+            s << "\n"
+            Find.find(@basepath) do |path|
+                if not File.stat(path).directory?
+                    s << path
+                    s << "\n"
+                end
+            end
+            s << "==== . ====\n"
+            return s
+        end
+        
+    end
+end

data/lib/{ru → openwfe/expressions}/environment.rb

@@ -1,6 +1,6 @@
 #
-#<tt>
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+#--
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -28,7 +28,7 @@
 # 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.
-#</tt>
+#++
 #
 # $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
 #
@@ -39,11 +39,11 @@
 # John Mettraux at openwfe.org
 #
 
-require 'ru/flowexpression'
-require 'ru/ruutils'
+require 'openwfe/utils'
+require 'openwfe/expressions/flowexpression'
 
 
-module OpenWFEru
+module OpenWFE
 
     #
     # An environment is a store for variables.
@@ -63,11 +63,12 @@ module OpenWFEru
         end
 
         def [] (key)
-            if OpenWFEru::starts_with(key, "//")
+
+            if OpenWFE::starts_with(key, "//")
                 return get_expression_pool()\
                     .get_engine_environment()[key[2..-1]]
             end
-            if OpenWFEru::starts_with(key, "/")
+            if OpenWFE::starts_with(key, "/")
                 return get_root_environment()[key[1..-1]]
             end
 
@@ -77,35 +78,38 @@ module OpenWFEru
                 if @variables.has_key?(key) or is_engine_environment?
                 #if value or is_engine_environment?
 
-            return get_parent()[key] if @parentId
+            return get_parent()[key] if @parent_id
 
             return get_expression_pool().fetch_engine_environment()[key]
         end
 
         def []= (key, value)
-            if OpenWFEru::starts_with(key, "//")
+
+            if OpenWFE::starts_with(key, "//")
                 key = key[2..-1]
                 get_expression_pool().fetch_engine_environment()[key] = value
-            elsif OpenWFEru::starts_with(key, "/")
+            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}'" }
+                #ldebug { "[]= #{@fei.to_debug_s}  :  '#{key}' -> '#{value}'" }
             end
         end
 
         def delete (key)
-            if OpenWFEru::starts_with(key, "//")
+
+            if OpenWFE::starts_with(key, "//")
                 key = key[2..-1]
                 get_expression_pool().fetch_engine_environment().delete(key)
-            elsif OpenWFEru::starts_with(key, "/")
+            elsif OpenWFE::starts_with(key, "/")
                 key = key[1..-1]
                 get_root_environment().delete(key)
             else
                 @variables.delete(key)
+                store_itself()
             end
         end
 
@@ -116,6 +120,7 @@ module OpenWFEru
         # variables in this environment.
         #
         def unbind ()
+
             @variables.each do |key, value|
                 get_expression_pool().remove(value) \
                     if value.kind_of? OpenWFE::FlowExpressionId

data/lib/{ru → openwfe/expressions}/expressionmap.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -39,18 +39,22 @@
 # John Mettraux at openwfe.org
 #
 
-require 'ru/service'
-require 'ru/fe_define'
-require 'ru/fe_base'
-require 'ru/fe_misc'
-require 'ru/fe_value'
-require 'ru/fe_subprocess'
-require 'ru/fe_concurrence'
-require 'ru/fe_participant'
-require 'ru/fe_time'
+require 'openwfe/service'
+require 'openwfe/expressions/fe_define'
+require 'openwfe/expressions/fe_misc'
+require 'openwfe/expressions/fe_value'
+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_losfor'
+require 'openwfe/expressions/fe_cursor'
+require 'openwfe/expressions/fe_iterator'
+require 'openwfe/expressions/fe_fqv'
 
 
-module OpenWFEru
+module OpenWFE
 
     #
     # The mapping between expression names like 'sequence', 'participant', etc
@@ -58,15 +62,11 @@ module OpenWFEru
     #
     class ExpressionMap < Service
 
-        #attr_accessor \
-        #    :applicationContext
-
-        SYNC_PREFIX = "sync::"
-
         def initialize (serviceName, applicationContext)
             super(serviceName, applicationContext)
 
             @map = {}
+            @sync_map = {}
 
             @map["process-definition"] = DefineExpression
             @map["workflow-definition"] = DefineExpression
@@ -76,9 +76,9 @@ module OpenWFEru
             @map["participant"] = ParticipantExpression
 
             @map["concurrence"] = ConcurrenceExpression
-            @map["#{SYNC_PREFIX}generic"] = GenericSyncExpression
+            @sync_map["generic"] = GenericSyncExpression
 
-            @map["subprocess"] = SubprocessRefExpression
+            @map["subprocess"] = SubProcessRefExpression
 
             @map["set"] = SetValueExpression
             @map["unset"] = UnsetValueExpression
@@ -94,6 +94,25 @@ module OpenWFEru
 
             @map["lose"] = LoseExpression
             @map["forget"] = ForgetExpression
+
+            @map["cursor"] = CursorExpression
+            @map["loop"] = LoopExpression
+
+            @map["back"] = CursorCommandExpression
+            @map["skip"] = CursorCommandExpression
+            @map["break"] = CursorCommandExpression
+            @map["cancel"] = CursorCommandExpression
+            @map["rewind"] = CursorCommandExpression
+            @map["continue"] = CursorCommandExpression
+
+            @map["iterator"] = IteratorExpression
+
+            @map["field"] = FqvExpression
+            @map["quote"] = FqvExpression
+            @map["variable"] = FqvExpression
+            @map["f"] = FqvExpression
+            @map["q"] = FqvExpression
+            @map["v"] = FqvExpression
         end
 
         #
@@ -105,7 +124,7 @@ module OpenWFEru
         end
 
         def get_sync_class (expressionname)
-            return @map["#{SYNC_PREFIX}#{expressionname}"]
+            return @sync_map[expressionname]
         end
 
         #
@@ -115,8 +134,16 @@ module OpenWFEru
         def is_definition? (expressionname)
             c = get_class(expressionname)
             return \
-                (c == OpenWFEru::DefineExpression or
-                 c == OpenWFEru::SetValueExpression)
+                (c == OpenWFE::DefineExpression or
+                 c == OpenWFE::SetValueExpression)
+        end
+
+        #
+        # Returns the list of expression names registered in this
+        # expression map.
+        #
+        def expression_names
+            return @map.keys
         end
 
     end

data/lib/{ru → openwfe/expressions}/fe_concurrence.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -39,17 +39,16 @@
 # John Mettraux at openwfe.org
 #
 
-require 'monitor'
-require 'ru/flowexpression'
-require 'ru/rudefinitions'
-require 'ru/ruutils'
+require 'openwfe/utils'
+require 'openwfe/rudefinitions'
+require 'openwfe/expressions/flowexpression'
 
 
 #
 # base expressions like 'sequence' and 'concurrence'
 #
 
-module OpenWFEru
+module OpenWFE
 
     class ConcurrenceExpression < SequenceExpression
 
@@ -64,49 +63,74 @@ module OpenWFEru
             @sync_expression = \
                 get_expression_map().get_sync_class(sync).new(@attributes)
 
-            #threads = []
-
             @children.each do |child|
                 @sync_expression.add_child(child)
             end
 
+            store_itself()
+
+            concurrence = self
+
             @children.each do |child|
-                t = Thread.new do
+                Thread.new do
                     begin
-                        get_expression_pool().apply(child, workitem.dup)
+                        concurrence.synchronize do
+                            get_expression_pool().apply(child, workitem.dup)
+                        end
                     rescue Exception => e
                         lwarn do 
-                            "apply() caught exception in concurrent child\n" + 
-                            OpenWFEru::exception_to_s(e)
+                            "apply() " +
+                            "caught exception in concurrent child  " + 
+                            child.to_debug_s + "\n" + 
+                            OpenWFE::exception_to_s(e)
                         end
                     end
                 end
+            end
+
+            #@sync_expression.ready(self)
+                #
+                # this is insufficient, have to do that :
 
-                #threads << t
+            synchronize do
+                #
+                # Making sure the freshest version of the concurrence
+                # expression is used.
+                # This is especially important when using pure persistence.
+                #
+                reloaded_self, _fei = get_expression_pool.fetch(@fei)
+                reloaded_self.sync_expression.ready(reloaded_self)
             end
         end
 
         def reply (workitem)
-            done = @sync_expression.reply(self, workitem)
-            reply_to_parent(done) if done
+            @sync_expression.reply(self, workitem)
         end
     end
 
+    #
+    # A base for sync expressions, currently empty.
+    # That may change.
+    #
     class SyncExpression
-        include Logging, MonitorMixin
 
-        #def initialize()
-        #    super()
-        #end
+        def initialize()
+            super()
+        end
     end
 
+    #
+    # The classical OpenWFE sync expression.
+    # Used by 'concurrence' and 'concurrent-iterator'
+    #
     class GenericSyncExpression < SyncExpression
 
         attr_accessor \
             :remaining_children,
             :count,
             :reply_count,
-            :cancel_remaining
+            :cancel_remaining,
+            :unready_queue
 
         def initialize (attributes)
 
@@ -117,6 +141,31 @@ module OpenWFEru
 
             @count = determine_count(attributes)
             @cancel_remaining = determine_remaining(attributes)
+
+            @unready_queue = []
+        end
+
+        #
+        # when all the children got applied concurrently, the concurrence
+        # calls this method to notify the sync expression that replies
+        # can be processed
+        #
+        def ready (synchable)
+            synchable.synchronize do
+
+                synchable.ldebug do 
+                    "ready() called by  #{synchable.fei.to_debug_s}  " +
+                    "#{@unready_queue.length} wi waiting"
+                end
+
+                queue = @unready_queue
+                @unready_queue = nil
+                synchable.store_itself()
+
+                queue.each do |workitem|
+                    do_reply(synchable, workitem)
+                end
+            end
         end
 
         def add_child (child)
@@ -124,47 +173,74 @@ module OpenWFEru
         end
 
         def reply (synchable, workitem)
-            synchronize do
+            synchable.synchronize do
+
+                if @unready_queue
+
+                    @unready_queue << workitem
+
+                    synchable.store_itself()
+
+                    synchable.ldebug do 
+                        "#{self.class}.reply() "+
+                        "#{@unready_queue.length} wi waiting..."
+                    end
 
-                @application_context = synchable.application_context
-                    #
-                    # ldebug uses the application context
+                else
+                    do_reply(synchable, workitem)
+                end
+            end
+        end
+
+        protected
 
-                ldebug { "reply()  #{workitem.lastExpressionId.to_debug_s}" }
+            def do_reply (synchable, workitem)
+
+                synchable.ldebug do 
+                    "#{self.class}.do_reply()  "+
+                    "#{workitem.last_expression_id.to_debug_s}"
+                end
 
                 @reply_count = @reply_count + 1
 
                 @remaining_children.delete(workitem.last_expression_id)
 
-                return workitem \
-                    if @remaining_children.length <= 0
+                if @remaining_children.length <= 0
+                    synchable.reply_to_parent(workitem)
+                    return
+                end
 
                 if @count > 0 and @reply_count >= @count
                     treat_remaining_children(synchable)
-                    return workitem
+                    synchable.reply_to_parent(workitem)
                 end
-
-                return nil
             end
-        end
-
-        protected
 
             def treat_remaining_children (synchable)
 
                 expool = synchable.get_expression_pool
 
                 @remaining_children.each do |child|
+
+                    synchable.ldebug do 
+                        "#{self.class}.treat_remainining_children() " +
+                        "#{child.to_debug_s} " +
+                        "(cancel ? #{@cancel_remaining})"
+                    end
+
                     if @cancel_remaining
                         expool.cancel(child)
                     else
-                        expool.remove(child)
+                        #expool.remove(child)
+                        expool.forget(child)
                     end
                 end
             end
 
             def determine_remaining (attributes)
-                return attributes[A_REMAINING] == REM_CANCEL
+                a = attributes[A_REMAINING]
+                return true if not a
+                return a == REM_CANCEL
             end
 
             def determine_count (attributes)