tengine_core 0.5.28

data/lib/tengine/core/dsl_filter_def.rb

@@ -0,0 +1,11 @@
+require 'tengine/core'
+
+class Tengine::Core::DslFilterDef
+  attr_reader :filter
+  attr_reader :event_type_names
+  def initialize(event_type_names, filter)
+    @event_type_names = event_type_names
+    @filter = filter
+  end
+
+end

data/lib/tengine/core/dsl_loader.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+require 'pathname'
+
+module Tengine::Core::DslLoader
+  include Tengine::Core::DslEvaluator
+
+  attr_accessor :__kernel__
+
+
+  # どのようなポリシーでackを返すのかをイベント種別名毎に指定できます。
+  #
+  # @param [Symbol] policy ackポリシー
+  # @param [[Symbol/String]] args イベント種別名の配列
+  #
+  # 例:
+  # {include:file:examples/uc50_commit_event_at_first.rb}
+  #
+  # 例:
+  # {include:file:examples/uc51_commit_event_at_first_submit.rb}
+  #
+  # 例:
+  # {include:file:examples/uc52_commit_event_after_all_handler_submit.rb}
+  #
+  def ack_policy(policy, *args)
+    args.each{|arg| @__kernel__.add_ack_policy(arg, policy)}
+  end
+
+  # このメソッドにブロックを渡すことで、Tengineコアが使用するEventMachineの初期化を行うために設定を行うことができます。
+  #
+  # 例:
+  # {include:file:examples/uc72_setup_eventmachine.rb}
+  #
+  def setup_eventmachine(&block)
+    return unless block
+    @__kernel__.em_setup_blocks << block
+  end
+
+  # イベントドライバを登録します。
+  #
+  # イベントドライバはonメソッドで定義されるイベントハンドラを持つことができます。
+  # イベントドライバは実行時のユーザーによる有効化、無効化の対象になります。
+  # 無効化されたイベントドライバのイベントハンドラは、イベントが発生した際に
+  # それがフィルタにマッチしたとしても、その処理を実行しません。
+  # つまりイベントハンドラの有効化、無効化は、それをまとめているイベントドライバ毎に
+  # 指定することが可能です。
+  #
+  # @param [String] name イベントドライバ名
+  # @param [Hash] options オプション
+  # @option options [String] :enabled_on_activation 実行時に有効にするならばtrue、でなければfalse。デフォルトはtrue
+  # @return [Tengine::Core::Driver]
+  # @see #on
+  #
+  # 例:
+  # {include:file:examples/uc01_execute_processing_for_event.rb}
+  def driver(name, options = {}, &block)
+    unless block_given?
+      # Tengine::Core::stdout.info("no block given at #{caller.first}")
+      return
+    end
+
+    if dsl_version_document = Tengine::Core::Setting.first(:conditions => {:name => "dsl_version"})
+      dsl_version_document.value = config.dsl_version
+      dsl_version_document.save!
+    else
+      Tengine::Core::Setting.create!(:name => "dsl_version", :value => config.dsl_version)
+    end
+    c = config
+    klass = Class.new
+    const_name = name.to_s.camelize
+#     if Object.constants.include?(const_name) || defined?(const_name)
+#       puts "#{const_name} is already defined\n  " << caller.join("\n  ")
+#     end
+    Object.send :remove_const, const_name if Object.const_defined? const_name
+    Object.const_set(const_name, klass)
+    klass.module_eval do
+      include Tengine::Core::Driveable::ByDsl
+      self.singleton_class.config = c
+      self.singleton_class.options = options
+      include Tengine::Core::Driveable
+    end
+    begin
+      klass.module_eval(&block)
+    rescue Exception => e
+      driver = klass.driver
+      driver.destroy if driver && !driver.new_record?
+      raise e
+    end
+  end
+
+  # @see Tengine::Core::DslBinder#session
+  def session
+    raise Tengine::Core::DslError, "session is not available outside of event driver block." unless @__session__
+    @__session_wrapper__ ||= Tengine::Core::SessionWrapper.new(@__session__)
+  end
+
+  def fire(*args, &blcok)
+    options = args.extract_options!
+    options[:keep_connection] = true
+    args = args + [options]
+    Tengine::Event.fire(*args, &blcok)
+  end
+
+  # 現時点ではMM1との互換性のためのダミーのメソッドです
+  # 必要があれば将来ちゃんと役割を見直して復活するかもしれません
+  def dsl_version(*args)
+  end
+
+end

data/lib/tengine/core/event.rb

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+require 'selectable_attr'
+
+class Tengine::Core::Event
+  autoload :Finder, 'tengine/core/event/finder'
+
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Tengine::Core::Validation
+  include Tengine::Core::SelectableAttr
+  include Tengine::Core::CollectionAccessible
+
+  field :lock_version   , :type => Integer, :default => -(2**63)
+  field :event_type_name, :type => String
+  field :key            , :type => String
+  field :source_name    , :type => String
+  field :occurred_at    , :type => Time
+  field :level          , :type => Integer, :default => 2
+  field :confirmed      , :type => Boolean
+  field :sender_name    , :type => String
+  field :properties     , :type => Hash
+  map_yaml_accessor :properties
+
+  validates :event_type_name, :presence => true, :format => EVENT_TYPE_NAME.options
+
+  # 以下の２つはバリデーションを設定したいところですが、外部からの入力は極力保存できる
+  # ようにしたいのでバリデーションを外します。
+  # validates :source_name, :presence => true #, :format => RESOURCE_IDENTIFIER.options
+  # validates :sender_name, :presence => true #, :format => RESOURCE_IDENTIFIER.options
+
+  # 複数の経路から同じ意味のイベントが複数個送られる場合に
+  # これらを重複して登録しないようにユニーク制約を設定
+  index :key, unique: true
+  # :unique => trueのindexを設定しているので、uniquenessのバリデーションは設定しません
+  validates :key, :presence => true #, :uniqueness => true
+
+  index([ [:event_type_name, Mongo::ASCENDING], [:confirmed, Mongo::ASCENDING], ])
+  index([ [:event_type_name, Mongo::ASCENDING], [:level, Mongo::ASCENDING], [:occurred_at, Mongo::DESCENDING], ])
+  index([ [:event_type_name, Mongo::ASCENDING], [:occurred_at, Mongo::ASCENDING], ])
+  index([ [:event_type_name, Mongo::ASCENDING], [:source_name, Mongo::ASCENDING], ])
+  index([ [:level, Mongo::ASCENDING], [:sender_name, Mongo::ASCENDING], [:occurred_at, Mongo::DESCENDING], ])
+  index([ [:level, Mongo::ASCENDING], [:occurred_at, Mongo::DESCENDING], ])
+  index([ [:source_name, Mongo::ASCENDING], [:level, Mongo::ASCENDING], [:occurred_at, Mongo::DESCENDING], ])
+
+  # selectable_attrを使ってます
+  # see http://github.com/akm/selectable_attr
+  #     http://github.com/akm/selectable_attr_rails
+  selectable_attr :level do
+    entry 1, :debug       , "debug"
+    entry 2, :info        , "info"
+    entry 3, :warn        , "warn"
+    entry 4, :error       , "error"
+    entry 5, :fatal       , "fatal"
+  end
+
+  attr_accessor :kernel # tengined実行時に処理しているカーネルのインスタンスを保持します
+
+  def to_hash
+    ret = attributes.dup # <- dup ?
+    ret.delete "_id"
+    ret
+  end
+
+  # TODO: Tengine::Core::OptimisticLockを拡張して、ここでも使えるよう
+  # にする。現状は同じようなコードが複数箇所にあってよくない。
+
+  # @yield                      [event]                Yields the (possibly new) event.
+  # @yieldparam  [Tengine::Core::Event] event          The event in question.
+  # @yieldreturn              [Boolean]                Return false, and it will just break the execution.  Otherwise, it tries to update the event.
+  # @param                       [Hash] condition      Criteria to find a document.
+  # @param                    [Numeric] retry_max (3)  Maximum number of retry attempts to save the event.
+  # @return      [Tengine::Core::Event]                The event in question if update succeeded, false if retry_max reached, or nil if the block exited with false.
+  # @raise    [Mongo::OperationFailure]                Any exceptions that happened inside will be propagated outside.
+  def self.find_or_create_then_update_with_block condition, retry_max = 3
+    # * とある条件を満たすイベントがあれば、それを上書きしたい。
+    # * なければ、新規作成したい。
+    # * でもアトミックにやりたい。
+    # * ないとおもって新規作成しようとしたら裏でイベントが生えていたら、上書きモードでやり直したい。
+    # * あるとおもって上書きしようとしたら裏でイベントが消えていたら、新規作成モードでやり直したい。
+    # * という要求をできるだけ高速に処理したい。
+
+    the_event = nil
+    retries = -1
+    results = nil
+
+    case collection.driver.db.connection when Mongo::ReplSetConnection then
+      safemode = { :w => "majority", :wtimeout => 1024, } # mongodb 2.0+, 参加しているレプリカセットの多数派に書き込んだ時点でOK扱い
+    else
+      safemode = true
+    end
+
+    while true do
+      return false if retries >= retry_max # retryしすぎ
+
+      retries += 1
+      # あればとってくる
+      if the_event and not the_event.new_record?
+        the_event.reload
+      else
+        the_event = where(condition).first || new(condition)
+      end
+
+      return nil if not yield(the_event) # ユザーによる意図的な中断
+
+      hash = the_event.as_document.dup # <- dup ?
+      hash.delete "_id"
+      hash['lock_version'] = the_event.lock_version + 1
+      hash['created_at'] ||= Time.at(Time.now.to_i)
+      hash['updated_at'] = Time.at(Time.now.to_i)
+
+      begin
+        results = collection.driver.update(
+          { :key => the_event.key, :lock_version => the_event.lock_version },
+          { "$set" => hash },
+          { :upsert => true, :safe => safemode, :multiple => false }
+        )
+      rescue Mongo::OperationFailure => e
+        # upsert = trueだがindexのunique制約があるので重複したkeyは
+        # 作成不可、lock_versionの更新失敗はこちらに来る。これは意
+        # 図した動作なのでraiseしない。
+        Tengine.logger.debug "retrying due to mongodb error #{e}"
+        # lock_versionが存在しない可能性(そのような古いDBを引きずっている等)
+        collection.driver.update(
+          { :key => the_event.key, :lock_version => { "$exists" => false } },
+          { "$set" => { :lock_version => -(2**63) } },
+          { :upsert => false, :safe => $safemode, :multiple => false }
+        )
+      else
+        if results["error"]
+          raise Mongo::OperationFailure, results["error"]
+        elsif results["upserted"]
+          # *hack* _idを消してupsertしたので、このとき_idは新しくなっている
+          the_event.write_attributes "_id" => results["upserted"]
+          the_event.reload
+          return the_event
+        else
+          the_event.reload
+          return the_event
+        end
+      end
+    end
+  end
+end

data/lib/tengine/core/event/finder.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core/event'
+
+class Tengine::Core::Event::Finder
+
+  include ::SelectableAttr::Base
+
+  ATTRIBUTE_NAMES = [
+    :event_type_name,
+    :key,
+    :source_name,
+    :occurred_at_start,
+    :occurred_at_end,
+    :level_ids,
+    :confirmed,
+    :sender_name,
+    :properties,
+    :reflesh_interval, # 更新間隔
+  ].freeze
+
+  ATTRIBUTE_NAMES.each{|name| attr_accessor(name)}
+
+  # 通知レベル
+  multi_selectable_attr :level, :enum => Tengine::Core::Event.level_enum
+
+  def initialize(attrs = {})
+    attrs = {
+      :level_ids => default_level_ids
+    }.update(attrs || {})
+    attrs.each do |attr, v|
+      send("#{attr}=", v) unless v.blank?
+    end
+  end
+
+  def attributes
+    ATTRIBUTE_NAMES.inject({}){|d, name| d[name] = send(name); d}
+  end
+
+  # デフォルトでは通知レベルがすべて選択された状態にする
+  def default_level_ids
+    result = []
+    Tengine::Core::Event.level_entries.each do |entry|
+      result << entry.id
+    end
+    return result
+  end
+
+  def paginate(page = nil)
+    result = scope(Tengine::Core::Event)
+    if page || result.respond_to?(:page)
+      result = result.page(page)
+    end
+    result
+  end
+
+  def scope(criteria)
+    result = criteria
+    result = result.where(:event_type_name => str_or_regexp(event_type_name)) if event_type_name
+    result = result.where(:key => key)  if key
+    result = result.where(:source_name => str_or_regexp(source_name)) if source_name
+    result = result.where(:occurred_at.gte => occurred_at_start) if occurred_at_start
+    result = result.where(:occurred_at.lte =>  occurred_at_end) if occurred_at_end
+    result = result.any_in(:level => level_ids) if level_ids
+    result = result.where(:confirmed => confirmed) if confirmed
+    result = result.where(:sender_name => str_or_regexp(sender_name)) if sender_name
+    result = result.where(:properties => properties) if properties
+    # ソート
+    result = result.desc(:occurred_at)
+    result
+  end
+
+  private
+  def str_or_regexp(val)
+    if val =~ %r{\A\/(.+)\/\Z}
+      /#{$1}/
+    else
+      /\A#{Regexp.escape(val)}/
+    end
+  end
+
+end
+

data/lib/tengine/core/event_exception_reportable.rb

@@ -0,0 +1,88 @@
+require 'tengine/core'
+
+module Tengine::Core::EventExceptionReportable
+  extend ActiveSupport::Concern
+
+  FIRE_ALL = lambda do |kernel, dsl_context, event, exception|
+    kernel.fire("#{event.event_type_name}.error.tengined",
+      :properties => {
+        :original_event => event.to_json,
+        :error_class_name => exception.class.name,
+        :error_message => exception.message,
+        :error_backtrace => exception.backtrace,
+        # :block_source_location => '%s:%d' % block.source_location,
+      })
+  end
+
+  FIRE_EXCEPT_TESTING_ERROR = lambda do |kernel, dsl_context, event, exception|
+    if exception.class.name =~ /^Test::|^MiniTest::|^RSpec::|^Spec::/
+      raise exception
+    else
+      FIRE_ALL.call(kernel, dsl_context, event, exception)
+    end
+  end
+
+  RAISE_ALL = lambda do |kernel, dsl_context, event, exception|
+    raise exception
+  end
+
+  EVENT_EXCEPTION_REPORTERS = {
+    :fire_all => FIRE_ALL,
+    :raise_all => RAISE_ALL,
+    :except_test => FIRE_EXCEPT_TESTING_ERROR,
+  }.freeze
+
+  class << self
+    def to_reporter(reporter)
+      if reporter.is_a?(Symbol)
+        result = EVENT_EXCEPTION_REPORTERS[reporter]
+        raise NameError, "Unknown reporter: #{reporter.inspect}" unless result
+        result
+      elsif reporter.respond_to?(:call)
+        reporter
+      else
+        raise ArgumentError, "Invalid reporter: #{reporter.inspect}"
+      end
+    end
+  end
+
+  module ClassMethods
+    def event_exception_reporter
+      unless defined?(@event_exception_reporter)
+        @event_exception_reporter = FIRE_ALL
+      end
+      @event_exception_reporter
+    end
+
+    def event_exception_reporter=(reporter)
+      @event_exception_reporter =
+        Tengine::Core::EventExceptionReportable.to_reporter(reporter)
+    end
+
+    def temp_exception_reporter(reporter)
+      backup = self.event_exception_reporter
+      begin
+        self.event_exception_reporter = reporter
+        yield if block_given?
+      ensure
+        self.event_exception_reporter = backup
+      end
+    end
+
+  end
+
+  module InstanceMethods
+    def report_on_exception(dsl_context, event)
+      begin
+        yield
+      rescue Exception => e
+        Tengine.logger.error("[#{e.class.name}] #{e.message}\n  " << e.backtrace.join("\n  "))
+        if reporter = Tengine::Core::Kernel.event_exception_reporter
+          reporter.call(self, dsl_context, event, e)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/tengine/core/event_wrapper.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+class Tengine::Core::EventWrapper
+
+  def initialize(source)
+    @source = source
+  end
+
+  [:event_type_name, :key, :source_name, :occurred_at,
+    :level, :confirmed, :sender_name, :properties,].each do |attr_name|
+    class_eval(<<-EOS)
+      def #{attr_name}; @source.#{attr_name}; end
+    EOS
+  end
+
+  def [](key)
+    properties[key.to_s]
+  end
+
+end