tengine_core 0.5.28

data/examples2/uc62_session_in_driver.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+class Uc62SessionInDriver
+  include Tengine::Core::Driveable
+
+  session.update(:foo => 100) # ドライバ登録時にそのセッションに キー:foo に対して 値100 を設定する。
+
+  on:event62
+  def event62
+    value = session[:foo]
+    value +=1
+    session.update(:foo => value)
+    puts value
+  end
+end

data/examples2/uc71_driver_disabled_on_activation.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+class Uc71DriverDisabledOnActivation
+  include Tengine::Core::Driveable
+  include Tengine::Core::Driveable::ByDsl
+
+  self.singleton_class.options = { :enabled_on_activation => false }
+
+  # イベントに対応する処理の実行する
+  on:event71
+  def event71
+    puts "handler71"
+  end
+
+end

data/failure_examples/VERSION

@@ -0,0 +1 @@
+20110902213500

data/failure_examples/uc53_submit_outside_of_handler.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+# submitメソッドは、ハンドラ内でのみ使用できるので、ハンドラ外で使用した場合例外がraiseされる。
+# loadでもbindでも途中で失敗し、Tengineコアのプロセスは終了する
+ack_policy(:at_first, :event53)
+
+driver :driver53 do
+  submit # SyntaxErrorなどではなく、Tengine::Core::DslErrorがraiseされる
+
+  on:event53 do
+    puts "handler53"
+  end
+
+end

data/failure_examples/uc61_event_outside_of_handler.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+# eventメソッドはハンドラ内でのみ使用できるものなのでその外で使用したら例外がraiseされる。
+# loadでもbindでも途中で失敗し、Tengineコアのプロセスは終了する
+
+driver :driver61 do
+  event # SyntaxErrorではなく、Tengine::Core::DslErrorがraiseされる
+
+  on:event61 do
+  end
+end

data/failure_examples/uc63_session_outside_of_driver.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+# sessionメソッドは、ドライバ内でのみ使用できるので、ドライバ外で使用した場合例外がraiseされる。
+# loadでもbindでも途中で失敗し、Tengineコアのプロセスは終了する
+
+session # SyntaxErrorなどではなく、Tengine::Core::DslErrorがraiseされる
+
+driver :driver63 do
+
+  on:event63 do
+  end
+end

data/lib/tengine/core.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+require 'tengine_core'
+require 'logger'
+
+module Tengine::Core
+  # base
+  autoload :Bootstrap        , 'tengine/core/bootstrap'
+  autoload :Config           , 'tengine/core/config'
+  autoload :Kernel           , 'tengine/core/kernel'
+  autoload :Driveable        , 'tengine/core/driveable'
+  autoload :KernelRuntime    , 'tengine/core/kernel_runtime'
+  autoload :DslEvaluator     , 'tengine/core/dsl_evaluator'
+  autoload :DslLoader        , 'tengine/core/dsl_loader'
+  autoload :DslFilterDef     , 'tengine/core/dsl_filter_def'
+  autoload :Plugins          , 'tengine/core/plugins'
+
+  # models
+  autoload :Event      , 'tengine/core/event'
+  autoload :Driver     , 'tengine/core/driver'
+  autoload :Session    , 'tengine/core/session'
+  autoload :Handler    , 'tengine/core/handler'
+  autoload :HandlerPath, 'tengine/core/handler_path'
+  autoload :Setting    , 'tengine/core/setting'
+  autoload :Schedule   , 'tengine/core/schedule'
+
+  # model wrappers
+  autoload :EventWrapper  , 'tengine/core/event_wrapper'
+  autoload :SessionWrapper, 'tengine/core/session_wrapper'
+
+  # utilities
+  autoload :CollectionAccessible, 'tengine/core/collection_accessible'
+  autoload :IoToLogger          , 'tengine/core/io_to_logger'
+  autoload :SelectableAttr      , 'tengine/core/selectable_attr'
+  autoload :MethodTraceable     , 'tengine/core/method_traceable'
+  autoload :OptimisticLock      , 'tengine/core/optimistic_lock'
+  autoload :Validation          , 'tengine/core/validation'
+  autoload :EventExceptionReportable, 'tengine/core/event_exception_reportable'
+  autoload :FindByName          , 'tengine/core/find_by_name'
+  autoload :Mutex               , 'tengine/core/mutex'
+
+  class << self
+    # Tengine::Coreの正常時の動きをアプリケーション運用者が確認できる内容を出力するロガー
+    # ログレベルがinfoでも出力する内容は少ない
+    def stdout_logger
+      @stdout_logger ||= Logger.new(STDOUT)
+    end
+    attr_writer :stdout_logger
+
+    # Tengine::Coreの異常発生時の動きをアプリケーション運用者が確認できる内容を出力するロガー
+    def stderr_logger
+      @stderr_logger ||= Logger.new(STDERR)
+    end
+    attr_writer :stderr_logger
+
+    # リリースされたtengine_coreパッケージのバージョンを返します
+    def version
+      File.read(File.expand_path("../../VERSION", File.dirname(__FILE__))).strip
+    end
+  end
+
+  # 設定に問題があることを示す例外
+  class ConfigError < StandardError
+  end
+
+  # DSLの記述に問題があることを示す例外
+  class DslError < ::Tengine::DslError
+  end
+
+  # カーネルの動作で問題が発生した場合にraiseする例外
+  class KernelError < StandardError
+  end
+
+
+end

data/lib/tengine/core/bootstrap.rb

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+require 'tengine/event'
+require 'tengine/mq'
+require 'eventmachine'
+
+class Tengine::Core::Bootstrap
+
+  attr_accessor :config
+  attr_writer :kernel
+
+  def initialize(hash)
+    @config = Tengine::Core::Config::Core[hash]
+    prepare_trap
+  end
+
+  def prepare_trap; Signal.trap(:HUP) { kernel.stop } end
+
+  DEBUG_CONFIG_ATTRS = [:dsl_dir_path, :dsl_file_paths, :dsl_version_path, :dsl_version].freeze
+
+  def boot
+    Tengine::Core.stdout_logger.debug(DEBUG_CONFIG_ATTRS.map{|attr| "#{attr}: " << config.send(attr).inspect}.join(", "))
+    case config[:action]
+    when "load" then load_dsl
+    when "start" then
+      load_dsl # unless config[:tengined][:skip_load]
+      start_kernel do
+        # ここでイベントを待つ
+      end
+    when "test" then test_connection
+    when "enable" then enable_drivers
+    else
+      raise ArgumentError, "config[:action] in boot method must be test|load|start|enable but was #{config[:action]} "
+    end
+  end
+
+  def load_dsl
+    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
+    Tengine.plugins.notify(self, :load_dsl) do
+      context = kernel.dsl_context
+      context.__evaluate__
+    end
+  end
+
+  def kernel
+    @kernel ||= Tengine::Core::Kernel.new(config)
+  end
+
+  def start_kernel(&block)
+    Tengine.plugins.notify(self, :start_kernel) do
+      kernel.start(&block)
+    end
+  end
+
+  def stop_kernel
+    Tengine.plugins.notify(self, :stop_kernel) do
+      kernel.stop
+    end
+  end
+
+  def enable_drivers
+    drivers = Tengine::Core::Driver.where(:version => config.dsl_version, :enabled_on_activation => true)
+    drivers.each{ |d| d.update_attribute(:enabled, true) }
+  end
+
+  def test_connection
+    config[:tengined][:load_path] = File.expand_path("connection_test/fire_bar_on_foo.rb", File.dirname(__FILE__))
+    config.prepare_dir_and_paths(true)
+
+    begin
+      load_dsl
+      start_kernel do |mq| # このブロックは Tengine::Core::Kernel#activateのEM.runに渡されたブロックから呼び出されます。
+        teardown = lambda do |result|
+          EM.next_tick do
+            Tengine::Core.stdout_logger.info(result)
+            stop_kernel
+          end
+        end
+        # http://keijinsonyaban.blogspot.com/2010/12/eventmachine.html のEM.defer(op, callback)を参照
+        EM.defer(lambda{start_connection_test(mq)}, teardown)
+      end
+      Tengine::Core::stdout_logger.info("Connection test success.")
+    rescue Exception => e
+      Tengine::Core::stderr_logger.error("Connection test failure: [#{e.class.name}] #{e.message}")
+    end
+  end
+
+  def start_connection_test(mq)
+    require 'timeout'
+    timeout(10) do
+      connection_test_completed = false
+      Tengine.callback_for_test = lambda do |event_type_name|
+        case event_type_name
+        when :foo then
+          Tengine::Core.stdout_logger.info("handing :foo successfully.")
+        when :bar then
+          Tengine::Core.stdout_logger.info("handing :bar successfully.")
+          connection_test_completed = true
+        else
+          Tengine::Core.stderr_logger.error("Unexpected event: #{event_type_name}")
+        end
+      end
+      Tengine::Event.instance_variable_set(:@mq_suite, mq)
+      Tengine::Event.fire(:foo, :level_key => :info, :keep_connection => true)
+      loop do
+        sleep(0.1)
+        return if connection_test_completed
+      end
+    end
+  end
+
+  # 自動でログ出力する
+  extend Tengine::Core::MethodTraceable
+  method_trace(:prepare_trap, :boot, :load_dsl, :start_kernel, :stop_kernel,
+    :enable_drivers, :test_connection, :start_connection_test)
+
+end

data/lib/tengine/core/collection_accessible.rb

@@ -0,0 +1,34 @@
+require 'tengine/core'
+
+module Tengine::Core::CollectionAccessible
+
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def array_text_accessor(attr_name, options = {})
+      options = {:delimeter => ","}.update(options || {})
+      delimeter = options[:delimeter]
+      self.module_eval(<<-"EOS", __FILE__, __LINE__ + 1)
+        def #{attr_name}_text
+          #{attr_name} ? #{attr_name}.join(#{delimeter.inspect}) : ""
+        end
+        def #{attr_name}_text=(value)
+          self.#{attr_name} = value.nil? ? [] :
+            value.split(#{delimeter.inspect}).map(&:strip)
+        end
+      EOS
+    end
+
+    def map_yaml_accessor(attr_name)
+      self.module_eval(<<-"EOS", __FILE__, __LINE__ + 1)
+        def #{attr_name}_yaml
+          YAML.dump({}.update(#{attr_name} || {}))
+        end
+        def #{attr_name}_yaml=(value)
+          self.#{attr_name} = value.blank? ? nil : YAML.load(value)
+        end
+      EOS
+    end
+  end
+
+end

data/lib/tengine/core/config.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core'
+
+# require 'tengine/core/config/default' # DEFAULT定数と関係するメソッドを定義
+
+module Tengine::Core::Config
+  autoload :Core, 'tengine/core/config/core'
+  autoload :Atd,  'tengine/core/config/atd'
+  autoload :HeartbeatWatcher,  'tengine/core/config/heartbeat_watcher'
+end

data/lib/tengine/core/config/atd.rb

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+require 'tengine/core/config'
+
+require 'yaml'
+require 'optparse'
+require 'active_support/memoizable'
+
+require 'tengine/support/yaml_with_erb'
+
+Tengine::Support::Config::Definition::Group.module_eval do
+  def symbolize_keys
+    to_hash
+  end
+end
+
+class Tengine::Core::Config::Atd < Tengine::Support::Config::Definition::Suite
+  # memoize については http://wota.jp/ac/?date=20081025#p11 などを参照してください
+  extend ActiveSupport::Memoizable
+
+  class << self
+    # この辺は以前のTengine::Core::Configとの互換のために用意してあります
+    def [](hash_or_suite)
+      case hash_or_suite
+      when Tengine::Core::Config::Atd then hash_or_suite
+      when Hash then
+        result = Tengine::Core::Config::Atd.new
+        result.load(hash_or_suite)
+        result
+      else
+        raise "unsupported class: #{hash_or_suite.class.inspect}"
+      end
+    end
+
+    def default_hash
+      new.to_hash
+    end
+    alias_method :skelton_hash, :default_hash
+
+    def parse_to_hash(args)
+      config = new
+      config.parse!(args)
+      result = new
+      result.config = config.config
+      result.to_hash
+    end
+
+    def parse(args)
+      config = new
+      config.parse!(args)
+      config
+    end
+
+  end
+
+  def initialize(hash_or_filepath = nil)
+    build if respond_to?(:build)
+    case hash_or_filepath
+    when Hash then
+      if config = hash_or_filepath[:config]
+        load_file(config)
+      else
+        load(hash_or_filepath)
+      end
+    when String then load_file(hash_or_filepath)
+    end
+  end
+
+  def load_file(filepath)
+    super
+  rescue Exception => e
+    msg = e.message
+    unless msg.include?(filepath)
+      msg = "#{msg} in #{filepath}"
+    end
+    raise Tengine::Core::ConfigError, msg
+  end
+
+
+  def build
+    banner <<EOS
+Usage: tengine_atd [-k action] [-f path_to_config] [-D process_daemon]
+         [-o mq_conn_host] [-p mq_conn_port] [-u mq_conn_user]
+         [-s mq_conn_pass] [-e mq_exchange_name] [-q mq_queue_name]
+         [-G heartbeat_atd_interval]
+EOS
+
+    field(:action, "start|stop", :type => :string, :default => "start")
+    load_config(:config, "path/to/config_file", :type => :string)
+
+    add(:process, Tengine::Core::Config::Atd::Process)
+    field(:db, "settings to connect to db", :type => :hash, :default => {
+        'host' => 'localhost',
+        'port' => 27017,
+        'username' => nil,
+        'password' => nil,
+        'database' => 'tengine_production',
+      })
+
+    group(:heartbeat) do
+      add(:atd      , Tengine::Core::Config::Core::Heartbeat)
+    end
+
+    group(:event_queue, :hidden => true) do
+      add(:connection, AmqpConnection)
+      add(:exchange  , Tengine::Support::Config::Amqp::Exchange, :defaults => {:name => 'tengine_event_exchange'})
+      add(:queue     , Tengine::Support::Config::Amqp::Queue   , :defaults => {:name => 'tengine_event_queue'})
+    end
+
+    add(:log_common, Tengine::Support::Config::Logger,
+      :defaults => {
+        :rotation      => 3          ,
+        :rotation_size => 1024 * 1024,
+        :level         => 'info'     ,
+      })
+    add(:application_log, Tengine::Core::Config::Atd::LoggerConfig,
+      :parameters => {:logger_name => "application"},
+      :dependencies => { :process_config => :process, :log_common => :log_common,}){
+      self.formatter = lambda{|level, t, prog, msg| "#{t.iso8601} #{level} #{@process_identifier} #{msg}\n"}
+    }
+    add(:process_stdout_log, Tengine::Core::Config::Atd::LoggerConfig,
+      :parameters => {:logger_name => "#{File.basename($PROGRAM_NAME)}_#{::Process.pid}_stdout"},
+      :dependencies => { :process_config => :process, :log_common => :log_common,}){
+      self.formatter = lambda{|level, t, prog, msg| "#{t.iso8601} STDOUT #{@process_identifier} #{msg}\n"}
+    }
+    add(:process_stderr_log, Tengine::Core::Config::Atd::LoggerConfig,
+      :parameters => {:logger_name => "#{File.basename($PROGRAM_NAME)}_#{::Process.pid}_stderr"},
+      :dependencies => { :process_config => :process, :log_common => :log_common,},
+      :defaults => {
+        :output => proc{ process_config.daemon ? "./log/#{logger_name}.log" : "STDERR" }}){
+      self.formatter = lambda{|level, t, prog, msg| "#{t.iso8601} STDERR #{@process_identifier} #{msg}\n"}
+    }
+
+    separator("\nGeneral:")
+    field(:verbose, "Show detail to this command", :type => :boolean)
+    __action__(:version, "show version"){ STDOUT.puts Tengine::Core.version.to_s; exit }
+    __action__(:dump_skelton, "dump skelton of config"){ STDOUT.puts YAML.dump(root.to_hash); exit }
+    __action__(:help   , "show this help message"){ STDOUT.puts option_parser.help; exit }
+
+    mapping({
+        [:action] => :k,
+        [:config] => :f,
+        [:process, :daemon] => :D,
+
+        [:event_queue, :connection, :host] => :o,
+        [:event_queue, :connection, :port] => :p,
+        [:event_queue, :connection, :user] => :u,
+        [:event_queue, :connection, :pass] => :s,
+        [:event_queue, :exchange  , :name] => :e,
+        [:event_queue, :queue     , :name] => :q,
+
+        [:heartbeat, :atd, :interval] => :G,
+
+        [:verbose] => :V,
+        [:version] => :v,
+        [:help] => :h
+      })
+  end
+
+  class Process
+    include Tengine::Support::Config::Definition
+
+    field :daemon, "process works on background.", :type => :boolean, :default => false
+    field :pid_dir, "path/to/dir for PID created.", :type => :directory, :default => "./pids"
+  end
+
+  def heartbeat_period
+    # [:][:heartbeat_period].to_i
+    heartbeat.interval.to_i
+  end
+
+  def heartbeat_enabled?
+    heartbeat_period > 0
+  end
+
+  class AmqpConnection < Tengine::Support::Config::Amqp::Connection
+    field :vhost, :default => '/'
+    field :user , :default => 'guest'
+    field :pass , :default => 'guest'
+    field :logging, :type => :boolean, :default => false
+    field :insist, :type => :boolean, :default => false
+    field :auto_reconnect_delay, :type => :integer, :default => 1
+  end
+
+  class LoggerConfig < Tengine::Support::Config::Logger
+    parameter :logger_name
+    depends :process_config
+    depends :log_common
+    field :output, {
+      :default => proc {
+        process_config.daemon ? "./log/#{logger_name}.log" : "STDOUT"
+      },
+      :default_description => proc {
+        "if daemon process then \"./log/#{logger_name}.log\" else \"STDOUT\""
+      }
+    }
+    field :rotation, {
+      :default => proc{ log_common.rotation },
+      :default_description => proc{ "value of #{log_common.long_opt}-rotation" }
+    }
+    field :rotation_size, {
+      :default => proc{ log_common.rotation_size },
+      :default_description => proc{ "value of #{log_common.long_opt}-rotation-size" }
+    }
+    field :level, {
+      :default => proc{ log_common.level },
+      :default_description => proc{ "value of #{log_common.long_opt}-level" }
+    }
+
+    def new_logger *;
+      super.tap {|i| i.formatter = self.formatter }
+    end
+  end
+
+  def setup_loggers
+    Tengine.logger = application_log.new_logger
+    Tengine::Core.stdout_logger = process_stdout_log.new_logger
+    Tengine::Core.stderr_logger = process_stderr_log.new_logger
+
+    Tengine::Core.stdout_logger.info("#{self.class.name}#setup_loggers complete")
+  rescue Exception
+    Tengine::Core.stderr_logger.info("#{self.class.name}#setup_loggers failure")
+    raise
+  end
+
+end