tengine_core 0.5.28

data/lib/tengine/core/kernel_runtime.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+module Tengine::Core::KernelRuntime # Kernelにincludeされます
+
+  def safety_processing_headers(headers, event, ack_policy)
+    @ack_called = false
+    @processing_headers, @event, @ack_policy = headers, event, ack_policy
+    begin
+      yield if block_given?
+    ensure
+      @processing_headers, @event, @ack_policy = nil, nil, nil
+    end
+  end
+
+  def ack_policies
+    @ack_policies ||= { }
+  end
+
+  def add_ack_policy(event_type_name, policy)
+    ack_policies[event_type_name.to_s] = policy.to_sym
+  end
+
+  def ack_policy_for(event)
+    Tengine.logger.debug("ack_policies: #{ack_policies.inspect}")
+    ack_policy = ack_policies[event.event_type_name.to_s] || :at_first
+  end
+
+  def ack
+    unless @ack_called
+      @ack_called = true
+      @processing_headers.ack
+    end
+  end
+
+  def ack?
+    @ack_called
+  end
+
+
+  def submit
+    if @submitted_handlers
+      @submitted_handlers << @handler
+    end
+  end
+
+  def all_submitted?
+    return false if @submitted_handlers.nil? || @handlers.nil?
+    (@handlers - @submitted_handlers).empty?
+  end
+
+
+  def processing_event?; @processing_event; end
+
+
+  def em_setup_blocks
+    @em_setup_blocks ||= []
+  end
+
+  private
+
+  def safety_processing_event(headers)
+    @processing_event = true
+    begin
+      yield if block_given?
+    ensure
+      @processing_event = false
+    end
+  end
+
+  def safty_handlers(handlers)
+    @handlers = handlers
+    @submitted_handlers = (@ack_policy == :after_all_handler_submit ? [] : nil)
+    begin
+      yield if block_given?
+    ensure
+      @handlers = nil
+    end
+  end
+
+  def safety_handler(handler)
+    @handler = handler
+    @submitted_handler = nil
+    begin
+      yield if block_given?
+    ensure
+      @handler = nil
+    end
+  end
+
+end

data/lib/tengine/core/method_traceable.rb

@@ -0,0 +1,38 @@
+require 'tengine/core'
+
+module Tengine::Core::MethodTraceable
+
+  class << self
+    attr_accessor :disabled
+  end
+
+  def method_trace(*symbols)
+    symbols.each do |symbol|
+      original_method = :"_unmethod_traceable_#{symbol}"
+      class_eval(<<-EOS, __FILE__, __LINE__ +1)
+        if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
+          raise "Already method_tracing #{symbol}"                               #   raise "Already memoized mime_type"
+        end                                                                      # end
+        alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
+
+        def #{symbol}(*args, &block)
+          disabled = Tengine::Core::MethodTraceable.disabled
+          begin
+            Tengine::Core::stdout_logger.info("\#{self.class.name}##{symbol} called") unless disabled
+            result = #{original_method}(*args, &block)
+            Tengine::Core::stdout_logger.info("\#{self.class.name}##{symbol} complete") unless disabled
+            return result
+          rescue Exception => e
+            unless e.instance_variable_get(:@__traced__) || disabled
+              Tengine::Core::stderr_logger.error("\#{self.class.name}##{symbol} failure. [\#{e.class.name}] \#{e.message}\n  " << e.backtrace.join("\n  "))
+              e.instance_variable_set(:@__traced__, true)
+            end
+            raise
+          end
+        end
+
+      EOS
+    end
+  end
+
+end

data/lib/tengine/core/mongoid_fix.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+require 'tengine_core'
+require 'mongoid'
+require 'mongoid/version'
+require 'mongoid/cursor'
+
+if Mongoid::VERSION <= "3.0.0"
+  class Mongoid::Cursor
+    # https://github.com/mongoid/mongoid/pull/1609
+    def each
+      loop do
+        retry_on_connection_failure do
+          return unless document = cursor.next
+          yield Mongoid::Factory.from_db(klass, document)
+        end
+      end
+    end
+  end
+end

data/lib/tengine/core/mutex.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+# Tengine::Core::Mutexは(若干残念な実装の)分散ロック機構です。これを用
+# いることで、とあるMutexをロックしているプロセスを同時にたかだか一つに
+# 制限することが可能になります。
+#
+#     mutex = Tengine::Core::Mutex.new "foo"
+#     mutex.synchronize do
+#        ...
+#     end
+#
+# #### 問題点 ####
+#
+# このクラスは正しく使わないと正しく使えません。
+#
+# * スケールしません。当然の話ですが一カ所につき一つのプロセスしか動か
+#   ないので、何個プロセスを並列に動かしても無駄です。
+#
+# * トランザクションではありません。あくまでプロセスが同時に動くのを止
+#   めているだけです。データの整合性に関していっさい感知できません。
+#
+# * スピンロックです。MongoDBの制限による。したがって非効率です。
+#
+# * ロックしているプロセスが何かの弾みで死ぬかもしれないわけです。そう
+#   すると誰もアンロックできなくて詰みます。これを避けるために、一定の
+#   時間がたつとロックは勝手に外れるようになっています(一番残念な部分)。
+#   長時間ロックするようなプロセスは勝手にロックが外れないようにときど
+#   きロックを更新する必要があります。これにはheartbeatを使います。
+#
+#     mutex.synchronize do
+#        ...
+#        mutex.heartbeat
+#        ...
+#        mutex.heartbeat
+#        ...
+#        mutex.heartbeat
+#        ...
+#     end
+
+################################################################################
+
+# Poor man's distributed lock.
+Tengine::Core::Mutex = Struct.new :mutex, :_id, :recursive
+
+# @api private
+class Tengine::Core::Mutex::Mutex
+
+  include Mongoid::Document
+
+  field :ttl, :type => Float
+  field :waiters, :type => Array
+
+  def self.find_or_create name, ttl
+    collection.driver.update(
+      { :_id => name },
+      { "$set" => { :ttl => ttl, }, },
+      { :upsert => true, :safe => true, :multiple => false, }
+    )
+    return find(name)
+  end
+
+  private
+
+  # 暫定対応[Bug]mongodbフェールオーバ中にtengine_resource＿watchdが落ちてしまう
+  def _update q = {}, r
+    retry_count = 100
+    idx = 1
+    begin
+      self.class.collection.driver.update({ :_id => _id, }.update(q), r, {:safe=>true})
+      reload
+    rescue Mongo::ConnectionFailure => e
+      idx += 1
+      sleep 0.5
+      retry if retry_count > idx
+    end
+  end
+
+  public
+
+  # delete stale locks
+  def invalidate
+    # can this be done via standard mongoid queries?
+    _update("$pull" => { :waiters => { :timeout => { "$lt" => Time.now, }, }, } )
+  end
+
+  # attempt to gain lock
+  def lock id
+    _update("$push" => { :waiters => { :_id => id._id, :timeout => Time.now + ttl, }, })
+  end
+
+  # attempt to release lock
+  def unlock id
+    _update("$pull" => { :waiters => { :_id => id._id, }, })
+  end
+
+  # attempt to refresh lock
+  def heartbeat id
+    _update(
+      { :_id => _id, "waiters._id" => id._id, },
+      { "$set" => { "waiters.$.timeout" => Time.now + ttl, }, }
+    )
+  end
+end
+
+class Tengine::Core::Mutex
+
+  class << self
+
+    alias oldnew new
+    private :oldnew
+
+    # @param [String]  name  Mutex name.  One process at once can gain a lock against a name.
+    # @param [Numeric] ttl   Time to auto-release a gained lock.
+    # @return [Tengine::Core::Mutex] An instance.
+    def new name, ttl=2.048
+      t = 0.0 + ttl # type check
+      raise TypeError, "finite numeric expected (got #{t})" unless t.finite?
+      raise ArgumentError, "TTL doesn't make sense." unless t > 0
+
+      return oldnew(Tengine::Core::Mutex::Mutex.find_or_create(name, t), BSON::ObjectId.new, 0)
+    end
+  end
+
+  private
+
+  def lock_attempt
+    m = mutex
+    m.invalidate
+    m.lock self
+    return m.waiters.first["_id"] == _id
+  end
+
+  def lock
+    if lock_attempt
+      self.recursive += 1
+    end
+  end
+
+  def unlock
+    self.recursive -= 1
+    if self.recursive <= 0
+      mutex.unlock self
+    end
+  end
+
+  public
+
+  # delays until you get a lock.
+  def synchronize
+    raise ArgumentError, "no block given" unless block_given?
+
+    if lock
+      # OK, locked
+      EM.schedule do
+        begin
+          heartbeat
+          yield
+        ensure
+          unlock
+        end
+      end
+    else
+      # NG, try again later
+      EM.add_timer mutex.ttl do
+        synchronize do
+          yield
+        end
+      end
+    end
+  end
+
+  # If you need to lock it longer than ttl, call this and you can refresh the ttl.
+  def heartbeat
+    mutex.heartbeat self
+  end
+end

data/lib/tengine/core/optimistic_lock.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+require 'active_support/core_ext/array/extract_options'
+
+module Tengine::Core::OptimisticLock
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :lock_optimistically, :instance_writer => false
+    self.lock_optimistically = true
+
+    class << self
+      alias_method :locking_field=, :set_locking_field
+    end
+  end
+
+  class RetryOverError < StandardError
+  end
+
+  def update_with_lock(options = {})
+    retry_count = options[:retry] || 5
+    idx = 1
+    while idx <= retry_count
+      yield
+      return if __find_and_modify__
+      reload
+      idx += 1
+    end
+    raise RetryOverError, "retried #{retry_count} times but failed to update"
+  end
+
+  def __find_and_modify__
+    lock_field_name = self.class.locking_field
+    current_version = self.send(lock_field_name)
+    hash = as_document.dup
+    new_version = current_version + 1
+    hash[lock_field_name] = new_version
+    result = self.class.collection.find_and_modify({
+        :query => {:_id => self.id, lock_field_name.to_sym => current_version},
+        :update => hash
+      })
+    send("#{lock_field_name}=", new_version)
+    result
+  end
+
+  # ActiveRecord::Locking::Optimistic::ClassMethods を参考に実装しています
+  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/locking/optimistic.rb
+  module ClassMethods
+    DEFAULT_LOCKING_FIELD = 'lock_version'.freeze
+
+    # Set the field to use for optimistic locking. Defaults to +lock_version+.
+    def set_locking_field(value = nil, &block)
+      define_attr_method :locking_field, value, &block
+      value
+    end
+
+    # The version field used for optimistic locking. Defaults to +lock_version+.
+    def locking_field
+      reset_locking_field
+    end
+
+    # Reset the field used for optimistic locking back to the +lock_version+ default.
+    def reset_locking_field
+      set_locking_field DEFAULT_LOCKING_FIELD
+    end
+  end
+
+end

data/lib/tengine/core/plugins.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+class Tengine::Core::Plugins
+  attr_reader :modules
+
+  def initialize
+    @modules = []
+  end
+
+  def add(plugin_module)
+    return if modules.include?(plugin_module)
+    Tengine::Core.stdout_logger.info("#{self.class.name}#add(#{plugin_module.name})")
+    modules << plugin_module
+    enable_plugin(plugin_module)
+    plugin_module
+  end
+
+  def notify(sender, msg)
+    if block_given?
+      notify(sender, :"before_#{msg}")
+      yield
+      notify(sender, :"after_#{msg}")
+    else
+      modules.each do |m|
+        m.notify(sender, msg) if m.respond_to?(:notify)
+      end
+    end
+  end
+
+
+  # 自動でログ出力する
+  extend Tengine::Core::MethodTraceable
+  method_trace(:add)
+
+  private
+  def enable_plugin(plugin_module)
+    if loader = find_sub_module(plugin_module, :DslLoader, :dsl_loader)
+      # Tengine::Core::DslLoadingContext.send(:include, loader)
+      Tengine::Core::Kernel.top.singleton_class.send(:include, loader)
+    end
+    if binder = find_sub_module(plugin_module, :DslBinder, :dsl_binder)
+      # Tengine::Core::DslBindingContext.send(:include, binder)
+      # Tengine::Core::Kernel.top.singleton_class.send(:include, binder)
+    end
+  end
+
+  private
+  def find_sub_module(plugin_module, const_name, method_name)
+    plugin_module.const_defined?(const_name) ? plugin_module.const_get(const_name) :
+      plugin_module.respond_to?(method_name) ? plugin_module.send(method_name) : nil
+  end
+
+end