ruote 0.9.18 → 0.9.19

data/lib/openwfe/expressions/timeout.rb

@@ -2,31 +2,31 @@
 #--
 # Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without 
+#
+# 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 
+#   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 
+#
+# 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.
 #++
 #
@@ -46,133 +46,133 @@ require 'rufus/otime'
 
 module OpenWFE
 
+  #
+  # The timeout behaviour is implemented here, making it easy
+  # to mix it in into ParticipantExpression and WhenExpression.
+  #
+  module TimeoutMixin
+    include Rufus::Schedulable
+
+    attr_accessor \
+      :timeout_at,
+      :timeout_job_id
+
     #
-    # The timeout behaviour is implemented here, making it easy
-    # to mix it in into ParticipantExpression and WhenExpression.
+    # Looks for the "timeout" attribute in its process definition
+    # and then sets the @timeout_at field (if there is a timeout).
     #
-    module TimeoutMixin
-        include Rufus::Schedulable
-
-        attr_accessor \
-            :timeout_at,
-            :timeout_job_id
-        
-        #
-        # Looks for the "timeout" attribute in its process definition
-        # and then sets the @timeout_at field (if there is a timeout).
-        #
-        def determine_timeout (timeout_attname=:timeout)
-
-            #@timeout_at = nil
-            #@timeout_job_id = nil
-
-            timeout = lookup_attribute(timeout_attname, @applied_workitem)
-            return unless timeout
-
-            timeout = Rufus::parse_time_string(timeout)
-            @timeout_at = Time.new.to_f + timeout
-        end
+    def determine_timeout (timeout_attname=:timeout)
 
-        #
-        # Providing a default reschedule() implementation for the expressions
-        # that use this mixin.
-        # This default implementation just reschedules the timeout.
-        #
-        def reschedule (scheduler)
-            to_reschedule(scheduler)
-        end
+      #@timeout_at = nil
+      #@timeout_job_id = nil
 
-        #
-        # Combines a call to determine_timeout and to reschedule.
-        #
-        def schedule_timeout (timeout_attname=:timeout)
+      timeout = lookup_attribute(timeout_attname, @applied_workitem)
+      return unless timeout
 
-            determine_timeout(timeout_attname)
-            to_reschedule(get_scheduler)
-        end
+      timeout = Rufus::parse_time_string(timeout)
+      @timeout_at = Time.new.to_f + timeout
+    end
+
+    #
+    # Providing a default reschedule() implementation for the expressions
+    # that use this mixin.
+    # This default implementation just reschedules the timeout.
+    #
+    def reschedule (scheduler)
+      to_reschedule(scheduler)
+    end
+
+    #
+    # Combines a call to determine_timeout and to reschedule.
+    #
+    def schedule_timeout (timeout_attname=:timeout)
+
+      determine_timeout(timeout_attname)
+      to_reschedule(get_scheduler)
+    end
+
+    #--
+    # Overrides the parent method to make sure a potential
+    # timeout schedules gets removed.
+    #
+    # Well... Leave that to classes that mix this in...
+    # No method override in a mixin...
+    #
+    #def reply_to_parent (workitem)
+    #  unschedule_timeout()
+    #  super(workitem)
+    #end
+    #++
+
+    #
+    # Places a "__timed_out__" field in the workitem.
+    #
+    def set_timedout_flag (workitem)
 
-        #--
-        # Overrides the parent method to make sure a potential
-        # timeout schedules gets removed.
-        #
-        # Well... Leave that to classes that mix this in...
-        # No method override in a mixin...
-        #
-        #def reply_to_parent (workitem)
-        #    unschedule_timeout()
-        #    super(workitem)
-        #end
-        #++
-
-        #
-        # Places a "__timed_out__" field in the workitem.
-        #
-        def set_timedout_flag (workitem)
-
-            workitem.attributes["__timed_out__"] = "true"
+      workitem.attributes["__timed_out__"] = "true"
+    end
+
+    #
+    # Removes any "__timed_out__" field in the workitem.
+    #
+    def remove_timedout_flag (workitem)
+
+      workitem.attributes.delete("__timed_out__")
+    end
+
+    protected
+
+      #
+      # prefixed with "to_" for easy mix in
+      #
+      def to_reschedule (scheduler)
+
+        #return if @timeout_job_id
+          #
+          # already rescheduled
+
+        return unless @timeout_at
+          #
+          # no need for a timeout
+
+        @timeout_job_id = "timeout_#{self.fei.to_s}"
+
+        scheduler.schedule_at(
+          @timeout_at,
+          { :schedulable => self,
+            :job_id => @timeout_job_id,
+            :do_timeout! => true,
+            :tags => [ "timeout", self.class.name ] })
+
+        ldebug do
+          "to_reschedule() will timeout at " +
+          "#{Rufus::to_iso8601_date(@timeout_at)}" +
+          " @timeout_job_id is #{@timeout_job_id}" +
+          " (oid #{object_id})"
         end
 
-        #
-        # Removes any "__timed_out__" field in the workitem.
-        #
-        def remove_timedout_flag (workitem)
+        #store_itself()
+          #
+          # done in the including expression
+      end
+
+      #
+      # Unschedules the timeout
+      #
+      def unschedule_timeout ()
 
-            workitem.attributes.delete("__timed_out__")
+        ldebug do
+          "unschedule_timeout() " +
+          "@timeout_job_id is #{@timeout_job_id}" +
+          " (oid #{object_id})"
         end
 
-        protected
-
-            #
-            # prefixed with "to_" for easy mix in
-            #
-            def to_reschedule (scheduler)
-
-                #return if @timeout_job_id
-                    #
-                    # already rescheduled
-
-                return unless @timeout_at
-                    #
-                    # no need for a timeout
-
-                @timeout_job_id = "timeout_#{self.fei.to_s}"
-
-                scheduler.schedule_at(
-                    @timeout_at, 
-                    { :schedulable => self, 
-                      :job_id => @timeout_job_id,
-                      :do_timeout! => true,
-                      :tags => [ "timeout", self.class.name ] })
-
-                ldebug do 
-                    "to_reschedule() will timeout at " +
-                    "#{Rufus::to_iso8601_date(@timeout_at)}" +
-                    " @timeout_job_id is #{@timeout_job_id}" +
-                    " (oid #{object_id})"
-                end
-
-                #store_itself()
-                    #
-                    # done in the including expression
-            end
-
-            #
-            # Unschedules the timeout
-            #
-            def unschedule_timeout ()
-
-                ldebug do 
-                    "unschedule_timeout() " +
-                    "@timeout_job_id is #{@timeout_job_id}" +
-                    " (oid #{object_id})"
-                end
-
-                #ldebug_callstack "unschedule_timeout()"
-
-                get_scheduler.unschedule(@timeout_job_id) \
-                    if @timeout_job_id
-            end
-    end
+        #ldebug_callstack "unschedule_timeout()"
+
+        get_scheduler.unschedule(@timeout_job_id) \
+          if @timeout_job_id
+      end
+  end
 
 end
 

data/lib/openwfe/expressions/value.rb

@@ -39,88 +39,88 @@
 
 module OpenWFE
 
+  #
+  # A small mixin providing value for looking up the attributes
+  # variable/var/v and field/fld/f.
+  #
+  module ValueMixin
+
     #
-    # A small mixin providing value for looking up the attributes
-    # variable/var/v and field/fld/f.
+    # Expressions that include the ValueMixin let it gather values and
+    # then, in their reply() methods do the job with the values.
+    # The gathering task is performed by the ValueMixin.
     #
-    module ValueMixin
-
-        #
-        # Expressions that include the ValueMixin let it gather values and
-        # then, in their reply() methods do the job with the values.
-        # The gathering task is performed by the ValueMixin.
-        #
-        def apply (workitem)
+    def apply (workitem)
 
-            escape = lookup_boolean_attribute('escape', workitem, false)
+      escape = lookup_boolean_attribute('escape', workitem, false)
 
-            if @children.length < 1
+      if @children.length < 1
 
-                workitem.attributes[FIELD_RESULT] =
-                    lookup_value workitem, :escape => escape
+        workitem.attributes[FIELD_RESULT] =
+          lookup_value workitem, :escape => escape
 
-                reply workitem
-                return
-            end
+        reply workitem
+        return
+      end
 
-            child = @children.first
+      child = @children.first
 
-            if child.kind_of?(OpenWFE::FlowExpressionId)
+      if child.kind_of?(OpenWFE::FlowExpressionId)
 
-                handle_child child, workitem
-                return
-            end
+        handle_child child, workitem
+        return
+      end
 
-            workitem.attributes[FIELD_RESULT] =
-                fetch_text_content workitem, escape
+      workitem.attributes[FIELD_RESULT] =
+        fetch_text_content workitem, escape
 
-            reply workitem
-        end
+      reply workitem
+    end
 
-        def lookup_variable_attribute (workitem)
+    def lookup_variable_attribute (workitem)
 
-            lookup [ "variable", "var", "v" ], workitem
-        end
+      lookup [ "variable", "var", "v" ], workitem
+    end
 
-        def lookup_field_attribute (workitem)
+    def lookup_field_attribute (workitem)
 
-            lookup [ "field", "fld", "f" ], workitem
-        end
+      lookup [ "field", "fld", "f" ], workitem
+    end
 
-        protected
+    protected
 
-            def handle_child (child, workitem)
+      def handle_child (child, workitem)
 
-                raw_child, _fei = get_expression_pool.fetch(child)
+        raw_child, _fei = get_expression_pool.fetch(child)
 
-                if raw_child.is_definition?
+        if raw_child.is_definition?
 
-                    #body_fei = get_expression_pool.evaluate child, workitem
-                    #workitem.attributes[FIELD_RESULT] = body_fei
+          #body_fei = get_expression_pool.evaluate child, workitem
+          #workitem.attributes[FIELD_RESULT] = body_fei
 
-                    workitem.attributes[FIELD_RESULT] = raw_child
-                        #
-                        # storing the child raw expression
+          workitem.attributes[FIELD_RESULT] = raw_child
+            #
+            # storing the child raw expression
 
-                    reply workitem
-                else
+          reply workitem
+        else
 
-                    get_expression_pool.apply raw_child, workitem
-                end
-            end
+          get_expression_pool.apply raw_child, workitem
+        end
+      end
 
-        private
+    private
 
-            def lookup (name_array, workitem)
+      def lookup (name_array, workitem)
 
-                name_array.each do |n|
-                    v = lookup_string_attribute n, workitem
-                    return v if v
-                end
+        name_array.each do |n|
+          v = lookup_string_attribute n, workitem
+          return v if v
+        end
 
-                nil
-            end
-    end
+        nil
+      end
+  end
 
 end
 

data/lib/openwfe/extras/engine/db_persisted_engine.rb

@@ -0,0 +1,94 @@
+#
+#--
+# Copyright (c) 2007-2008, Tomaso Tosolini 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.
+#++
+#
+
+#
+# "made in Italy"
+#
+# Tomaso Tosolini
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/engine/engine'
+require 'openwfe/extras/expool/dbexpstorage'
+require 'openwfe/extras/expool/dberrorjournal'
+
+
+module OpenWFE::Extras
+
+  #
+  # A simple DbPersistedEngine, pure storage, no caching, no optimization.
+  # For tests only.
+  #
+  class DbPersistedEngine < OpenWFE::Engine
+
+    protected
+
+      #
+      # Overrides the method already found in Engine with a persisted
+      # expression storage
+      #
+      def build_expression_storage
+
+        init_service :s_expression_storage, DbExpressionStorage
+      end
+
+      #
+      # Uses a file persisted error journal.
+      #
+      def build_error_journal
+
+        init_service :s_error_journal, DbErrorJournal
+      end
+  end
+
+  #
+  # This OpenWFEru engine features database persistence (thanks to
+  # ActiveRecord), with a cache (for faster read operations) and a
+  # threaded wrapper (for buffering out unecessary write operations),
+  # hence it's fast (of course its's slower than in-memory storage.
+  #
+  class CachedDbPersistedEngine < DbPersistedEngine
+
+    protected
+
+      def build_expression_storage
+
+        @application_context[:expression_cache_size] ||= 1000
+
+        init_service(:s_expression_storage, OpenWFE::CacheExpressionStorage)
+
+        #init_service(:s_expression_storage__1, DbExpressionStorage)
+        init_service(:s_expression_storage__1, ThreadedDbExpressionStorage)
+      end
+  end
+end