unageanu-jiji 0.1.0

data/lib/jiji/registry.rb

@@ -0,0 +1,255 @@
+
+require 'rubygems'
+require 'yaml'
+require 'needle'
+require 'jiji/collector'
+require 'jiji/configuration'
+require 'jiji/observer'
+require 'jiji/process'
+require 'jiji/process_manager'
+require 'jiji/agent/agent'
+require 'jiji/agent/agent_manager'
+require 'jiji/agent/agent_registry'
+require 'jiji/agent/permitter'
+require 'jiji/agent/util'
+require 'jiji/output'
+require 'jiji/operator'
+require 'jiji/single_click_client'
+require "jiji/dao/rate_dao"
+require "jiji/dao/trade_result_dao"
+require 'logger'
+require 'fileutils'
+require 'jiji/util/synchronize_interceptor'
+
+require 'jiji/service/agent_service'
+require 'jiji/service/hello_service'
+require 'jiji/service/rate_service'
+require 'jiji/service/trade_result_service'
+require 'jiji/service/output_service'
+require 'jiji/service/process_service'
+require 'jiji/service/system_service'
+
+module JIJI
+
+  #
+  # レジストリ
+  #
+  class Registry
+
+    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( :account ) {
+          conf = r.conf
+          accountClass = Struct.new(:user, :password)
+          accountClass.new(
+            conf.get([:securities,:account,:user], ""),
+            conf.get([:securities,:account,:password], ""))
+        }
+
+        # レート一覧置き場
+        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( :server_logger ) {
+          dir = "#{r.base_dir}/#{r.conf.get([:dir,:log], "logs")}"
+          FileUtils.mkdir_p dir
+          Logger.new( dir + "/log.txt", 10, 512*1024 )
+        }
+        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)$/] )
+        }
+
+        # クライアント
+        r.register( :client ) {
+          JIJI::SingleClickClient.new( r.account, r.conf, r.server_logger )
+        }
+        # 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.client   = r.client
+          c.registory = 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.client, 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.client
+          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.client
+          c
+        }
+
+        # RMTプロセス
+        r.register( :rmt_process ) {
+          c = JIJI::Process.new("rmt", r.process_dir, r.agent_manager("rmt",true), nil, 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), props, props == nil)
+          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
+        }
+      }
+    end
+
+    def method_missing(name, *args)
+      @registry.send( name, *args )
+    end
+
+    def [](name)
+      @registry[name]
+    end
+
+  end
+
+end

data/lib/jiji/server.rb

@@ -0,0 +1,115 @@
+
+require 'jiji/registry'
+require 'webrick'
+require 'jiji/util/json_broker'
+require 'cgi'
+
+module JIJI
+  
+  class FxServer < WEBrick::HTTPServer
+    def initialize( base, param={} )
+      
+      registry = JIJI::Registry.new(base, self)
+      registry.server_logger.info "base dir : #{base}"
+      
+      conf = registry[:conf]
+      param[:Port] = conf.get([:server,:port], 7000).to_i 
+      param[:ServerType] = WEBrick::Daemon
+      param[:Logger] = registry[:server_logger]  
+      param[:DocumentRoot] = File.expand_path( "#{__FILE__}/../../../html" )
+      
+      param[:Logger].info( File.expand_path( "#{__FILE__}/../../../html" ) )
+      
+      start_callback_org = param[:StartCallback]
+      param[:StartCallback] = proc {
+        JIJI::Util.log_if_error(registry.server_logger) {
+	        registry.process_manager.start
+	        [:INT,:TERM].each {|sig|
+	          trap(sig){ shutdown }
+	        }        
+	        start_callback_org.call if start_callback_org
+        }
+      }
+      stop_callback_org = param[:StopCallback]
+      param[:StopCallback] = proc { 
+        JIJI::Util.log_if_error(registry.server_logger) {
+          begin
+	          registry.process_manager.stop
+	        ensure
+            begin
+              registry.permitter.close
+            ensure
+              registry.client.close
+            end
+          end
+	        stop_callback_org.call if stop_callback_org
+        }
+      }
+      super(param)
+      
+      mount("/json", JIJI::JsonServlet, registry)
+    end
+  end
+  
+  class JsonServlet < WEBrick::HTTPServlet::AbstractServlet
+    
+    # サーブレットの唯一のインスタンス
+    @@instance = nil
+    # インスタンス生成を同期化するためのMutex
+    @@instance_creation_mutex = Mutex.new
+    
+    # サーブレットのインスタンスを生成するための関数
+    def self.get_instance(config, *options)
+      @@instance_creation_mutex.synchronize {
+        @@instance = self.new(config, *options) if @@instance == nil
+        @@instance
+      }
+    end
+    
+    def initialize( config, *options )
+      super
+      @registry = options[0]
+    end
+      
+    def do_GET(req, res)
+      begin
+        process( req, res, req.query["request"].to_s )
+      rescue Exception
+        @registry.server_logger.error $!
+        error =  $!.to_s + " : " + $!.backtrace.join("\n")
+        res.body = "[{\"error\":\"fatal:#{error}\", \"result\":null}]"
+      end
+    end
+    
+    def do_POST(req, res)
+      begin 
+        process( req, res, CGI.unescape(req.body.to_s) )
+      rescue Exception
+        @registry.server_logger.error $!
+        error =  $!.to_s + " : " + $!.backtrace.join("\n")
+        res.body = "[{\"error\":\"fatal:#{error}\", \"result\":null}]"
+      end
+    end
+    
+    def process( req, res, request )
+      res['Content-Type'] = "application/json"
+      begin
+        path = req.path
+        @registry.server_logger.info "access : path=#{req.path}"
+        raise "illegal path." unless path =~ /\/json\/([a-zA-Z0-9_]+)$/
+        @registry.server_logger.info "access : request=#{request}"
+        service = @registry["#{$1}_service".to_sym]
+        raise "service not found." if service == nil
+        res.body = JSONBroker::Broker.new( service ).invoke( request )
+      rescue JIJI::UserError
+        @registry.server_logger.warn $!
+        error =  $!.to_s + " : " + $!.backtrace.join("\n")
+        res.body = "[{\"error\":\"#{$!.code}:#{error}\", \"result\":null}]" 
+      rescue JIJI::FatalError
+        @registry.server_logger.error $!
+        error =  $!.to_s + " : " + $!.backtrace.join("\n")
+        res.body = "[{\"error\":\"#{$!.code}:#{error}\", \"result\":null}]"
+      end
+    end
+  end
+end

data/lib/jiji/service/agent_service.rb

@@ -0,0 +1,131 @@
+
+require 'jiji/error'
+require 'jiji/agent/agent'
+require 'jiji/agent/agent_manager'
+require 'jiji/agent/agent_registry'
+require 'jiji/agent/permitter'
+require 'jiji/agent/util'
+
+
+module JIJI
+  module Service
+    class AgentService
+
+      include JIJI::AgentUtil
+
+      # ファイルの一覧を取得する
+      def list_files( type=:agent )
+        @agent_registry.files( type.to_sym )
+      end
+
+      # ファイルの内容を取得する
+      def get_file( file_name, type=:agent )
+        check_filename( file_name )
+        @agent_registry.get_file( file_name, type.to_sym )
+      end
+
+
+      # エージェントの一覧を取得する
+      def list_agent_class
+        @agent_registry.inject([]) {|list,name|
+          next unless name =~ /([^@]+)@([^@]+)/
+          list << {
+            "class_name"=>$1,
+            "file_name"=>$2,
+            "properties"=>@agent_registry.get_property_infos(name),
+            "description"=>@agent_registry.get_description(name)
+          }
+          list
+        }
+      end
+
+      # ファイルを追加/更新する
+      def put_file( file_name, body, type=:agent )
+        check_filename( file_name )
+        @agent_registry.add_file( file_name, body, type.to_sym )
+      end
+
+      # ファイルを削除する
+      def delete_files( file_names, type=:agent )
+        file_names.each {|fn|
+          check_filename( fn )
+        }
+        file_names.each {|fn|
+          @agent_registry.remove_file( fn, type.to_sym )
+        }
+        :success
+      end
+
+
+      # プロセスに登録されているエージェントの一覧を得る
+      def list_agent( process_id )
+        p = process_manager.get( process_id )
+        safe(4) {
+          p.agent_manager.collect.map! {|entry|
+            props = entry[1].agent.properties
+            {
+              "name"=>entry[0],
+              "properties"=>entry[1].agent.property_infos.map! {|info|
+                prop = props.find() {|e| e[0] == info.id.to_s }
+                { "id"=>info.id.to_s, "info"=>info, "value"=> prop ? prop[1] : nil }
+              },
+              "description"=>entry[1].agent.description,
+              "active"=>entry[1].active
+            }
+          }
+        }
+      end
+
+      # プロセスにエージェントを追加する
+      def add_agent( process_id, name, class_name, properties )
+        p = process_manager.get( process_id )
+        agent = agent_registry.create( class_name, properties )
+        p.agent_manager.add( name, agent )
+        :success
+      end
+
+      # プロセスのエージェントを削除する
+      def remove_agent( process_id, name )
+        p = process_manager.get( process_id )
+        p.agent_manager.remove( name )
+        :success
+      end
+
+#      # エージェントのプロパティを更新する
+#      def set_agent_properties( process_id, name, properties )
+#        p = process_manager.get( process_id )
+#        p.agent_manager.get( name ).properties = properties
+#      end
+
+      # プロセスのエージェントを一時的に無効化する
+      def off( process_id, name )
+        p = process_manager.get( process_id )
+        p.agent_manager.off( name )
+        :success
+      end
+      # プロセスのエージェントの無効化を解除する
+      def on( process_id, name )
+        p = process_manager.get( process_id )
+        p.agent_manager.on( name )
+        :success
+      end
+      # プロセスのエージェントの無効化状態を取得する
+      def on?( process_id, name )
+        p = process_manager.get( process_id )
+        p.agent_manager.on?( name )
+      end
+      attr :agent_registry, true
+      attr :process_manager, true
+
+    private
+      def check_filename( file_name )
+        unless file_name =~ VALID_FILE_NAME
+          raise JIJI::UserError.new( ERROR_ILLEGAL_NAME, "illegal file name. name=#{file_name}" )
+        end
+      end
+      VALID_FILE_NAME = /^[A-Za-z0-9_\*\+\-\#\"\'\!\~\(\)\[\]\?\.]+\.rb$/
+
+    end
+
+  end
+end