Class: JIJI::Registry

Inherits:

Object

• Object
• JIJI::Registry

Defined in:

lib/jiji/registry.rb

Overview

レジストリ

Instance Method Summary

• #[](name) ⇒ Object
• #initialize(base, server = nil) ⇒ Registry constructor

  A new instance of Registry.

• #method_missing(name, *args) ⇒ Object

Constructor Details

#initialize(base, server = nil) ⇒ Registry

Returns a new instance of Registry.

# File 'lib/jiji/registry.rb', line 46

def initialize(base, server=nil)
  @registry = Needle::Registry.new {|r|

    # ベースディレクトリ
    r.register( :base_dir) { base }
    # サーバー
    r.register( :server) { server }

    # 設定値
    r.register( :conf ) {
      JIJI::Configuration.new r.base_dir + "/conf/configuration.yaml"
    }
    # レート一覧置き場
    r.register( :rate_dir ) {
      dir = r.base_dir + "/" + r.conf.get([:dir,:rate_data], "rate_datas")
      FileUtils.mkdir_p dir
      dir
    }
    # プロセスデータ置き場
    r.register( :process_dir ) {
     process_dir = "#{r.base_dir}/#{r.conf.get([:dir,:process_log], "process_logs")}"
     FileUtils.mkdir_p process_dir
      process_dir
    }
    # バージョンファイル
    r.register( :version_file ) {
      r.base_dir + "/data_version"
    }

    # ロガー
    r.register( :server_logger ) {
      dir = "#{r.base_dir}/#{r.conf.get([:dir,:log], "logs")}"
      FileUtils.mkdir_p dir
      l = Logger.new( dir + "/log.txt", 10, 512*1024 )
      l.level = Logger::DEBUG
      l
    }
    r.register( :process_logger, :model=>:multiton_initialize ) {|c,p,id|
      dir = "#{r.process_dir}/#{id}"
      FileUtils.mkdir_p dir
      c = Logger.new( dir + "/log.txt", 10, 512*1024 )
      r.permitter.proxy( c, [/^(info|debug|warn|error|fatal|close)$/] )
    }

    # Permitter
    r.register( :permitter ) {
      JIJI::Permitter.new( 5, 0 )
    }

    # Dao
    r.register( :scales ) {
      ["1m", "5m", "10m", "30m", "1h", "6h", "1d", "2d", "5d"]
    }
    r.register( :rate_dao ) {
      JIJI::Dao::RateDao.new( r.rate_dir, r.scales )
    }
    r.register( :trade_result_dao, :model=>:multiton_initialize ) {|c,p,id|
      dir = "#{r.process_dir}/#{id}/trade"
      FileUtils.mkdir_p dir
      JIJI::Dao::TradeResultDao.new( dir, r.scales )
    }

    # アウトプット
    r.register( :output, :model=>:multiton_initialize ) {|c,p,id,agent_name|
      dir = "#{r.process_dir}/#{id}/out"
      FileUtils.mkdir_p dir

      c = JIJI::Output.new(agent_name, dir, r.scales)
      r.permitter.proxy( c, [/^(get|put|<<)$/], [/^get$/] )
    }

    # オブザーバー
    r.register( :rmt_observer_manager ) {
      JIJI::WorkerThreadObserverManager.new([
        r.rate_dao, r.agent_manager("rmt",true)
      ], r.process_logger("rmt"))
    }
    r.register( :backtest_observer_manager, :model=>:multiton_initialize ) {|c,p,id|
      JIJI::ObserverManager.new( [r.agent_manager(id, false)], r.process_logger(id))
    }

    # エージェントマネージャ
    r.register( :agent_manager, :model=>:multiton_initialize ) {|c,p,id,failsafe|
      c = JIJI::AgentManager.new( id, r.agent_registry, r.process_logger(id), failsafe )
      c.operator = r.operator(id, false, nil) # 作成段階では常に取引は行なわない。
      c.registry = r
      c.conf = r.conf
      c.trade_result_dao = r.trade_result_dao(id)
      c
    }
    r.intercept( :agent_manager ).with {
      SynchronizeInterceptor
    }.with_options( :id=>:agent_manager )

    # エージェントレジストリ
    r.register( :agent_registry ) {
      dir = "#{r.base_dir}/#{r.conf.get([:dir,:agent], "agents")}"
      sdir = "#{r.base_dir}/#{r.conf.get([:dir,:shared_lib], "shared_lib")}"
      FileUtils.mkdir_p dir
      FileUtils.mkdir_p sdir
      c = JIJI::AgentRegistry.new( dir, sdir )
      c.conf = r.conf
      c.load_all
      c
    }

    # オペレーター
    r.register( :operator, :model=>:multiton_initialize ) {|c,p,id,trade_enable,money|
      c = JIJI::RmtOperator.new(r.securities_plugin_manager.selected, 
          r.process_logger(id), r.trade_result_dao(id), trade_enable, money)
      c.conf = r.conf
      r.permitter.proxy( c, [/^(sell|buy|commit)$/], [/^(sell|buy)$/])
    }

    # コレクター
    r.register( :rmt_collector ) {
      c = JIJI::Collector.new
      c.observer_manager = r.rmt_observer_manager
      c.conf      = r.conf
      c.logger    = r.process_logger("rmt")
      c.client    = r.securities_plugin_manager.selected
      c
    }
    r.register( :backtest_collector, :model=>:multiton_initialize ) {|c,p,id, start_date, end_date|
      c = JIJI::BackTestCollector.new( r.rate_dao, start_date, end_date )
      c.observer_manager = r.backtest_observer_manager(id)
      c.conf      = r.conf
      c.logger    = r.process_logger(id)
      c.client    = r.securities_plugin_manager.selected
      c
    }

    # RMTプロセス
    r.register( :rmt_process ) {
      c = JIJI::Process.new("rmt", r.process_dir, r.agent_manager("rmt",true), r.process_logger("rmt"), nil, r, true)
      c.observer_manager = r.rmt_observer_manager
      c.collector = r.rmt_collector
      c
    }
    # バックテストプロセス
    r.register( :backtest_process, :model=>:multiton_initialize ) {|c,p,id, props|
      # 既存のバックテストを読み込む場合、プロパティはnil
      c = JIJI::Process.new(id, r.process_dir, r.agent_manager(id,false), r.process_logger(id), props, r, false)
      c.observer_manager = r.backtest_observer_manager(id)
      c.collector = r.backtest_collector(id,
        Time.at( c["start_date"]), Time.at( c["end_date"]))
      c
    }

    # プロセスマネージャ
    r.register( :process_manager ) {
      c = JIJI::ProcessManager.new( r )
      c.conf = r.conf
      c
    }
    r.intercept( :process_manager ).with {
      SynchronizeInterceptor
    }.with_options( :id=>:process_manager )

    # サービス
    r.register( :hello_service ) {
      JIJI::Service::HelloService.new
    }
    r.register( :agent_service ) {
      c = JIJI::Service::AgentService.new
      c.agent_registry = r.agent_registry
      c.process_manager = r.process_manager
      c
    }
    r.register( :rate_service ) {
      c = JIJI::Service::RateService.new
      c.rate_dao = r.rate_dao
      c
    }
    r.register( :trade_result_service ) {
      c = JIJI::Service::TradeResultService.new
      c.process_manager = r.process_manager
      c
    }
    r.register( :output_service ) {
      c = JIJI::Service::OutputService.new
      c.process_manager = r.process_manager
      c.process_dir = r.process_dir
      c
    }
    r.register( :process_service ) {
      c = JIJI::Service::ProcessService.new
      c.process_manager = r.process_manager
      c
    }
    r.register( :system_service ) {
      c = JIJI::Service::SystemService.new
      c.server = r.server
      c
    }
    
    # データ移行
    r.register( :migrator ) {
      c = JIJI::Migration::Migrator.new
      c.registry = r
      c.server_logger = r.server_logger
      c.version_file = r.version_file
      c.migrators = [
        { :version=>Gem::Version.new( "1.0.3" ), :migrator=>JIJI::Migration::Migrator1_0_3.new},
        { :version=>Gem::Version.new( "1.1.0" ), :migrator=>JIJI::Migration::Migrator1_1_0.new}
      ]
      c
    }
    
    # プラグイン
    r.register( :plugin_loader ) {
      c = JIJI::Plugin::Loader.new
      c.server_logger = r.server_logger
      c
    }
    # Securitiesプラグイン
    r.register( :securities_plugin_manager ) {
      c = JIJI::Plugin::SecuritiesPluginManager.new
      c.conf = r.conf
      c.server_logger = r.server_logger
      c
    }
  }
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object

# File 'lib/jiji/registry.rb', line 271

def method_missing(name, *args)
  @registry.send( name, *args )
end

Instance Method Details

#[](name) ⇒ Object

# File 'lib/jiji/registry.rb', line 275

def [](name)
  @registry[name]
end