jiji 1.2.5

data/lib/jiji/dao/trade_result_dao.rb

@@ -0,0 +1,128 @@
+
+require 'thread'
+require 'jiji/util/csv_append_support'
+require 'jiji/util/thread_use_generator'
+require 'jiji/util/util'
+require 'jiji/models'
+require 'jiji/dao/timed_data_dao'
+require 'set'
+
+module JIJI
+  module Dao
+
+    # 取引結果DAO
+    class TradeResultDao
+
+      def initialize( data_dir, scales=[] )
+        @data_dir = data_dir
+        @scales = scales
+
+        aggregators = @scales.map {|s| TradeAggregator.new(s) }
+        @trade_dao = dao( "trade", aggregators )
+
+        aggregators = @scales.map {|s| LastAggregator.new(s) }
+        @profit_or_loss_dao = dao( "profit_or_loss", aggregators )
+
+        @position_dir = "#{data_dir}/positions"
+        FileUtils.mkdir_p @position_dir unless File.exists? @position_dir
+      end
+
+      # ポジションデータを保存する
+      def save( position )
+        props = position.values
+        file = "#{@position_dir}/#{position.position_id}.yaml"
+        FileLock.new( file ).writelock {|f|
+          f.write( YAML.dump(props) )
+        }
+      end
+      # ポジションデータをロードする。
+      def load( id )
+        props = {}
+        file = "#{@position_dir}/#{id}.yaml"
+        if ( File.exist? file )
+          FileLock.new( file ).readlock {|f|
+            props = YAML.load f
+          }
+        end
+        props
+      end
+
+      # 指定期間のトレードデータを得る。
+      def list_positions( scale, start_date=nil, end_date=nil )
+        ids = Set.new
+        @trade_dao.each_data( scale, start_date, end_date ) {|r, t|
+          ids += r[0].split(" ")
+        }
+        
+        # バッファ内に取得期間内のデータがある場合、それも追加する。
+        aggregator = @trade_dao.aggregator.find {|a| a.scale == scale }
+        if  aggregator  && aggregator.values
+           aggregator.values.each {|v|  ids << v  }
+        end
+        ids.inject({}) {|r,id| 
+          v = load(id)
+          if ( v && !( start_date && v[:fix_date] != 0 && v[:fix_date] < start_date.to_i ) \
+            && !( end_date &&  v[:date]  > end_date.to_i ))
+            r[id] = v
+          end
+          r 
+        }
+      end
+
+      # 指定の期間の損益データを得る。
+      def each( scale=:raw, start_date=nil, end_date=nil, &block )
+        @profit_or_loss_dao.each_data( scale, start_date, end_date ) {|row, time|
+          yield row
+        }
+      end
+
+      # 取引結果を記録する。
+      def next( operator, time )
+        @profit_or_loss_dao << BasicTimedData.new(
+          [operator.profit_or_loss, operator.fixed_profit_or_loss, operator.win_rate], time)
+        ids = operator.positions.map {|p| p[1].position_id }
+        @trade_dao << BasicTimedData.new( [ids], time)
+      end
+
+      # 取引結果を強制的に記録する。
+      def flush( time )
+        # 取引結果のみ(損益データは出力しない)
+        @trade_dao.flush(time)
+      end
+
+    private
+
+      def dao( name, aggregators )
+        dir = "#{@data_dir}/#{name}"
+        FileUtils.mkdir_p dir unless File.exists? dir
+
+        TimedDataDao.new( dir, aggregators )
+      end
+
+      def lock(file)
+        FileLock.new( "#{file}.lock" ).writelock {
+          yield
+        }
+      end
+
+      class TradeAggregator < AbstractAggregator
+        def aggregate( timed_data )
+          @values = Set.new unless @values
+          @values += timed_data.values[0]
+        end
+        def aggregated
+          begin
+            str = @values.to_a.join(" ")
+            return BasicTimedData.new( [str] \
+              + [@start.to_i, @end.to_i], @end)
+          ensure
+            @values.clear if @values
+          end
+        end
+        attr_reader :values
+      end
+
+    end
+  end
+
+end

data/lib/jiji/error.rb

@@ -0,0 +1,49 @@
+
+module JIJI
+
+  class AbstractError < StandardError
+    def initialize( code, message="", info={}  )
+      super( message )
+      @code = code
+      @info = info
+    end
+    def detail
+      {"code"=>@code,"info"=>@info}
+    end
+    attr :code
+    attr :info, true
+  end
+
+  # 致命的エラー
+  class FatalError < AbstractError
+    def initialize( code, message="", info={}  )
+      super
+    end
+  end
+  # ユーザー操作により発生しうるエラー
+  class UserError < AbstractError
+    def initialize( code, message="", info={} )
+      super
+    end
+  end
+
+  # エラーコード:存在しない
+  ERROR_NOT_FOUND = "not_found"
+  # エラーコード:すでに存在する
+  ERROR_ALREADY_EXIST = "already_exist"
+  # エラーコード:ファイルでない
+  ERROR_IS_NOT_FILE = "is_not_file"
+  # エラーコード:フォルダでない
+  ERROR_IS_NOT_FOLDER = "is_not_folder"
+
+  # エラーコード:不正な名前
+  ERROR_ILLEGAL_NAME = "illegal_name"
+  # エラーコード:不正な引数
+  ERROR_ILLEGAL_ARGUMENTS = "illegal_arguments"
+
+  # エラーコード:想定外エラー
+  ERROR_FATAL = "fatal"
+
+  # エラーコード:サーバーに接続されていない
+  ERROR_NOT_CONNECTED = "not_connected"
+end

data/lib/jiji/migration/migrator.rb

@@ -0,0 +1,50 @@
+
+require 'rubygems'
+require 'fileutils'
+require 'logger'
+require 'jiji/util/file_lock'
+
+module JIJI
+  module Migration
+    
+    #==サーバー起動時にデータ移行を行うクラス。
+    class Migrator
+
+      #データを移行する。
+      def migrate
+        logger = server_logger
+        begin
+          data_version = version
+          new_version = data_version
+          tmp = nil
+          @migrators.sort_by {|item| item[:version] }.each {|d|
+            tmp = d[:version]
+            if ( data_version < d[:version] )
+              d[:migrator].migrate(registry)
+              new_version = d[:version]
+              logger.info "data migration succesful! new_version=#{new_version.to_s}."
+            end
+          }
+        rescue Exception
+          logger.error "data migration failed. current=#{data_version.to_s} new_version=#{tmp.to_s}"
+          logger.error $!
+        ensure
+          FileLock.new( version_file ).writelock {|f| f << new_version.to_s }
+        end
+      end
+      
+      # 現在のデータバージョンを取得する。
+      def version
+        version_str = File.exist?(version_file) ? 
+          FileLock.new( version_file ).readlock {|f| f.read } : "1.0.0"
+        return Gem::Version.new( version_str )
+      end
+      
+      attr :migrators, true
+      attr :server_logger, true
+      attr :version_file, true
+      attr :registry, true
+    end
+  end
+end
+

data/lib/jiji/migration/migrator1_0_3.rb

@@ -0,0 +1,26 @@
+
+require 'fileutils'
+require 'yaml'
+require 'jiji/util/fix_yaml_bug'
+require 'jiji/util/file_lock'
+
+module JIJI
+  module Migration
+
+    #===1.0.0 → 1.0.3
+    class Migrator1_0_3
+      def migrate( registry )
+        # outputのプロパティキーを変換
+        Dir.glob( "#{registry.process_dir}/*/out/**/meta.yaml").each {|meta|
+          props = YAML.load_file meta
+          props = props.inject({}) {|r,p| r[p[0].to_sym] = p[1]; r }
+          FileLock.new( meta ).writelock { |f|
+            f.write( YAML.dump( props ) )
+          }
+        }
+      end
+    end
+    
+  end
+end
+

data/lib/jiji/migration/migrator1_1_0.rb

@@ -0,0 +1,46 @@
+
+require 'fileutils'
+require 'yaml'
+require 'jiji/util/fix_yaml_bug'
+require 'jiji/util/file_lock'
+
+module JIJI
+  module Migration
+
+    #===1.0.3 → 1.1.0
+    class Migrator1_1_0
+      def migrate( registry )
+        #設定ファイルを更新
+        conf_file = registry.base_dir + "/conf/configuration.yaml"
+        return unless File.exist? conf_file
+        tmp = key_to_sym(YAML.load_file(conf_file))
+        
+        # 証券会社アクセス関連の設定値を置換
+        if( tmp[:securities] ) 
+          old = tmp[:securities]
+          tmp[:securities] = {
+            :type=>:click_securities_demo,
+            :user=>old[:account] &&old[:account][:user] ? old[:account][:user] : "",
+            :password=>old[:account] &&old[:account][:password] ? old[:account][:password] : ""
+          }
+          open( conf_file, "w" ) {|f|
+            f << YAML.dump( tmp )
+          }
+          # 設定値を再読み込み
+          registry.conf.load
+        end
+      end
+      
+      # ハッシュのキーをシンボルに置換する
+      def key_to_sym( map )
+        map.inject({}) {|r,e|
+           v = e[1].kind_of?(Hash) ? key_to_sym( e[1] ) : e[1]
+           r.store(e[0].to_sym, v)
+           r
+        }
+      end
+    end
+    
+  end
+end
+

data/lib/jiji/migration/migrator1_2_0.rb

@@ -0,0 +1,67 @@
+
+require 'fileutils'
+require 'yaml'
+require 'jiji/util/fix_yaml_bug'
+require 'jiji/util/file_lock'
+require 'jiji/process'
+require 'kconv'
+
+module JIJI
+  module Migration
+
+    #===1.1.3 → 1.2.0
+    class Migrator1_2_0
+      def migrate( registry )
+        logger = registry.server_logger
+
+        #出力の保存先を置換
+        Dir.glob("#{registry.process_dir}/*") {|d|
+          
+          logger.info "convert : #{d}"
+          process_id = File.basename(d)
+          process_info = {}
+          begin
+            file = "#{d}/#{JIJI::ProcessInfo::PROPERTY_FILE}"
+            process_info = YAML.load_file(file) if  File.exist?(file)
+          rescue Exception
+            logger.error $!
+          end
+          
+          begin
+            # 出力データを列挙
+            Dir.glob("#{d}/out/*").map.each {|out_dir|
+              convert_out_dir( out_dir, process_info, logger )
+            }
+          rescue Exception
+            logger.error $!
+          end
+        }
+      end
+
+      #各出力ディリクトリデータのリネーム
+      def convert_out_dir( out_dir, info, logger )
+        begin
+          agent_id = JIJI::Util.decode( File.basename(out_dir))
+          agent_name = resolve_name( info, agent_id )
+          FileLock.new( "#{out_dir}/#{JIJI::Output::PROPERTIES_FILE_NAME}" ).writelock { |f|
+            f.write( YAML.dump({:agent_name=>agent_name}) )
+          }
+          FileUtils.mv out_dir, "#{File.dirname(out_dir)}/#{agent_id}"
+        rescue Exception
+          logger.error $!
+        end
+      end
+      #エージェント名を解決する
+      def resolve_name( process_info, agent_id )
+        if ( process_info["agents"]  )
+          item = process_info["agents"].find {|i| i["id"] == agent_id }
+          return item["name"] if item
+        end
+        return "不明"
+      end
+
+    end
+
+  end
+end
+

data/lib/jiji/models.rb

@@ -0,0 +1,223 @@
+
+require 'jiji/util/util'
+require "jiji/dao/timed_data_dao"
+
+module JIJI
+
+  #===レートの集合
+  #通貨ペアコード(:EURJPYのようなシンボル)をキーとしてJIJI::Rateを保持します。
+  #
+  #  rates = <省略>
+  #  
+  #  #EURJPYのレートを取得。
+  #  rate = rates[:EURJPY] #=> JIJI::Rate
+  #
+  #  #bidレート,askレートを取得
+  #  p rate.bid
+  #  p rate.ask
+  #
+  class Rates < Hash
+
+    include JIJI::Util::Model
+
+    def initialize( pair_infos, list, time=Time.now ) #:nodoc:
+      super()
+      @pair_infos = pair_infos
+      @time = time
+      list.each_pair { |k,info|
+        self[k] = Rate.new( info.bid.to_f, info.ask.to_f,
+          info.sell_swap.to_f, info.buy_swap.to_f, time)
+      }
+    end
+    # 通貨ペアの情報(取引数量など)
+    attr_reader :pair_infos
+    # 現在時刻
+    attr_reader :time
+  end
+
+  #==レート
+  class Rate
+
+    include JIJI::Util::Model
+    include JIJI::Dao::TimedData
+
+    def initialize( bid=nil, ask=nil, sell_swap=nil, buy_swap=nil, time=nil ) #:nodoc:
+      @bid = bid
+      @ask = ask
+      @sell_swap = sell_swap
+      @buy_swap = buy_swap
+      @time = time
+    end
+    # 値を配列で取得する
+    def values #:nodoc:
+      [bid,ask,sell_swap,buy_swap,time.to_i]
+    end
+    # 値を配列で設定する
+    def values=(values) #:nodoc:
+      @bid = values[0].to_f
+      @ask = values[1].to_f
+      @sell_swap = values[2].to_f
+      @buy_swap  = values[3].to_f
+    end
+    #bidレート
+    attr_reader :bid
+    #askレート
+    attr_reader :ask
+    #売りスワップ
+    attr_reader :sell_swap
+    #買いスワップ
+    attr_reader :buy_swap
+  end
+
+  #===一定期間のレートの集合
+  #通貨ペアコード(:EURJPYのようなシンボル)をキーとしてJIJI::PeriodicallyRateを保持します。
+  #
+  #  rates = <省略>
+  #  
+  #  #EURJPYのレートを取得。
+  #  rate = rates[:EURJPY] #=> JIJI::PeriodicallyRate
+  #
+  #  #bidレートの高値、安値を取得
+  #  bid = rate.bid
+  #  p bid.max
+  #  p bid.min
+  #
+  class  PeriodicallyRates < Hash
+
+    include JIJI::Util::Model
+    #====コンストラクタ
+    #pair_infos:: 通貨ペアの情報
+    #list:: 初期データ
+    def initialize( pair_infos, list=[] ) #:nodoc:
+      super()
+      @pair_infos = pair_infos
+      list.each {|rates|
+        self << rates
+      }
+    end
+    #====JIJI::Ratesを追加し各値の四本値を再計算します。
+    #rates:: JIJI::Rates
+    def <<(rates)
+      now = rates.time
+      @start_time = now unless @start_time
+      @end_time   = now
+      rates.each_pair { |code,rate|
+        self[code] = PeriodicallyRate.new unless key? code
+        self[code] << rate
+      }
+    end
+    def time #:nodoc:
+      @start_time
+    end
+    #通貨ペアの情報(取引数量など)
+    attr_reader :pair_infos
+    #集計開始日時
+    attr :start_time, true
+    #集計終了日時
+    attr :end_time, true
+  end
+
+  #===一定期間のレート
+  #bid,ask,sell_swap,buy_swapの各値が四本値(JIJI::PeriodicallyValue)で保持されます。
+  class PeriodicallyRate
+
+    include JIJI::Util::Model
+    include JIJI::Dao::TimedData
+    
+    #====コンストラクタ
+    #list:: 初期データ
+    def initialize( list=[] ) #:nodoc:
+      @bid = PeriodicallyValue.new
+      @ask = PeriodicallyValue.new
+      @sell_swap = PeriodicallyValue.new
+      @buy_swap  = PeriodicallyValue.new
+      list.each { |item|
+        self << item
+      }
+    end
+    #====JIJI::Rateを追加し各値の四本値を再計算します。
+    #rate:: JIJI::Rate
+    def <<( rate ) #:nodoc:
+      @bid << rate.bid
+      @ask << rate.ask
+      @sell_swap << rate.sell_swap
+      @buy_swap  << rate.buy_swap
+      @start_time = rate.time unless @start_time
+      @end_time = rate.time
+    end
+    # 値を配列で取得する
+    def values #:nodoc:
+      bid.values + ask.values + sell_swap.values + buy_swap.values \
+        + [@start_time.to_i, @end_time.to_i]
+    end
+    # 値を配列で設定する
+    def values=(values) #:nodoc:
+      @bid.values = values[0..3]
+      @ask.values = values[4..7]
+      @sell_swap.values = values[8..11]
+      @buy_swap.values = values[12..15]
+      @start_time = Time.at(values[16].to_i)
+      @end_time = Time.at(values[17].to_i)
+    end
+    def time #:nodoc:
+      @end_time
+    end
+    def time=(t) #:nodoc:
+      @end_time = t
+    end
+    #bidレート
+    attr_reader :bid
+    #askレート
+    attr_reader :ask
+    #売りスワップ
+    attr_reader :sell_swap
+    #買いスワップ
+    attr_reader :buy_swap
+    #集計開始日時
+    attr :start_time, true
+    #集計終了日時
+    attr :end_time, true
+  end
+
+  #===一定期間の値
+  #始値、終値、高値、安値の四本値
+  class PeriodicallyValue
+
+    include JIJI::Util::Model
+    
+    #====コンストラクタ
+    #list:: 初期データ
+    def initialize( list=[] )
+      list.each { |item|
+        self << item
+      }
+    end
+    #====値を追加し四本値を再計算します。
+    #value:: 値
+    def <<( value )
+      @start = value if @start == nil
+      @end = value
+      @max = value if @max == nil || value > @max
+      @min = value if @min == nil || value < @min
+    end
+    # 値を配列で取得する
+    def values #:nodoc:
+      [@start, @end, @max, @min]
+    end
+    # 値を配列で設定する
+    def values=(values) #:nodoc:
+      @start = values[0].to_f
+      @end   = values[1].to_f
+      @max   = values[2].to_f
+      @min   = values[3].to_f
+    end
+    #始値
+    attr :start
+    #終値
+    attr :end
+    #高値
+    attr :max
+    #安値
+    attr :min
+  end
+end

data/lib/jiji/observer.rb

@@ -0,0 +1,105 @@
+
+require 'thread'
+
+module JIJI
+  
+   #==コレクターからのレートの通知を受け取るクラス。
+  class ObserverManager
+    #コンストラクタ
+    #observers:: オブサーバー
+    #logger:: ロガー
+    def initialize( observers, logger )
+     @logger = logger
+     @observers = observers
+   end
+   #レートの通知を受ける
+   #rates:: レート
+    def next_rates( rates )
+      @observers.each {|w|
+        w.next_rates( rates )
+      }
+    end
+    #オブザーバーを追加する
+    #observer:: オブザーバー
+    def <<(observer)
+      @observers << observer
+    end
+    #通知を停止する
+    def stop 
+    end
+    #ロガー
+    attr :logger, true
+  end
+
+  
+  #==コレクターからのレートの通知を受け取り、別スレッドで処理するクラス。
+  #- 登録されたオブザーバーごとに専用のスレッドを起こして情報を通知する。
+  #- スレッドを破棄する必要があるため、必ずstopで停止すること。
+  class WorkerThreadObserverManager
+    #コンストラクタ
+    #observers:: オブサーバー
+    #logger:: ロガー
+    def initialize( observers, logger )
+     @logger = logger
+     @workers = observers.map {|o|
+       Worker.new( o, @logger )
+     }
+   end
+   #レートの通知を受ける
+   #rates:: レート
+    def next_rates( rates )
+      @workers.each {|w|
+        w.next_rates( rates )
+      }
+    end
+    #オブザーバーを追加する
+    #observer:: オブザーバー
+    def <<(observer)
+      @workers << Worker.new( observer, @logger )
+    end
+    #通知を停止する
+    def stop 
+      @logger.info( "observer manager stop" )
+      @workers.each {|w|  w.alive = false }
+      @workers.each {|w|  w.thread.join }
+      @workers.clear
+    end
+    #ロガー
+    attr :logger, true
+  end
+  
+  # ワーカースレッド
+  class Worker
+    def initialize( observer, logger )
+      @logger = logger
+      @alive = true
+      @alive_mutex = Mutex.new
+      @q = Queue.new
+      @thread = Thread.start {
+        while( !@q.empty? || alive? )
+          JIJI::Util.log_if_error( @logger ) {
+            rates = @q.pop 
+            observer.next_rates( rates ) if rates != nil
+          }
+        end
+      }
+    end
+    def next_rates( rates )
+      @q.push rates
+    end
+    def alive?
+      @alive_mutex.synchronize {
+        @alive
+      }
+    end
+    def alive=(value)
+      @alive_mutex.synchronize {
+        @alive = value
+        @q.push nil # 眠れるスレッドをたたき起こす。
+      }
+    end
+    
+    attr_reader :thread
+  end
+  
+end