unageanu-jiji 0.1.0

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 (   !( 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
+          end
+        end
+        attr_reader :values
+      end
+
+    end
+  end
+
+end

data/lib/jiji/error.rb

@@ -0,0 +1,33 @@
+
+module JIJI
+  # 致命的エラー
+  class FatalError < StandardError
+    def initialize( code, message="" )
+      super( message )
+      @code = code
+    end
+    attr :code
+  end
+  # ユーザー操作により発生しうるエラー
+  class UserError < StandardError
+    def initialize( code, message="" )
+      super( message )
+      @code = code
+    end
+    attr :code
+  end
+
+  # エラーコード:存在しない
+  ERROR_NOT_FOUND = "not_found"
+  # エラーコード:すでに存在する
+  ERROR_ALREADY_EXIST = "already_exist"
+
+  # エラーコード:不正な名前
+  ERROR_ILLEGAL_NAME = "illegal_name"
+
+  # エラーコード:想定外エラー
+  ERROR_FATAL = "fatal"
+
+  # エラーコード:サーバーに接続されていない
+  ERROR_NOT_CONNECTED = "not_connected"
+end

data/lib/jiji/models.rb

@@ -0,0 +1,169 @@
+
+require 'jiji/util/util'
+require "jiji/dao/timed_data_dao"
+
+module JIJI
+
+  #==レートの集合
+  class Rates < Hash
+
+    include JIJI::Util::Model
+
+    def initialize( pair_infos, list, time=Time.now )
+      super()
+      @pair_infos = pair_infos.inject({}){ |r,pair|
+        code = JIJI::Util.convert_currency_pair_code(pair[0])
+        r[code] = pair[1]
+        r
+      }
+      @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 )
+      @bid = bid
+      @ask = ask
+      @sell_swap = sell_swap
+      @buy_swap = buy_swap
+      @time = time
+    end
+    # 値を配列で取得する
+    def values
+      [bid,ask,sell_swap,buy_swap,time.to_i]
+    end
+    # 値を配列で設定する
+    def values=(values)
+      @bid = values[0].to_f
+      @ask = values[1].to_f
+      @sell_swap = values[2].to_f
+      @buy_swap  = values[3].to_f
+    end
+    attr_reader :bid, :ask, :sell_swap, :buy_swap
+  end
+
+  #==一定期間のレートの集合
+  class  PeriodicallyRates < Hash
+
+    include JIJI::Util::Model
+
+    def initialize( pair_infos, list=[] )
+      super()
+      @pair_infos = pair_infos
+      list.each {|rates|
+        self << rates
+      }
+    end
+    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
+      @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
+
+    def initialize( list=[] )
+      @bid = PeriodicallyValue.new
+      @ask = PeriodicallyValue.new
+      @sell_swap = PeriodicallyValue.new
+      @buy_swap  = PeriodicallyValue.new
+      list.each { |item|
+        self << item
+      }
+    end
+    def <<( rate )
+      @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
+      bid.values + ask.values + sell_swap.values + buy_swap.values \
+        + [@start_time.to_i, @end_time.to_i]
+    end
+    # 値を配列で設定する
+    def values=(values)
+      @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
+      @end_time
+    end
+    def time=(t)
+      @end_time = t
+    end
+    attr_reader :bid, :ask, :sell_swap, :buy_swap
+    attr :start_time, true
+    attr :end_time, true
+  end
+
+  #==一定期間の値
+  #始値、終値、高値、安値の四本値
+  class PeriodicallyValue
+
+    include JIJI::Util::Model
+
+    def initialize( list=[] )
+      list.each { |item|
+        self << item
+      }
+    end
+    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
+      [@start, @end, @max, @min]
+    end
+    # 値を配列で設定する
+    def values=(values)
+      @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

data/lib/jiji/operator.rb

@@ -0,0 +1,405 @@
+
+require 'fileutils'
+require 'delegate'
+require 'jiji/util/util'
+require 'jiji/single_click_client'
+require 'jiji/util/util'
+require 'jiji/dao/timed_data_dao'
+require 'uuidtools'
+
+module JIJI
+
+  #==オペレーター
+  class Operator
+
+    #===コンストラクタ
+    #*money*:: 保証金
+    def initialize( trade_result_dao=nil, money=nil )
+      @rate = nil
+      @money = money
+      @profit_or_loss = 0
+      @fixed_profit_or_loss = 0
+      @positions = {}
+      @draw = 0
+      @lose = 0
+      @win = 0.0
+      @trade_result_dao = trade_result_dao
+    end
+
+    #===レートを更新する。
+    def next_rates( rate )
+      @rate = rate
+      result = @positions.inject({:total=>0.0,:profit=>0}) {|r,e|
+        p = e[1]
+        p.next(rate)
+        r[:total] += p.price if p.state == Position::STATE_START
+        r[:profit] += p.profit_or_loss
+        r
+      }
+      @profit_or_loss = result[:profit] + @fixed_profit_or_loss
+      if @money && (( @money + result[:profit] ) / result[:total]) <= 0.007
+        raise "loss cut"
+      end
+      @trade_result_dao.next( self, rate.time ) if @trade_result_dao
+    end
+
+    #===購入する
+    #count:: 購入する数量
+    #pair:: 通貨ペア(:EURJPYなど)
+    #trader:: 取引実行者識別用の名前
+    #return:: Position
+    def buy(count, pair=:EURJPY, trader="")
+      rate = @rate[pair]
+      unit = @rate.pair_infos[pair].trade_unit
+      p = Position.new( UUID.random_create().to_s, Position::BUY, count,
+        unit, @rate.time, rate.ask, pair, trader, self )
+      p.next( @rate )
+      @profit_or_loss += p.profit_or_loss
+      @positions[p.position_id] = p
+      @trade_result_dao.save( p ) if @trade_result_dao
+      return p
+    end
+
+    #===売却する
+    #count:: 売却する数量
+    #pair:: 通貨ペア(:EURJPYなど)
+    #trader:: 取引実行者識別用の名前
+    #return:: Position
+    def sell(count, pair=:EURJPY, trader="")
+      rate = @rate[pair]
+      unit = @rate.pair_infos[pair].trade_unit
+      p = Position.new( UUID.random_create().to_s, Position::SELL, count,
+        unit, @rate.time, rate.bid, pair, trader, self )
+      p.next( @rate )
+      @profit_or_loss += p.profit_or_loss
+      @positions[p.position_id] = p
+      @trade_result_dao.save( p ) if @trade_result_dao
+      return p
+    end
+
+    # 取引を確定する
+    def commit(position)
+      position._commit
+      @trade_result_dao.save( position ) if @trade_result_dao
+      @positions.delete position.position_id
+
+      @fixed_profit_or_loss += position.profit_or_loss
+      if position.profit_or_loss == 0
+        @draw+=1
+      elsif position.profit_or_loss < 0
+        @lose+=1
+      else
+        @win+=1
+      end
+    end
+
+    # 勝率
+    def win_rate
+      win > 0 ? win / (win+lose+draw) : 0.0
+    end
+
+    # 未約定のポジションデータを"ロスト"としてマークする。
+    def stop
+      @positions.each_pair {|k, v|
+        v.lost
+        @trade_result_dao.save( v ) if @trade_result_dao
+      }
+    end
+
+    # すべてのポジションデータを保存する。
+    def flush
+      @positions.each_pair {|k, v|
+        @trade_result_dao.save( v ) if @trade_result_dao
+      }
+    end
+
+    #現在の損益
+    attr_reader :profit_or_loss
+    #現在の確定済み損益
+    attr_reader :fixed_profit_or_loss
+    #建て玉
+    attr :positions
+
+    # 勝ち数
+    attr_reader :win
+    # 負け数
+    attr_reader :lose
+    # 引き分け
+    attr_reader :draw
+
+    attr :conf, true
+  end
+
+
+
+  #==ポジション
+  class Position
+
+    #売り/買い区分
+    SELL = 0
+    BUY  = 1
+
+    #状態:注文中
+    STATE_WAITING = 0
+    #状態:新規
+    STATE_START = 1
+    #状態:決済注文中
+    STATE_FIX_WAITING = 2
+    #状態:決済済み
+    STATE_FIXED = 3
+    #状態:約定前にシステムが再起動された
+    STATE_LOST = 4
+
+    #===コンストラクタ
+    #
+    #*sell_or_buy*:: 売りor買い
+    #*count*:: 数量
+    #*unit*:: 取引単位
+    #*date*:: 取引日時
+    #*rate*:: レート
+    #*pair*:: 通貨ペア
+    #*trader*:: 取引実行者
+    #*operator*:: operator
+    #*open_interest_no*:: 建玉番号
+    #*order_no*:: 注文番号
+    def initialize( position_id, sell_or_buy, count, unit, date, rate, pair,
+      trader, operator, open_interest_no="", order_no="" )
+      @position_id = position_id
+      @sell_or_buy = sell_or_buy
+      @count = count
+      @unit = unit
+      @price = (count*unit*rate).to_i
+      @date = date
+      @profit_or_loss = 0
+      @state =STATE_START
+      @rate = rate
+      @pair = pair
+      @trader = trader
+
+      @open_interest_no = open_interest_no
+      @order_no = order_no
+
+      @operator = operator
+      @info = {}
+      @swap = 0
+      @swap_time = Time.local( date.year, \
+        date.month, date.day, operator.conf.get([:swap_time], 5 ))
+      @swap_time += 60*60*24 if date > @swap_time
+    end
+
+    def _commit
+      raise "illegal state" if @state != STATE_START
+      @state = STATE_FIXED
+      @fix_date = @current_date
+      @fix_rate = @current_rate
+    end
+
+    def lost
+      @state = STATE_LOST
+    end
+
+    #===現在価格を更新
+    def next(rates)
+      return if @state == STATE_FIXED
+      rate = rates[@pair]
+      @current_rate = @sell_or_buy == BUY ? rate.bid : rate.ask
+      @current_price = (@count * @unit * @current_rate).to_i
+
+      # swap
+      if @swap_time <= rates.time
+        @swap += @sell_or_buy == BUY ? rate.buy_swap : rate.sell_swap
+        @swap_time += 60*60*24
+      end
+
+      @profit_or_loss = @sell_or_buy == BUY \
+          ? @current_price - @price + @swap\
+          : @price - @current_price + @swap
+
+      @current_date = rates.time
+    end
+
+    def [](key)
+      @info[key]
+    end
+    def []=(key, value)
+      @info[key] = value
+    end
+
+    def values
+      {
+        :position_id => position_id,
+        :open_interest_no=> open_interest_no,
+        :sell_or_buy =>  sell_or_buy == JIJI::Position::SELL ? :sell : :buy,
+        :state => state,
+        :date => date.to_i,
+        :fix_date => fix_date.to_i,
+        :count => count ,
+        :price => price,
+        :profit_or_loss => profit_or_loss.to_i,
+        :rate => rate,
+        :fix_rate => fix_rate,
+        :swap=> swap,
+        :pair => pair,
+        :trader => trader
+      }
+    end
+
+    # クライアント
+    attr :operator
+    # 建玉番号
+    attr :open_interest_no, true
+    # 注文番号
+    attr :order_no, true
+
+    # 一意な識別子
+    attr_reader :position_id
+    # 売りか買いか?
+    attr_reader :sell_or_buy
+    # 状態
+    attr_reader :state
+
+    # 購入日時
+    attr_reader :date
+    # 決済日時
+    attr_reader :fix_date
+    # 取引数量
+    attr_reader :count
+    # 取得金額
+    attr_reader :price
+    # 現在価値
+    attr_reader :current_price
+    # 現在の損益
+    attr_reader :profit_or_loss
+    # 購入時のレート
+    attr_reader :rate
+    # 決済時のレート
+    attr_reader :fix_rate
+    # 決済時のレート
+    attr_reader :swap
+    # 通貨ペア
+    attr_reader :pair
+    # 取引実行者
+    attr_reader :trader
+  end
+
+  #==リアル取引用オペレーター
+  class RmtOperator < Operator
+
+    #===コンストラクタ
+    #*client*:: クライアント
+    #*logger*:: ロガー
+    #*money*:: 保証金
+    def initialize( client, logger, trade_result_dao, trade_enable=true, money=nil )
+      super(trade_result_dao,money)
+      @client = client
+      @logger = logger
+      @trade_enable = trade_enable
+    end
+
+    #===購入する
+    #*count*:: 購入する数量
+    #*return*:: Position
+    def buy(count, pair=:EURJPY, trader="")
+      open_interest_no = nil
+      order_no = nil
+      if @trade_enable
+        JIJI::Util.log_if_error_and_throw( @logger ) {
+	        rate = @rate[pair]
+		      # 成り行きで買い
+		      result = @client.request{ |fx|
+		        fx.order( JIJI::Util.convert_currency_pair_code_r(pair),
+		          ClickClient::FX::BUY, count, options={:slippage_base_rate=>rate.bid} )
+	        }
+	        open_interest_no = result.open_interest_no
+	        order_no = result.order_no
+	      }
+	    end
+      p = super(count, pair, trader)
+      p.open_interest_no = open_interest_no
+      p.order_no = order_no
+      p
+    end
+
+    #===売却する
+    #*count*:: 売却する数量
+    #*return*:: Position
+    def sell(count, pair=:EURJPY, trader="")
+      open_interest_no = nil
+      order_no = nil
+      if @trade_enable
+	      JIJI::Util.log_if_error_and_throw( @logger ) {
+	        rate = @rate[pair]
+	        # 成り行きで売り
+		      result = @client.request {|fx|
+		        fx.order( JIJI::Util.convert_currency_pair_code_r(pair),
+		          ClickClient::FX::SELL, count, options={:slippage_base_rate=>rate.ask} )
+	        }
+	        open_interest_no = result.open_interest_no
+	        order_no = result.order_no
+	      }
+	    end
+      p = super(count, pair, trader)
+      p.open_interest_no = open_interest_no
+      p.order_no = order_no
+      p
+    end
+
+    # 取引を確定する
+    def commit(position)
+      if @trade_enable
+	      JIJI::Util.log_if_error_and_throw( @logger ) {
+	        @client.request {|fx|
+	          fx.settle( position.open_interest_no, position.count )
+	        }
+	      }
+	    end
+      super(position)
+    end
+
+    attr :trade_enable, true
+  end
+
+  # 各エージェントに設定されるオペレータ。
+  # 取引者としてエージェント名を指定して売り買いを行なう。
+  # また、建玉を独自に保持する。(エージェント間で共有されない)
+  # 売/買ロジック自体ははオペレータに委譲する。
+  class AgentOperator
+    def initialize( operator, agent_name )
+      @operator = operator
+      @name = agent_name
+      @positions = {}.taint
+    end
+
+    #===購入する
+    #count:: 購入する数量
+    #pair:: 通貨ペア
+    #return:: ポジション
+    def buy(count, pair=:EURJPY)
+      p = @operator.buy( count, pair, @name )
+      @positions[p.position_id] = p
+      return p
+    end
+
+    #===売却する
+    #count:: 売却する数量
+    #pair:: 通貨ペア
+    #return:: ポジション
+    def sell(count, pair=:EURJPY)
+      p = @operator.sell( count, pair, @name )
+      @positions[p.position_id] = p
+      return p
+    end
+
+    # 取引を確定する
+    def commit(position)
+      @operator.commit(position)
+      @positions.delete position.position_id
+    end
+   
+    #建て玉
+    attr_reader :positions
+    
+  end
+
+end
+