openwferu 0.9.4 → 0.9.5

data/lib/openwfe/expool/expstorage.rb

@@ -40,110 +40,123 @@
 # John Mettraux at openwfe.org
 #
 
+#require 'monitor'
 require 'fileutils'
 
 require 'openwfe/service'
-require 'openwfe/util/lru_cache'
+require 'openwfe/util/lru'
 require 'openwfe/flowexpressionid'
 
 module OpenWFE
     
     #
-    # Create a composite expression storage.
-    # This will take parameters from the application context to create 
-    # the resulting composite storage
-    class CompositeExpressionStorage 
-        include ServiceMixin
-        
-        attr_accessor \
-        :persistence, \
-        :cache, \
-        :journal
-        
-        def initialize (serviceName, applicationContext)
-            
-            service_init(serviceName, applicationContext)
-            
-            @cache = @application_context[:cached_expression_storage]
-            @journal = @application_context[:journalized_expression_storage]
-            @persistence = @application_context[:file_expression_storage]
-        end
-        
-        #
-        # call the add method for each registered storage
-        #
-        def []= (fei, flowExpression)
-            @journal[fei] = flowExpression if @journal
-            @cache[fei] = flowExpression if @cache
-            @persistence[fei] = flowExpression
-        end
-        
-        #
-        # remove the expressionid from each registered storage
-        #
-        def delete (fei)
-            @journal.delete(fei) if @journal
-            @cache.delete(fei) if @cache
-            @persistence.delete(fei)
-        end
-        
-        #
-        # slightly different method. Try to get the value from the cache storage if one
-        # if not retrieve it, and then add it to the cache.
-        def [] (fei)
-            return @cache[fei] if @cache
-            flow_expression = @persistence[fei]
-            @cache[fei] = flow_expression if @cache
-            return flow_expression
-        end
-    end
-        
-     #
-     # implementation of a LRU caching storage.
-    class LruCachedExpressionStorage
-        include ServiceMixin
-        
-        DEFAULT_LRU_SIZE = 10
-        
+    # This cache uses a LruHash (Least Recently Used) to store expressions.
+    # If an expression is not cached, the 'real storage' is consulted.
+    # The real storage is supposed to be the service named
+    # "expressionStorage.1"
+    #
+    class CacheExpressionStorage
+        include ServiceMixin, OwfeServiceLocator
+
+        DEFAULT_SIZE = 5000
+
         def initialize (service_name, application_context)
+
+            super()
+
             service_init(service_name, application_context)
-            size = if (@application_context) 
-                @application_context[:lru_storage_size] 
-            else 
-                DEFAULT_LRU_SIZE 
+
+            size = @application_context[:expression_cache_size]
+            size = DEFAULT_SIZE unless size
+
+            linfo { "new() size is #{size}" }
+
+            @cache = LruHash.new(size)
+
+            @real_storage = nil
+
+            #
+            # expstorage observes expool :
+
+            get_expression_pool.add_observer(:update) do |channel, fei, fe|
+                ldebug { ":update  for #{fei}" }
+                self[fei] = fe
+            end
+            get_expression_pool.add_observer(:remove) do |channel, fei|
+                ldebug { ":delete  for #{fei}" }
+                self.delete(fei)
             end
-            @cache = LRUCache.new(size)
         end
-        
-        def []= (fei, flowExpression)
-            @cache[fei]=flowExpression
+
+        def [] (fei)
+
+            #ldebug { "[] size is #{@cache.size}" }
+            ldebug { "[] (sz #{@cache.size}) for #{fei.to_debug_s}" }
+
+            fe = @cache[fei]
+            return fe if fe
+
+            ldebug { "[] (reload) for #{fei.to_debug_s}" }
+
+            fe = get_real_storage[fei]
+
+            return nil unless fe
+
+            @cache[fei] = fe
+
+            return fe
         end
-        
-        #
-        # interface method to remove an entry for the given expression_id
-        #
+
+        def []= (fei, fe)
+            @cache[fei] = fe
+        end
+
         def delete (fei)
             @cache.delete(fei)
         end
-        
-        #
-        # check if the value is in the cache
-        def is_in_cache?(fei)
-            @cache.include?(fei)
+
+        def length
+            @cache.length
         end
-        alias has_key? is_in_cache? 
-        
+
+        alias :size :length
+
+        def clear
+            @cache.clear
+        end
+
+        alias :purge :clear
+
         #
-        # interface method, return the value associated with the given id, 
-        # or nil if not in cache.
-        def [] (fei)
-            if(@cache.include?(fei))
-                return @cache[fei]
-            else
-                return nil
+        # Simply redirects the call to the each_of_kind() method of 
+        # the 'real storage'.
+        #
+        def each_of_kind (kind, &block)
+
+            get_real_storage.each_of_kind(kind, &block)
+        end
+
+        def each (&block)
+            @cache.each do |k, v|
+                block.call(k, v)
             end
         end
-        
+
+        def to_s
+            expstorage_to_s(self)
+        end
+
+        protected
+
+            def get_real_storage
+
+                return @real_storage if @real_storage
+
+                @real_storage = 
+                    @application_context[S_EXPRESSION_STORAGE + ".1"]
+
+                return @real_storage
+            end
     end
         
     #
@@ -151,34 +164,62 @@ module OpenWFE
     # No memory limit, puts everything in a Hash
     #
     class InMemoryExpressionStorage < Hash
-        include ServiceMixin
+        include ServiceMixin, OwfeServiceLocator
         
         def initialize (service_name, application_context)
+
             service_init(service_name, application_context)
+
+            #
+            # expstorage observes expool :
+
+            get_expression_pool.add_observer(:update) do |channel, fei, fe|
+                #ldebug { ":update  for #{fei}" }
+                self[fei] = fe
+            end
+            get_expression_pool.add_observer(:remove) do |channel, fei|
+                #ldebug { ":delete  for #{fei}" }
+                self.delete(fei)
+            end
         end
 
         alias :purge :clear
 
-        def each_of_kind (kind)
-            # TODO : implement with a filter
+        def each_of_kind (kind, &block)
+
+            return unless block
+
+            self.each_value do |fexp|
+                block.call(fexp) if fexp.kind_of? kind
+            end
         end
-        
+
         def to_s
-            s = "\n\n==== #{self.class} ===="
-            each do |k, v|
-                s << "\n"
-                if v.kind_of?(RawExpression)
-                    s << "*raw" 
-                else
-                    s << "  "
-                end
-                s << v.to_s
-                s << "    key/value mismatch !" if k != v.fei
-            end
-            s << "\n==== . ====\n"
-            return s
+            expstorage_to_s(self)
         end
         
     end
 
+    #
+    # a small help method for expression storages...
+    #
+    def expstorage_to_s (expstorage)
+
+        s = "\n\n==== #{expstorage.class} ===="
+
+        expstorage.each do |k, v|
+            s << "\n"
+            if v.kind_of?(RawExpression)
+                s << "*raw" 
+            else
+                s << "  "
+            end
+            s << v.to_s
+            s << "    key/value mismatch !" if k != v.fei
+        end
+        s << "\n==== . ====\n"
+
+        return s
+    end
+
 end

data/lib/openwfe/expool/history.rb

@@ -39,7 +39,7 @@
 # John Mettraux at openwfe.org
 #
 
-#require 'monitor'
+#require 'date'
 
 require 'openwfe/service'
 require 'openwfe/rudefinitions'
@@ -91,7 +91,12 @@ module OpenWFE
         end
 
         def log (event, *args)
-            msg = ""
+
+            return if event == :stop
+            return if event == :reschedule
+
+            msg = "#{Time.now.to_s} -- "
+
             msg << event.to_s
 
             msg << " #{args[0].to_s}" \

data/lib/openwfe/expool/yamlexpstorage.rb

@@ -40,8 +40,6 @@
 # John Mettraux at openwfe.org
 #
 
-#require 'find'
-
 require 'openwfe/utils'
 require 'openwfe/rudefinitions'
 require 'openwfe/storage/yamlfilestorage'
@@ -109,6 +107,8 @@ module OpenWFE
             path = path + '/expool'
 
             super(service_name, application_context, path)
+
+            observe_expool()
         end
 
         #
@@ -149,6 +149,24 @@ module OpenWFE
         end
 
         protected
+
+            #
+            # The actual binding of this storage as an observer of the
+            # expression pool is done here.
+            # It gives the opportunity to override this method with variants
+            # (for example for delayed execution)
+            #
+            def observe_expool
+
+                get_expression_pool.add_observer(:update) do |channel, fei, fe|
+                    #ldebug { ":update  for #{fei.to_debug_s}" }
+                    self[fei] = fe
+                end
+                get_expression_pool.add_observer(:remove) do |channel, fei|
+                    #ldebug { ":remove  for #{fei.to_debug_s}" }
+                    self.delete(fei)
+                end
+            end
             
             def compute_file_path (fei)
                 
@@ -157,10 +175,10 @@ module OpenWFE
                     
                 wfid = fei.parent_workflow_instance_id
                 
-                @basepath + "/" +
-                wfid[-1, 1] + "/" +
+                @basepath +
+                #wfid[-3, 1] + "/" +
                 wfid[-2, 1] + "/" +
-                wfid + "/" +
+                wfid[-1, 1] + "/" +
                 fei.workflow_instance_id + "__" +
                 fei.expression_id + "_" + 
                 fei.expression_name + ".yaml"
@@ -175,6 +193,132 @@ module OpenWFE
 
                 return false
             end
-        
+    end
+
+    #
+    # With this extension of YmalFileExpressionStorage, persistence occurs
+    # in a separate thread, for a snappier response.
+    #
+    class ThreadedYamlFileExpressionStorage < YamlFileExpressionStorage
+
+        def initialize (service_name, application_context)
+
+            super
+
+            @events = {}
+            @op_count = 0
+
+            @stopped = false
+
+            start_processing_thread()
+        end
+
+        #
+        # Will take care of stopping the 'queue processing' thread.
+        #
+        def stop
+
+            @stopped = true
+
+            process_queue()
+                #
+                # flush every remaining events (especially the :delete ones)
+        end
+
+        #
+        # calls process_queue() before the call the super class each_of_kind()
+        # method
+        #
+        def each_of_kind (kind, &block)
+
+            #ldebug { "each_of_kind()" }
+
+            process_queue()
+            super
+        end
+
+        protected
+
+            def start_processing_thread
+                Thread.new do
+                    while true
+                        sleep(0.33)
+                        break if @stopped
+                        process_queue()
+                    end
+                end
+            end
+
+            def queue (event, fei, fe=nil)
+                synchronize do
+
+                    old_size = @events.size
+                    @op_count += 1
+
+                    @events[fei] = [ event, fei, fe ]
+
+                    ldebug do 
+                        "queue() ops #{@op_count} "+
+                        "size #{old_size} -> #{@events.size}"
+                    end
+                end
+            end
+
+            def process_queue ()
+
+                return unless @events.size > 0
+                    #
+                    # trying to exit as quickly as possible
+
+                ldebug do 
+                    "process_queue() #{@events.size} events #{@op_count} ops"
+                end
+
+                synchronize do
+                    @events.each_value do |v|
+                        event = v[0]
+                        begin
+                            if event == :update
+                                self[v[1]] = v[2]
+                            else
+                                safe_delete(v[1])
+                            end
+                        rescue Exception => e
+                            lwarn do
+                                "process_queue() ':#{event}' exception\n" + 
+                                OpenWFE::exception_to_s(e)
+                            end
+                        end
+                    end
+                    @op_count = 0
+                    @events.clear
+                end
+            end
+
+            #
+            # a call to delete that tolerates missing .yaml files
+            #
+            def safe_delete (fei)
+                begin
+                    self.delete(fei)
+                rescue Exception => e
+                #    lwarn do
+                #        "safe_delete() exception\n" + 
+                #        OpenWFE::exception_to_s(e)
+                #    end
+                end
+            end
+
+            def observe_expool
+
+                get_expression_pool.add_observer(:update) do |event, fei, fe|
+                    ldebug { ":update  for #{fei.to_debug_s}" }
+                    queue(event, fei, fe)
+                end
+                get_expression_pool.add_observer(:remove) do |event, fei|
+                    ldebug { ":remove  for #{fei.to_debug_s}" }
+                    queue(event, fei)
+                end
+            end
     end
 end

data/lib/openwfe/expressions/{fe_condition.rb → condition.rb}

@@ -39,9 +39,6 @@
 # John Mettraux at openwfe.org
 #
 
-#require 'openwfe/workitem'
-#require 'openwfe/flowexpressionid'
-
 
 module OpenWFE
 
@@ -83,10 +80,11 @@ module OpenWFE
 
             ldebug { "eval_condition() 2 for  '#{conditional}'" }
 
-            return true if conditional == '"true"'
-            return false if conditional == '"false"'
+            result = instance_eval(conditional)
+
+            ldebug { "eval_condition() 3 result is  '#{result}'" }
 
-            return instance_eval(conditional)
+            return (result == "true" or result == true)
         end
 
         private

data/lib/openwfe/expressions/expressionmap.rb

@@ -53,6 +53,7 @@ require 'openwfe/expressions/fe_losfor'
 require 'openwfe/expressions/fe_cursor'
 require 'openwfe/expressions/fe_iterator'
 require 'openwfe/expressions/fe_fqv'
+require 'openwfe/expressions/fe_cancel'
 
 
 module OpenWFE
@@ -116,6 +117,13 @@ module OpenWFE
             @map["q"] = FqvExpression
             @map["v"] = FqvExpression
 
+            #@map["do"] = DoExpression
+            #@map["undo"] = UndoExpression
+            #@map["redo"] = RedoExpression
+
+            @map["cancel-process"] = CancelProcessExpression
+            #@map["cancel"] = CancelExpression
+
             @map["environment"] = Environment
                 #
                 # only used by get_expression_names()

data/lib/openwfe/expressions/fe_cancel.rb

@@ -0,0 +1,109 @@
+#
+#--
+# 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/condition'
+require 'openwfe/expressions/flowexpression'
+
+
+module OpenWFE
+
+    #
+    # This expression cancels the current process instance. Use with care.
+    #
+    #     <sequence>
+    #         <participant ref="before" />
+    #         <cancel-process />
+    #         <participant ref="after" />
+    #     </sequence>
+    #
+    # the message "after" will never get printed.
+    #
+    # Use rather in scenarii like that one :
+    #
+    #     class TestDefinition1 < ProcessDefinition
+    #         def make
+    #             process_definition :name => "25_cancel", :revision => "1" do
+    #                 sequence do
+    #                     participant "customer"
+    #                     _cancel_process :if => "${f:no_thanks} == true"
+    #                     concurrence do
+    #                         participant "accounting"
+    #                         participant "logistics"
+    #                     end
+    #                 end
+    #             end
+    #         end
+    #     end
+    #
+    # Note that the expression accepts an "if" attribute.
+    #
+    class CancelProcessExpression < FlowExpression
+        include ConditionMixin
+
+        #
+        # apply / reply
+
+        def apply (workitem)
+
+            conditional = eval_condition(:if, workitem)
+                #
+                # for example : <cancel-process if="${approved} == false"/>
+
+            if conditional == false
+                reply_to_parent(workitem)
+                return
+            end
+
+            #
+            # else, do cancel the process
+
+            get_expression_pool.cancel_process(self)
+
+            # no need to reply to parent
+        end
+
+        #def reply (workitem)
+        #end
+
+    end
+
+end
+