openwferu-extras 0.9.15 → 0.9.16

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

@@ -0,0 +1,100 @@
+#
+#--
+# Copyright (c) 2007, 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 < 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, 
+                    CacheExpressionStorage)
+
+                #init_service(
+                #    S_EXPRESSION_STORAGE + ".1",
+                #    DbExpressionStorage)
+                init_service(
+                    S_EXPRESSION_STORAGE + ".1",
+                    ThreadedDbExpressionStorage)
+            end
+    end
+end

data/lib/openwfe/extras/expool/dberrorjournal.rb

@@ -0,0 +1,190 @@
+#
+#--
+# Copyright (c) 2007, Tomaso Tosolini, 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
+# 
+
+require 'rubygems'
+
+#require_gem 'activerecord'
+gem 'activerecord'
+require 'active_record'
+
+require 'openwfe/omixins'
+require 'openwfe/expool/errorjournal'
+
+
+module OpenWFE::Extras
+
+    #
+    # A migration for creating/dropping the "process errors" table, the 
+    # content of this table makes up for an error journal.
+    #
+    # There is one record per process error, the log journal can be
+    # easily rebuilt by doing find_all_by_wfid().
+    #
+    class ProcessErrorTables < ActiveRecord::Migration
+
+        def self.up
+
+            create_table :process_errors do |t|
+
+                t.column :wfid, :string, :null => false
+                t.column :svalue, :text, :null => false
+                    # 'value' could be reserved, using 'svalue' instead
+                    # It stands for 'serialized value'.
+            end
+            add_index :process_errors, :wfid
+        end
+
+        def self.down
+
+            drop_table :process_errors
+        end
+    end
+
+    #
+    # The active record for process errors. Not much to say.
+    #
+    class ProcessError < ActiveRecord::Base
+
+        serialize :svalue
+
+        #
+        # Returns the OpenWFE process error, as serialized
+        # (but takes care of setting its db_id)
+        #
+        def owfe_error
+
+            result = svalue
+            class << result
+                attr_accessor :db_id
+            end
+            result.db_id = id
+            result
+        end
+    end
+
+    #
+    # A database backed error journal.
+    #
+    # (no synchronization needed it seems)
+    #
+    class DbErrorJournal < OpenWFE::ErrorJournal
+        include FeiMixin
+
+        def initialize (service_name, application_context)
+
+            require 'openwfe/storage/yamlcustom'
+                # making sure this file has been required at this point
+                # this yamlcustom thing prevents the whole OpenWFE ecosystem
+                # to get serialized :)
+
+            super
+        end
+
+        #
+        # Returns the error log for a given workflow/process instance,
+        # the older error first.
+        #
+        def get_error_log (wfid)
+
+            wfid = to_wfid wfid
+            errors = ProcessError.find_all_by_wfid wfid, :order => "id asc"
+            errors.collect { |e| e.owfe_error }
+        end
+
+        #
+        # Erases all the errors for one given workflow/process instance.
+        #
+        def remove_error_log (wfid)
+
+            ProcessError.destroy_all ["wfid = ?", wfid]
+        end
+
+        #
+        # Returns a map wfid => error log, ie returns 1 error log for
+        # each workflow/process instance that encountered an error.
+        #
+        def get_error_logs
+
+            errors = ProcessError.find :all
+
+            result = {}
+
+            errors.each do |e|
+                (result[e.wfid] ||= []) << e.owfe_error
+            end
+
+            result
+        end
+
+        #
+        # Removes a set of errors. This is used by the expool when 
+        # resuming a previously broken process instance.
+        #
+        def remove_errors (wfid, errors)
+
+            errors = Array(errors)
+
+            errors.each do |e|
+                ProcessError.delete e.db_id
+            end
+        end
+
+        protected
+
+            #
+            # This is the inner method used by the error journal to 
+            # record a process error (instance of OpenWFE::ProcessError)
+            # that it observed in the expression pool.
+            #
+            # This method will throw an exception in case of trouble with 
+            # the database.
+            #
+            def record_error (process_error)
+
+                e = ProcessError.new
+
+                e.wfid = process_error.wfid
+                e.svalue = process_error
+
+                e.save!
+            end
+    end
+end
+

data/lib/openwfe/extras/expool/dbexpstorage.rb

@@ -0,0 +1,267 @@
+#
+#--
+# Copyright (c) 2007, Tomaso Tosolini, 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
+# 
+
+require 'rubygems'
+
+#require_gem 'activerecord'
+gem 'activerecord'
+require 'active_record'
+
+require 'monitor'
+
+
+require 'openwfe/service'
+require 'openwfe/rudefinitions'
+require 'openwfe/expool/expstorage'
+require 'openwfe/expool/threadedexpstorage'
+
+
+module OpenWFE::Extras
+
+    #
+    # A migration for creating/dropping the "expressions" table.
+    # 'expressions' are atomic pieces of running process instances.
+    #
+    class ExpressionTables < ActiveRecord::Migration
+
+        def self.up
+
+            create_table :expressions do |t|
+
+                t.column :fei, :string, :null => false
+                t.column :wfid, :string, :null => false
+                #t.column :wfname, :string, :null => false
+                t.column :exp_class, :string, :null => false
+                t.column :svalue, :text, :null => false
+                    # 'value' could be reserved, using 'svalue' instead
+            end
+            add_index :expressions, :fei
+            add_index :expressions, :wfid
+            #add_index :expressions, :wfname
+            add_index :expressions, :exp_class
+        end
+
+        def self.down
+
+            drop_table :expressions
+        end
+    end
+
+    #
+    # The ActiveRecord wrapper for an OpenWFEru FlowExpression instance.
+    #
+    class Expression < ActiveRecord::Base
+
+        serialize :svalue
+    end
+
+    #
+    # Storing OpenWFE flow expressions in a database.
+    #
+    class DbExpressionStorage
+        include MonitorMixin
+        include OpenWFE::ServiceMixin
+        include OpenWFE::OwfeServiceLocator
+        include OpenWFE::ExpressionStorageBase
+
+        #
+        # Constructor.
+        #
+        def initialize (service_name, application_context)
+
+            require 'openwfe/storage/yamlcustom'
+                # making sure this file has been required at this point
+                # this yamlcustom thing prevents the whole OpenWFE ecosystem
+                # to get serialized :)
+
+            super() # absolutely necessary as we include MonitorMixin
+            service_init service_name, application_context
+
+            observe_expool
+        end
+
+        #
+        # Stores an expression.
+        #
+        def []= (fei, flow_expression)
+
+            ldebug { "[]= storing #{fei.to_s}" }
+
+            synchronize do
+
+                e = Expression.find_by_fei fei.to_s
+
+                unless e
+                    e = Expression.new
+                    e.fei = fei.to_s
+                    e.wfid = fei.wfid
+                    #e.wfname = fei.wfname
+                end
+
+                e.exp_class = flow_expression.class.name
+                e.svalue = flow_expression
+
+                e.save!
+            end
+        end
+
+        #
+        # Retrieves a flow expression.
+        #
+        def [] (fei)
+
+            e = Expression.find_by_fei fei.to_s
+            return nil unless e
+
+            as_owfe_expression e
+        end
+
+        #
+        # Returns true if there is a FlowExpression stored with the given id.
+        #
+        def has_key? (fei)
+
+            (Expression.find_by_fei(fei.to_s) != nil)
+        end
+
+        #
+        # Deletes a flow expression.
+        #
+        def delete (fei)
+
+            synchronize do
+                Expression.delete_all ["fei = ?", fei.to_s]
+            end
+        end
+
+        #
+        # Returns the count of expressions currently stored.
+        #
+        def size
+
+            Expression.count
+        end
+
+        alias :length :size
+
+        #
+        # Danger ! Will remove all the expressions in the database.
+        #
+        def purge 
+
+            Expression.delete_all
+        end
+
+        #
+        # Given an expression class (Schedulable or ParticipantExpression for
+        # example), calls the passed block for each expression of that class.
+        #
+        def each_of_kind (kind, &block)
+
+            classes = get_expression_map.get_expression_classes(kind)
+            classes = classes.collect { |c| c.name }
+
+            exps = Expression.find_all_by_exp_class(classes)
+
+            exp_each exps, &block
+        end
+
+        #
+        # Calls the block for each expression stored. If a wfid prefix is
+        # passed, only the expressions whose workflow instance id begins
+        # with it will be iterated over.
+        #
+        def each (wfid_prefix=nil, &block)
+
+            params = {}
+
+            params[:conditions] = [ "wfid LIKE ?", "#{wfid_prefix}%" ] \
+                if wfid_prefix
+
+            exps = Expression.find(:all, params)
+
+            exp_each exps, &block
+        end
+
+        alias :real_each :each
+
+        protected
+
+            #
+            # Used by each() and each_of_kind().
+            #
+            def exp_each (expressions, &block)
+
+                expressions.each do |exp|
+                    fexp = as_owfe_expression(exp)
+                    block.call fexp.fei, fexp
+                end
+            end
+
+            #
+            # Extracts the OpenWFE FlowExpression instance from the
+            # active record and makes sure its application_context is set.
+            #
+            def as_owfe_expression (record)
+
+                fe = record.svalue
+                fe.application_context = @application_context
+                fe
+            end
+    end
+
+    #
+    # A DbExpressionStorage that does less work, for more performance,
+    # thanks to the ThreadedStorageMixin.
+    #
+    class ThreadedDbExpressionStorage < DbExpressionStorage
+        include OpenWFE::ThreadedStorageMixin
+
+        def initialize (service_name, application_context)
+
+            super
+
+            start_processing_thread()
+                #
+                # which sets @thread_id
+        end
+    end
+end
+

data/lib/openwfe/extras/listeners/sqslisteners.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -116,7 +114,7 @@ module Extras
 
                         o = decode_object(msg)
 
-                        handle_object(o)
+                        handle_item o
 
                         msg.delete