ruote-extras 0.9.18

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 < OpenWFE::Engine
+
+        protected
+
+            #
+            # Overrides the method already found in Engine with a persisted 
+            # expression storage
+            #
+            def build_expression_storage
+
+                init_service OpenWFE::S_EXPRESSION_STORAGE, DbExpressionStorage
+            end
+
+            #
+            # Uses a file persisted error journal.
+            #
+            def build_error_journal
+
+                init_service OpenWFE::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(
+                    OpenWFE::S_EXPRESSION_STORAGE, 
+                    OpenWFE::CacheExpressionStorage)
+
+                #init_service(
+                #    S_EXPRESSION_STORAGE + ".1",
+                #    DbExpressionStorage)
+                init_service(
+                    OpenWFE::S_EXPRESSION_STORAGE + ".1",
+                    ThreadedDbExpressionStorage)
+            end
+    end
+end

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

@@ -0,0 +1,189 @@
+#
+#--
+# Copyright (c) 2007-2008, 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 OpenWFE::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 = extract_wfid wfid, true
+            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,353 @@
+#
+#--
+# Copyright (c) 2007-2008, 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
+                t.column :svalue, :text, :null => false, :limit => 1024 * 1024
+                    #
+                    # 'value' could be reserved, using 'svalue' instead
+                    #
+                    # :limit patch by Maarten Oelering (a greater value
+                    # could be required in some cases)
+            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
+
+        #
+        # Gather expressions matching certain parameters.
+        #
+        def find_expressions (options={})
+
+            conditions = determine_conditions options
+                # note : this call modifies the options hash...
+
+            #
+            # maximize usage of SQL querying
+
+            exps = Expression.find :all, :conditions => conditions
+
+            #
+            # do the rest of the filtering
+
+            exps = exps.collect do |exp|
+                as_owfe_expression exp
+            end
+
+            exps.find_all do |fexp|
+                does_match? options, fexp
+            end
+        end
+
+        #
+        # Fetches the root of a process instance.
+        #
+        def fetch_root (wfid)
+
+            params = {}
+
+            params[:conditions] = [ 
+                "wfid = ? AND exp_class = ?", 
+                wfid, 
+                OpenWFE::DefineExpression.to_s
+            ]
+
+            exps = Expression.find(:all, params)
+
+            e = exps.sort { |fe1, fe2| fe1.fei.expid <=> fe2.fei.expid }[0]
+                #
+                # find the one with the smallest expid
+
+            as_owfe_expression e
+        end
+
+        protected
+
+            #
+            # Grabs the options to build a conditions array for use by
+            # find().
+            #
+            # Note : this method, modifies the options hash (it removes
+            # the args it needs).
+            #
+            def determine_conditions (options)
+
+                wfid = options.delete :wfid
+                wfid_prefix = options.delete :wfid_prefix
+                #parent_wfid = options.delete :parent_wfid
+
+                query = []
+                conditions = []
+
+                if wfid
+                    query << "wfid = ?"
+                    conditions << wfid
+                elsif wfid_prefix
+                    query << "wfid LIKE ?"
+                    conditions << "#{wfid_prefix}%"
+                end
+
+                add_class_conditions options, query, conditions
+
+                conditions = conditions.flatten
+
+                if conditions.size < 1
+                    nil
+                else
+                    conditions.insert 0, query.join(" AND ")
+                end
+            end
+
+            #
+            # Used by determine_conditions().
+            #
+            def add_class_conditions (options, query, conditions)
+
+                ic = options.delete :include_classes
+                ic = Array(ic)
+
+                ec = options.delete :exclude_classes
+                ec = Array(ec)
+
+                acc ic, query, conditions, "OR"
+                acc ec, query, conditions, "AND"
+            end
+
+            def acc (classes, query, conditions, join)
+
+                return if classes.size < 1
+
+                classes = classes.collect do |kind|
+                    get_expression_map.get_expression_classes kind
+                end
+                classes = classes.flatten
+
+                quer = []
+                cond = []
+                classes.each do |cl|
+
+                    quer << if join == "AND"
+                        "exp_class != ?"
+                    else
+                        "exp_class = ?"
+                    end
+
+                    cond << cl.to_s
+                end
+                quer = quer.join " #{join} "
+
+                query << "(#{quer})"
+                conditions << cond
+            end
+
+            #
+            # Extracts the OpenWFE FlowExpression instance from the
+            # active record and makes sure its application_context is set.
+            #
+            def as_owfe_expression (record)
+
+                return nil unless 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_queue
+                #
+                # which sets @thread_id
+        end
+    end
+end
+