tengine_core 0.5.39 → 1.1.0

data/lib/tengine/core/dsl_evaluator.rb

@@ -67,25 +67,12 @@ module Tengine::Core::DslEvaluator
   def __setup_core_ext__
     Symbol.class_eval do
       def and(other)
-        Tengine::Core::DslFilterDef.new(
-          [self.to_s, other.to_s],
-          {
-            'method' => :and,
-            'children' => [
-              { 'pattern' => self, 'method' => :find_or_mark_in_session },
-              { 'pattern' => other, 'method' => :find_or_mark_in_session },
-            ]
-          })
+        Tengine::Core::DslFilterDef.new_and(self, other)
       end
       alias_method :&, :and
 
       def at(soruce_pattern)
-        Tengine::Core::DslFilterDef.new(
-          [self.to_s],
-          {
-            'method' => :match_source_name?,
-            'pattern' => soruce_pattern.to_s,
-          })
+        Tengine::Core::DslFilterDef.new_at(self, soruce_pattern)
       end
     end
   end

data/lib/tengine/core/dsl_filter_def.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'tengine/core'
 
 class Tengine::Core::DslFilterDef
@@ -8,4 +9,43 @@ class Tengine::Core::DslFilterDef
     @filter = filter
   end
 
+  BRACE_FORMAT = 's_%s_e'.freeze # メソッド名にはカッコが使えないので変わりに表現する方法として(と)をそれぞれs_と_eで表します。
+
+  FORMATTERS = {
+    :and => lambda{|event_type_names, filter| "%s_and_%s" % event_type_names },
+    :at  => lambda{|event_type_names, filter| "%s_at_%s" % [event_type_names.first, filter['pattern'].to_s] },
+  }
+
+  def to_method_name
+    event_type_name_args =
+      event_type_names.map{|obj| obj.is_a?(Tengine::Core::DslFilterDef) ? obj.to_method_name : obj.to_s}
+    formatter = FORMATTERS[ filter['type'] ]
+    BRACE_FORMAT % formatter.call(event_type_name_args, filter)
+  end
+
+  class << self
+    def new_and(left, right)
+      Tengine::Core::DslFilterDef.new(
+        [left, right],
+        {
+          'type' => :and,
+          'method' => :and,
+          'children' => [
+            { 'pattern' => left, 'method' => :find_or_mark_in_session },
+            { 'pattern' => right, 'method' => :find_or_mark_in_session },
+          ]
+        })
+    end
+
+    def new_at(event_type_name, source_pattern)
+      Tengine::Core::DslFilterDef.new(
+        [event_type_name],
+        {
+          'type' => :at,
+          'method' => :match_source_name?,
+          'pattern' => source_pattern.to_s,
+        })
+    end
+
+  end
 end

data/lib/tengine/core/dsl_loader.rb

@@ -58,7 +58,7 @@ module Tengine::Core::DslLoader
       return
     end
 
-    if dsl_version_document = Tengine::Core::Setting.first(:conditions => {:name => "dsl_version"})
+    if dsl_version_document = Tengine::Core::Setting.where({:name => "dsl_version"}).first
       dsl_version_document.value = config.dsl_version
       dsl_version_document.save!
     else

data/lib/tengine/core/event.rb

@@ -32,17 +32,16 @@ class Tengine::Core::Event
 
   # 複数の経路から同じ意味のイベントが複数個送られる場合に
   # これらを重複して登録しないようにユニーク制約を設定
-  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], ])
+  index({ key: 1}, {unique: true})
+  validates :key, :presence => true, :uniqueness => true
+
+  index event_type_name: 1, confirmed:1
+  index event_type_name: 1, level:1, occurred_at: -1
+  index event_type_name: 1, occurred_at: 1
+  index event_type_name: 1, source_name:1
+  index level: 1, sender_name: 1, occurred_at: -1
+  index level: 1, occurred_at: -1
+  index source_name: 1, level: 1, occurred_at: -1
 
   # selectable_attrを使ってます
   # see http://github.com/akm/selectable_attr
@@ -86,11 +85,7 @@ class Tengine::Core::Event
     retries = -1
     results = nil
 
-    case collection.driver.db.connection when Mongo::ReplSetConnection then
-      safemode = { :w => "majority", :wtimeout => wtimeout, } # mongodb 2.0+, 参加しているレプリカセットの多数派に書き込んだ時点でOK扱い
-    else
-      safemode = true
-    end
+    safemode = Tengine::Core::SafeUpdatable.safemode(collection, wtimeout)
 
     while true do
       return false if retries >= retry_max # retryしすぎ
@@ -111,29 +106,47 @@ class Tengine::Core::Event
       hash['created_at'] ||= Time.at(Time.now.to_i)
       hash['updated_at'] = Time.at(Time.now.to_i)
 
+      results = nil
       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
+        # Can't, no results returned...
+        # results = with(safe: safemode).where(
+        #   key: the_event.key, lock_version: the_event.lock_version
+        # ).update(
+        #   "$set" => hash,
+        #   flags: [ :upsert ]
+        # )
+        mongo_session.with(safe: safemode) do |ss|
+          col = ss[collection.name]
+          results = ss.context.update(
+            col.database.name,
+            col.name,
+            { key: the_event.key, lock_version: the_event.lock_version },
+            { "$set" => hash },
+            flags: [ :upsert ]
+          )
+        end
+      rescue Moped::Errors::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 }
-        )
+        mongo_session.with(safe: safemode) do |ss|
+          col = ss[collection.name]
+          results = ss.context.update(
+            col.database.name,
+            col.name,
+            { "$query" => { key: the_event.key, lock_version: { "$exists" => false} } },
+            { "$set" => { lock_version: -(2**63) } },
+          )
+        end
+        # again
       else
         if results["error"]
-          raise Mongo::OperationFailure, results["error"]
+          raise Moped::Errors::OperationFailure, results["error"]
         elsif results["upserted"]
           # *hack* _idを消してupsertしたので、このとき_idは新しくなっている
-          the_event.write_attributes "_id" => results["upserted"]
+          the_event._id = results["upserted"]
           the_event.reload
           return the_event
         else
@@ -142,5 +155,7 @@ class Tengine::Core::Event
         end
       end
     end
+rescue Exception
+p $!
   end
 end

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

@@ -15,7 +15,7 @@ class Tengine::Core::Event::Finder
     :confirmed,
     :sender_name,
     :properties,
-    :reflesh_interval, # 更新間隔
+    :refresh_interval, # 更新間隔
   ].freeze
 
   ATTRIBUTE_NAMES.each{|name| attr_accessor(name)}

data/lib/tengine/core/event_exception_reportable.rb

@@ -71,18 +71,15 @@ module Tengine::Core::EventExceptionReportable
 
   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
+  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

data/lib/tengine/core/event_wrapper.rb

@@ -8,7 +8,7 @@ class Tengine::Core::EventWrapper
   end
 
   [:event_type_name, :key, :source_name, :occurred_at,
-    :level, :confirmed, :sender_name, :properties,].each do |attr_name|
+    :level, :level_key, :confirmed, :sender_name, :properties,].each do |attr_name|
     class_eval(<<-EOS)
       def #{attr_name}; @source.#{attr_name}; end
     EOS

data/lib/tengine/core/find_by_name.rb

@@ -19,7 +19,7 @@ module Tengine::Core::FindByName
 
   module ClassMethods
     def find_by_name(name)
-      first(:conditions => {:name => name})
+      where({:name => name}).first
     end
 
     def find_by_name!(name, *args, &block)

data/lib/tengine/core/handler.rb

@@ -103,9 +103,19 @@ class Tengine::Core::Handler
       @filter = filter
       @event = event
       @session = Tengine::Core::SessionWrapper.new(session)
+      @session_reloaded = false
       @current = @filter
     end
 
+    def session
+      unless @session_reloaded
+        @session.reload
+        @session_reloaded = true
+      end
+      @session
+    end
+
+
     def visit
       Tengine.logger.debug("visiting #{@current.inspect}")
       send(@current['method'])
@@ -131,13 +141,13 @@ class Tengine::Core::Handler
       name = @current['pattern'].to_s
       key = "mark_#{name}"
       if name == @event.event_type_name
-        unless @session.system_properties[key]
-          @session.system_update(key => true)
-          Tengine.logger.debug("session.system_updated #{@session.system_properties.inspect}")
+        if session.system_properties[key].nil?
+          session.system_update(key => true)
+          Tengine.logger.debug("session.system_updated #{session.system_properties.inspect}")
         end
         return true
       else
-        return @session.system_properties[key]
+        return session.system_properties[key]
       end
     end
 

data/lib/tengine/core/handler_path.rb

@@ -11,7 +11,7 @@ class Tengine::Core::HandlerPath
 
   scope(:event_type_name, lambda{|v| where(:event_type_name => v)})
 
-  index([ [:event_type_name, Mongo::ASCENDING], [:_id, Mongo::ASCENDING], ])
+  index event_type_name: 1, _id: 1
 
   class << self
     def find_handlers(event_type_name)

data/lib/tengine/core/heartbeat_watcher.rb

@@ -116,8 +116,9 @@ class Tengine::Core::HeartbeatWatcher
   def start
     @config.setup_loggers
 
-    Mongoid.config.from_hash @config[:db]
-    Mongoid.config.option :persist_in_safe_mode, :default => true
+    Mongoid.configure do |c|
+      c.send :load_configuration, @config[:db]
+    end
 
     require 'amqp'
     Mongoid.logger = AMQP::Session.logger = Tengine.logger

data/lib/tengine/core/kernel.rb

@@ -34,6 +34,7 @@ class Tengine::Core::Kernel
       update_status(:waiting_activation)
       wait_for_activation(&block)
     else
+      require 'profile' if ENV['tengined_profile']
       activate(&block)
     end
   end
@@ -78,10 +79,10 @@ class Tengine::Core::Kernel
   alias_method :context, :dsl_context
 
   def evaluate
+    Tengine::Core::Driver.delete_all_with_handler_paths(dsl_context.config.dsl_version)
     dsl_context.__evaluate__
   end
 
-
   def bind
     # dsl_context.__evaluate__
     # Tengine::Core::stdout_logger.debug("Hanlder bindings:\n" << dsl_context.to_a.inspect)
@@ -132,6 +133,8 @@ class Tengine::Core::Kernel
     end
     mq.subscribe(:ack => true, :nowait => false, :confirm => confirm) do |headers, msg|
       process_message(headers, msg)
+      # headers.ack
+      # Tengine.logger.debug("headers: #{headers.inspect}\n#{msg}")
     end
   end
 
@@ -170,7 +173,7 @@ class Tengine::Core::Kernel
                   save_event(raw_event)
                 end
 
-      rescue Mongo::OperationFailure, Mongoid::Errors::Validations => e
+      rescue Moped::Errors::OperationFailure, Mongoid::Errors::Validations => e
         Tengine.logger.warn("failed to store an event.\n[#{e.class.name}] #{e.message}")
         event = nil
       rescue Exception => e
@@ -184,7 +187,7 @@ class Tengine::Core::Kernel
 
         begin
           n = Tengine::Core::Event.where(:key => raw_event.key, :sender_name => raw_event.sender_name).count
-        rescue Mongo::ConnectionFailure, Mongo::OperationTimeout, Mongo::OperationFailure => e
+        rescue Moped::Errors::ConnectionFailure, Moped::Errors::OperationFailure => e
           Tengine.logger.error("giving up processing an event due to #{e} (#{e.class.name})")
           n = 0
         end
@@ -204,6 +207,19 @@ class Tengine::Core::Kernel
         ack_policy = ack_policy_for(event)
         safety_processing_headers(headers, event, ack_policy) do
           ack if ack_policy == :at_first
+
+          # ドライバを再ロードするならハンドラを検索する前に行います。
+          unless config.tengined.cache_drivers
+            Tengine::Core::Driveable.__remember_session_ids_for_drivers__(config.dsl_version)
+            begin
+              Tengine::Core::Driver.delete_all_with_handler_paths(dsl_context.config.dsl_version)
+              ActiveSupport::Dependencies.clear
+              evaluate
+            ensure
+              Tengine::Core::Driveable.__forget_session_ids_for_drivers__
+            end
+          end
+
           handlers = find_handlers(event)
           safty_handlers(handlers) do
             delegate(event, handlers)
@@ -213,7 +229,7 @@ class Tengine::Core::Kernel
         end
         close_if_shutting_down
         true
-      rescue Mongo::ConnectionFailure, Mongo::OperationTimeout, Mongo::OperationFailure => e
+      rescue Moped::Errors::ConnectionFailure, Moped::Errors::OperationFailure => e
         Tengine.logger.error("giving up processing an event due to #{e} (#{e.class.name})")
         Tengine.logger.info("requeue an event #{raw_event.inspect}")
         headers.reject(:requeue => true)
@@ -325,7 +341,7 @@ class Tengine::Core::Kernel
       raw_event.attributes.update(:confirmed => (raw_event.level.to_i <= config.confirmation_threshold)))
     Tengine.logger.debug("saved an event #{event.inspect}")
     event
-  rescue Mongo::OperationFailure => e
+  rescue Moped::Errors::OperationFailure => e
     Tengine.logger.error("failed to save an event #{raw_event.inspect}\n[#{e.class.name}] #{e.message}")
     # FIXME!!
     # このままではログに埋もれてしまうのでなんとかすべき。
@@ -402,6 +418,7 @@ class Tengine::Core::Kernel
       # * もうngが保存されているとき
       if event.new_record? or event.event_type_name != raw_event.event_type_name
         event.write_attributes raw_event.attributes.update(:confirmed => (raw_event.level.to_i <= config.confirmation_threshold))
+        event.occurred_at = Time.now
       else
         nil
       end
@@ -464,7 +481,6 @@ class Tengine::Core::Kernel
       end
     end
     after_delegate.call if after_delegate.respond_to?(:call)
-    ActiveSupport::Dependencies.clear unless config.tengined.cache_drivers
   end
 
   def close_if_shutting_down

data/lib/tengine/core/mongoid_fix.rb

@@ -3,9 +3,10 @@
 require 'tengine_core'
 require 'mongoid'
 require 'mongoid/version'
-require 'mongoid/cursor'
 
 if Mongoid::VERSION < "3.0.0"
+  require 'mongoid/cursor'
+
   class Mongoid::Cursor
     # https://github.com/mongoid/mongoid/pull/1609
     def each

data/lib/tengine/core/mutex.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 require 'tengine/core'
+require 'moped' # part of mongoid 3
 
 require_relative 'safe_updatable'
 
@@ -54,13 +55,26 @@ class Tengine::Core::Mutex::Mutex
   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)
+  class << self
+    def static_bson_objectids
+      @static_bson_objectids ||= {}
+    end
+
+    def clear_static_bson_objectids
+      @static_bson_objectids = nil
+    end
+
+    def add_static_bson_objectid(name, objectid)
+      static_bson_objectids[name] = objectid.is_a?(Moped::BSON::ObjectId) ? objectid :
+        Moped::BSON::ObjectId.from_string(objectid.to_s)
+    end
+
+    def find_or_create name, ttl
+      id = Moped::BSON::ObjectId.legal?(name) ? name : static_bson_objectids[name] or
+        raise ArgumentError, "Unknown name for BSON::ObjectId: #{name.inspect}"
+      collection.find(_id: id).upsert(_id: id, ttl: ttl)
+      return find(id)
+    end
   end
 
   private
@@ -117,7 +131,7 @@ class Tengine::Core::Mutex
       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)
+      return oldnew(Tengine::Core::Mutex::Mutex.find_or_create(name, t), Moped::BSON::ObjectId.new, 0)
     end
   end