ruote 0.9.19 → 0.9.20

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

@@ -0,0 +1,165 @@
+#--
+# Copyright (c) 2007-2009, Tomaso Tosolini, John Mettraux, OpenWFE.org
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Italy.
+#++
+
+
+require 'openwfe/omixins'
+require 'openwfe/expool/errorjournal'
+require 'openwfe/extras/singlecon'
+
+
+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 :created_at, :timestamp
+        t.column :wfid, :string, :null => false
+        t.column :expid, :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, :created_at
+      add_index :process_errors, :wfid
+      add_index :process_errors, :expid
+    end
+
+    def self.down
+
+      drop_table :process_errors
+    end
+  end
+
+  #
+  # The active record for process errors. Not much to say.
+  #
+  class ProcessError < ActiveRecord::Base
+    include SingleConnectionMixin
+
+    #serialize :svalue, OpenWFE::ProcessError
+    serialize :svalue
+
+    #
+    # Returns the OpenWFE process error, as serialized
+    # (but takes care of setting its db_id)
+    #
+    def as_owfe_error
+
+      result = svalue
+      class << result
+        attr_accessor :db_id
+      end
+      result.db_id = id
+      result
+    end
+
+    alias :owfe_error :as_owfe_error
+  end
+
+  #
+  # A database backed error journal.
+  #
+  # (no synchronization needed it seems)
+  #
+  class DbErrorJournal < OpenWFE::ErrorJournal
+    include OpenWFE::FeiMixin
+
+    #
+    # 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.as_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
+
+      ProcessError.find(:all).inject({}) do |h, e|
+        (h[e.wfid] ||= []) << e.as_owfe_error; h
+      end
+    end
+
+    #
+    # Removes a set of errors. This is used by the expool when
+    # resuming a previously broken process instance.
+    #
+    def remove_errors (wfid, errors)
+
+      Array(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 = OpenWFE::Extras::ProcessError.new
+
+        e.created_at = process_error.date
+          # making sure they are, well, in sync
+
+        e.wfid = process_error.wfid
+        e.expid = process_error.fei.expid
+        e.svalue = process_error
+
+        e.save_without_transactions!
+      end
+  end
+end
+

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

@@ -0,0 +1,73 @@
+#--
+# Copyright (c) 2007-2009, Tomaso Tosolini, John Mettraux OpenWFE.org
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Italy.
+#++
+
+require 'openwfe/expool/threaded_expstorage'
+require 'openwfe/extras/expool/ar_expstorage'
+
+
+module OpenWFE::Extras
+
+  #
+  # DEPRECATED !! use openwfe/extras/expool/ar_expstorage instead
+  #
+  # An extension of ArExpressionStorage that always stores its expression
+  # as YAML (way slower than the default Marshal, but Marshal version
+  # may differ over time).
+  #
+  # If you need to migrate from yaml to marshal and back (and other storage
+  # variants), have a look at work/pooltool.ru
+  #
+  class DbExpressionStorage < ArExpressionStorage
+
+    #
+    # Constructor.
+    #
+    def initialize (service_name, application_context)
+
+      application_context[:persist_as_yaml] = true
+
+      super
+    end
+  end
+
+  #
+  # A DbExpressionStorage that does less work, for more performance,
+  # thanks to the ThreadedStorageMixin.
+  #
+  # DEPRECATED. Use ArExpressionStorage.
+  #
+  class ThreadedDbExpressionStorage < DbExpressionStorage
+    include OpenWFE::ThreadedStorageMixin
+
+    def initialize (service_name, application_context)
+
+      super
+
+      start_queue
+        #
+        # which sets @thread_id
+    end
+  end
+end
+

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

@@ -0,0 +1,163 @@
+#--
+# Copyright (c) 2008-2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'openwfe/expool/history'
+require 'openwfe/extras/singlecon'
+
+
+module OpenWFE::Extras
+
+  #
+  # The migration for the DbHistory table
+  #
+  class HistoryTables < ActiveRecord::Migration
+
+    def self.up
+
+      create_table :history do |t|
+
+        t.column :created_at, :timestamp
+        t.column :source, :string, :null => false
+        t.column :event, :string, :null => false
+        t.column :wfid, :string
+        t.column :wfname, :string
+        t.column :wfrevision, :string
+        t.column :fei, :string
+        t.column :participant, :string
+        t.column :message, :string # empty is ok
+      end
+
+      add_index :history, :created_at
+      add_index :history, :source
+      add_index :history, :event
+      add_index :history, :wfid
+      add_index :history, :wfname
+      add_index :history, :wfrevision
+      add_index :history, :participant
+    end
+
+    def self.down
+
+      drop_table :history
+    end
+  end
+
+  #
+  # The active record for process errors. Not much to say.
+  #
+  class HistoryEntry < ActiveRecord::Base
+    include SingleConnectionMixin
+
+    set_table_name('history')
+
+    #
+    # returns a FlowExpressionId instance if the entry has a 'fei' or
+    # nil instead.
+    #
+    def full_fei
+
+      self.fei ? OpenWFE::FlowExpressionId.from_s(self.fei) : nil
+    end
+
+    #
+    # Directly logs an event (may throw an exception)
+    #
+    def self.log! (source, event, opts={})
+
+      fei = opts[:fei]
+
+      if fei
+        opts[:wfid] = fei.parent_wfid
+        opts[:wfname] = fei.wfname
+        opts[:wfrevision] = fei.wfrevision
+        opts[:fei] = fei.to_s
+      end
+
+      opts[:source] = source.to_s
+      opts[:event] = event.to_s
+
+      #self.new(opts).save!
+      self.new(opts).save_without_transactions!
+      #begin
+      #  self.new(opts).save!
+      #rescue Exception => e
+      #  puts ; puts e
+      #  self.new(opts).save! rescue nil
+      #end
+    end
+  end
+
+  class DbHistory < OpenWFE::History
+
+    #def initialize (service_name, application_context)
+    #  super
+    #end
+
+    def log (source, event, *args)
+
+      do_log(source, event, *args)
+    end
+
+    protected
+
+    def do_log (source, event, *args)
+
+      fei = get_fei(args)
+      wi = get_workitem(args)
+
+      begin
+
+        HistoryEntry.log!(
+          source, event,
+          :fei => fei,
+          :message => get_message(source, event, args),
+          :participant => wi.respond_to?(:participant_name) ?
+            wi.participant_name : nil)
+
+      rescue Exception => e
+        #p e
+        lerror { "db_history logging failure : #{e}" }
+      end
+    end
+  end
+
+  #
+  # An extension of the DbHistory that uses the engine's workqueue. Insertions
+  # into database are queued (as well as expool events).
+  #
+  # Seems to be slightly faster (0.8s gain for a 11s test).
+  #
+  # Currently in use in ruote-rest.
+  #
+  class QueuedDbHistory < DbHistory
+
+    def log (source, event, *args)
+
+      get_workqueue.push(self, :do_log, source, event, *args)
+    end
+  end
+
+end
+

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

@@ -0,0 +1,327 @@
+#--
+# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'base64'
+
+require 'dm-core'
+
+require 'openwfe/service'
+require 'openwfe/rudefinitions'
+require 'openwfe/expool/expstorage'
+
+
+module OpenWFE::Extras
+
+  #
+  # The datamapper resource class for Ruote expressions.
+  #
+  class DmExpression
+    include DataMapper::Resource
+
+    property :fei, String, :key => true
+    property :wfid, String, :index => :wfid
+    property :expid, String, :index => :expid
+    property :expclass, String, :index => :expclass
+    property :svalue, Text
+
+    def svalue= (fexp)
+
+      attribute_set(:svalue, Base64.encode64(Marshal.dump(fexp)))
+    end
+
+    def as_owfe_expression (application_context)
+
+      fe = Marshal.load(Base64.decode64(self.svalue))
+      fe.application_context = application_context
+      fe
+    end
+
+    def self.storage_name (repository_name = default_repository_name)
+      'dm_expressions'
+    end
+  end
+
+  #
+  # Storing Ruote's flow expressions via DataMapper.
+  #
+  class DmExpressionStorage
+
+    include OpenWFE::ServiceMixin
+    include OpenWFE::OwfeServiceLocator
+    include OpenWFE::ExpressionStorageBase
+
+    attr_accessor :dm_repository
+
+    #
+    # Instantiates a DmExpressionStorage service. (Where dm stands for
+    # Data Mapper).
+    #
+    def initialize (service_name, application_context)
+
+      super()
+      service_init(service_name, application_context)
+
+      @dm_repository =
+        application_context[:expstorage_dm_repository] || :default
+
+      DataMapper.repository(@dm_repository) {
+        DmExpression.auto_upgrade!
+      }
+
+      observe_expool
+    end
+
+    #
+    # Stores an expression.
+    #
+    def []= (fei, flow_expression)
+
+      DataMapper.repository(@dm_repository) {
+
+        e = find(fei) || DmExpression.new
+
+        e.fei = fei.as_string_key
+        e.wfid = fei.wfid
+        e.expid = fei.expid
+        e.expclass = flow_expression.class.name
+        e.svalue = flow_expression
+
+        e.save
+      }
+    end
+
+    #
+    # Retrieves a flow expression.
+    #
+    def [] (fei)
+
+      if e = find(fei)
+        e.as_owfe_expression(self.application_context)
+      else
+        nil
+      end
+    end
+
+    #
+    # Finds the DmExpression instance with the given fei (FlowExpressionId)
+    #
+    def find (fei)
+
+      DataMapper.repository(@dm_repository) {
+        DmExpression.first(:fei => fei.as_string_key)
+      }
+    end
+
+    #
+    # Returns true if there is a FlowExpression stored with the given id.
+    #
+    def has_key? (fei)
+
+      (self[fei] != nil)
+    end
+
+    #
+    # Deletes a flow expression.
+    #
+    def delete (fei)
+
+      e = find(fei)
+      e.destroy if e
+    end
+
+    #
+    # Returns the count of expressions currently stored.
+    #
+    def size
+
+      DataMapper.repository(@dm_repository) { DmExpression.count }
+    end
+
+    alias :length :size
+
+    #
+    # Danger ! Will remove all the expressions in the database.
+    #
+    def purge
+
+      DataMapper.repository(@dm_repository) {
+
+        DmExpression.all.each { |de| de.destroy }
+          #
+          # TODO : find simpler way to do that
+      }
+    end
+
+    #
+    # Gather expressions matching certain parameters.
+    #
+    def find_expressions (options={})
+
+      #conditions = determine_conditions(options)
+        # note : this call modifies the options hash...
+
+      conditions = {}
+
+      #
+      # maximize usage of SQL querying
+
+      exps = DataMapper.repository(@dm_repository) {
+        DmExpression.all(conditions)
+      }
+
+      #
+      # do the rest of the filtering
+
+      exps.inject([]) { |a, de|
+        fe = de.as_owfe_expression(application_context)
+        a << fe if does_match?(options, fe)
+        a
+      }
+    end
+
+    #
+    # Fetches the root of a process instance.
+    #
+    def fetch_root (wfid)
+
+      exps = DataMapper.repository(@dm_repository) {
+
+       DmExpression.all(
+        :wfid => wfid,
+        :expclass => OpenWFE::Definition.to_s,
+        :order => [ :expid.asc ])
+      }
+
+      #e = exps.sort { |fe1, fe2| fe1.fei.expid <=> fe2.fei.expid }[0]
+      e = exps.first
+
+      e ? e.as_owfe_expression(self.application_context) : nil
+    end
+
+    #
+    # Used only by work/pooltool.ru for storage migrations.
+    #
+    def each
+
+      return unless block_given?
+
+      exps = DataMapper.repository(@dm_repository) { DmExpression.all }
+
+      exps.each do |de|
+        fe = de.as_owfe_expression(self.application_context)
+        yield(fe.fei, fe)
+      end
+    end
+
+    #
+    # Closes the underlying database... Does nothing in this implementation.
+    #
+    def close
+
+      # nothing to do here.
+    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
+
+  end
+end
+