unageanu-jiji 0.1.0

data/lib/jiji/agent/permitter.rb

@@ -0,0 +1,128 @@
+
+require 'jiji/error'
+require 'jiji/util/file_lock'
+require 'set'
+
+module JIJI
+
+  module Permitted
+    def permitted_request( *args, &block )
+      r = JIJI::Permitter::Request.new( self, _function_name, args, 
+        block, @permitter_allows, @permitter_proxy_result )
+      @permitter << r
+      return r.wait
+    end
+    def _function_name
+      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ caller.first
+        return $3
+      end
+    end
+    attr :permitter, true
+    attr :permitter_allows, true
+    attr :permitter_proxy_result, true
+  end
+
+  #==任意のオブジェクトのAPIをセーフレベルの高い環境から呼び出せるようにする。
+  class Permitter
+    # コンストラクタ
+    #*pool_size*:: スレッドプールのサイズ
+    def initialize( pool_size=5, level=2 )
+      @alive = true
+      @alive_mutex = Mutex.new
+      @q = Queue.new
+      @ts = []
+      pool_size.times {
+	      @ts << Thread.fork {
+	        $SAFE = level
+          while( @alive_mutex.synchronize { @alive } )
+            req = @q.pop
+            req.exec(self) if req
+          end
+	      }
+      }
+    end
+    # リクエストを追加する。
+    def <<(request)
+      @q.push request
+    end
+    # インスタンスを破棄する。不要になった場合に必ず呼び出すこと。
+    def close
+      @alive_mutex.synchronize {
+        @alive = false
+      }
+      @ts.length.times {
+        @q.push nil
+      }
+      @ts.each {|t| t.join }
+    end
+    # 指定したインスタンスのAPIをセーフレベルの高い環境から呼び出せるようにする。
+    #*object*:: APIの呼び出しを許可するオブジェクト
+    #*allows*:: 許可するAPIを示す正規表現の配列
+    #*proxy_result*:: 戻り値もプロキシを設定するAPIを示す正規表現の配列
+    def proxy( object, allows=[], proxy_result=[])
+      clazz = class << object
+        include JIJI::Permitted
+        self
+      end
+      object.permitter = self
+      object.permitter_allows = allows
+      object.permitter_proxy_result = proxy_result
+      object.methods.each {|name|
+        next unless allows.find {|a| name.to_s =~ a }
+
+        # もともとのメソッドは、別名でキープしておく
+        old = name.to_s + "_without_permittion"
+        # 2重のアスペクト適用を防ぐ。
+        next if clazz.method_defined? old.to_sym
+        
+        clazz.__send__(:alias_method, old.to_sym, name.to_sym )
+        # インターセプタ適用対象のメソッドを上書きで定義。
+        clazz.__send__(:alias_method, name.to_sym, :permitted_request )
+      }
+      object
+    end
+
+    # メソッド呼び出しリクエスト
+    class Request
+      def initialize( receiver, name, args, block=nil, allows=[], proxy_result=[] )
+        @name = name
+        @args = args
+        @block = block
+        @receiver = receiver
+        @mutex = Mutex.new
+        @cv = ConditionVariable.new
+        @finished = false
+        @value = nil
+        @error = nil
+        @allows = allows
+        @proxy_result = proxy_result
+      end
+      # リクエストの完了を待ち、結果を返す。
+      def wait
+        @mutex.synchronize{
+          @cv.wait( @mutex ) until @finished
+        }
+        raise @error if @error
+        @value
+      end
+      # リクエストを実行する
+      def exec( permitter )
+        begin
+          m = @name + "_without_permittion"
+          @value = @block ? @receiver.send( m, *@args, &@block ) : @receiver.send( m, *@args )
+          if @proxy_result.find {|a| @name.to_s =~ a }
+            @value = permitter.proxy( @value, @allows, @proxy_result )
+          end
+        rescue Exception
+          @error = $!
+        ensure
+          @mutex.synchronize{
+            @finished = true
+            @cv.signal
+          }
+        end
+      end
+    end
+  end
+
+end

data/lib/jiji/agent/util.rb

@@ -0,0 +1,16 @@
+
+module JIJI
+
+  module AgentUtil
+
+    #ブロックを指定のセーフレベルで実行する。
+    #level:: セーフレベル
+    def safe(level=4)
+      Thread.fork {
+        $SAFE = level
+        yield if block_given?
+      }.value
+    end
+  end
+
+end

data/lib/jiji/collector.rb

@@ -0,0 +1,219 @@
+
+require "jiji/models"
+require "jiji/dao/rate_dao"
+require 'jiji/util/util'
+require "thread"
+require "date"
+
+module JIJI
+
+  #
+  #==レート一覧を取得しオブザーバーに通知するクラス
+  #- 設定値で指定された間隔でレート一覧を取得し、JIJI::ObserverManagerに通知する。
+  #
+  class Collector
+
+    #コンストラクタ
+    def initialize
+      @alive = false
+      @state_mutex = Mutex.new
+      @end_mutex = Mutex.new
+      @future = nil
+      @state_mutex.synchronize {
+        @state = :WAITING
+        @listeners = []
+      }
+    end
+
+    #収集を開始する。
+    def start
+      @state_mutex.synchronize {
+        @state = :RUNNING
+      }
+      @end_mutex.synchronize {
+        @alive = true
+        @future = Thread.fork {
+          start_collect
+          :finished
+        }
+      }
+    end
+
+    #収集を停止する。
+    #- サーバーが終了した際に呼び出される。
+    #- JIJI::ObserverManagerの破棄も内部で行う。
+    def stop
+      @end_mutex.synchronize {
+        return unless @alive # 実行していない場合何もしない。
+        @alive = false
+      }
+      # スレッドの完了を待つ
+      @future.value
+    end
+
+    #進捗(%を示す整数)を取得する
+    def progress
+      0 # リアルトレードでは常に0
+    end
+    #状態を取得する。
+    #戻り値:: 状態を示すシンボル。
+    #           :WAITING ..  実行待ち状態
+    #           :RUNNING ..  実行中
+    #           :CANCELED ..  実行がキャンセルされた(JIJI::BackTestCollectorのみ)
+    #           :FINISHED ..  実行完了(JIJI::BackTestCollectorのみ)
+    #           :ERROR_END ..  エラー終了(JIJI::BackTestCollectorのみ)
+    def state
+      @state_mutex.synchronize {
+        @state
+      }
+    end
+
+    #待ち時間
+    attr :wait_time, true
+    #コンフィグレーション
+    attr :conf, true
+    #JIJI::ObserverManager
+    attr :observer_manager, true
+    #ロガー
+    attr :logger, true
+    #JIJI::SingleClickClient
+    attr :client, true
+    #情報取得中に発生したエラー
+    attr_reader :error
+
+    # 収集終了の通知を受けるリスナ。
+    attr :listeners, true
+
+  private
+    def start_collect
+      begin
+        @logger.info( "collector start" )
+        JIJI::Util.log_if_error_and_throw( @logger ) {
+          # 通貨ペア情報を取得
+          @pair_infos = @client.request{|fx|
+            fx.list_currency_pairs
+          }
+        }
+        collect
+      rescue Exception
+        @error = $!
+      ensure
+        @logger.info( "collector finished" )
+        JIJI::Util.log_if_error( @logger ) {
+          @observer_manager.stop # 終了を通知
+          state = @end_mutex.synchronize { @alive } \
+            ? ( @error ? :ERROR_END : :FINISHED ) \
+            : :CANCELED
+          @state_mutex.synchronize {
+            @state = state
+          }
+          @end_mutex.synchronize { @alive = false }
+
+          # リスナに通知
+          @listeners.each {|l|
+            begin
+              l.on_finished( @state, Time.at(@now) ) if l.respond_to? :on_finished
+            rescue Exception
+            end
+          }
+        }
+      end
+    end
+    def collect
+      while( @end_mutex.synchronize { @alive } ) #停止されるまでループ
+        JIJI::Util.log_if_error( @logger ) {
+          #通貨ペアコードを変換
+          list = @client.request{|fx|
+            fx.list_rates.inject({}) {|r,p|
+              code = JIJI::Util.convert_currency_pair_code(p[0])
+              r[code] = p[1]
+              r
+            }
+          }
+          #オブザーバーに通知
+          @observer_manager.next_rates Rates.new( @pair_infos, list )
+          @now = Time.now # 現在時刻を更新
+
+          # 一定期間待つ
+          sleep @conf.get([:collector, :wait_time], 10 )
+        }
+      end
+    end
+  end
+
+  #
+  #==指定された期間のログからレート一覧を取得し、JIJI::ObserverManagerに通知するクラス
+  #
+  class BackTestCollector < Collector
+
+    #コンストラクタ
+    #rate_dao:: レート情報の取得先とするJIJI::RateDao
+    #start_date:: 読み込み開始日時
+    #end_date:: 読み込み終了日時
+    def initialize( rate_dao, start_date, end_date )
+      super()
+      @dao = rate_dao
+      @start_date = start_date
+      @end_date  =  end_date
+      @progress = 0
+    end
+    def collect
+      JIJI::Util.log_if_error_and_throw( @logger ) {
+        begin
+          pairs =  @dao.list_pairs
+          if pairs.length > 0
+            @start_date = @start_date || Time.at( @dao.dao(pairs[0]).first_time(:raw) )
+            @end_date = @end_date || Time.at( @dao.dao(pairs[0]).last_time(:raw) )
+          end
+          @dao.each_all_pair_rates(:raw, @start_date, @end_date ) {|rates|
+            each_rate(rates)
+            # キャンセルチェック
+            if ( !@end_mutex.synchronize { @alive } )
+              @logger.info( "collector canceled" )
+              break
+            end
+          }
+        ensure
+          @state_mutex.synchronize {
+            @progress = 100
+          }
+        end
+      }
+    end
+    def progress
+      @state_mutex.synchronize {
+        @progress
+      }
+    end
+
+    #レートDAO
+    attr_reader :dao
+  private
+    # レートを1つ読み込んで通知する。
+    def each_rate(rates)
+      begin
+        tmp = {}
+        time = nil
+        rates.each_pair {|k,v|
+          tmp[k] = Rate.new(
+            v[0].to_f, v[1].to_f, v[2].to_i, v[3].to_i, Time.at(v[4].to_i) )
+          time = Time.at(v[4].to_i) unless time
+        }
+        @observer_manager.next_rates(Rates.new( @pair_infos, tmp, time ))
+      ensure
+
+        # 進捗を更新
+        if @start_date !=nil && @end_date !=nil
+          @state_mutex.synchronize {
+            @now = @end_date.to_i # 現在時刻を更新
+            current = time.to_i - @start_date.to_i
+            all = @end_date.to_i - @start_date.to_i
+            @progress = ( current*100 / all ).to_i
+          }
+        end
+      end
+    end
+
+  end
+
+end

data/lib/jiji/command.rb

@@ -0,0 +1,129 @@
+
+require 'rubygems'
+require "highline"
+require 'jiji/server'
+require 'jiji/util/json_rpc_requestor'
+
+module JIJI
+
+  # コマンドラインツール
+  class Command
+
+    # 設定ファイル置き場
+    JIJI_DIR_NAME = "~/.jiji"
+
+
+    # サービスを開始
+    def start
+      begin
+        puts "jiji started."
+        s = JIJI::FxServer.new( data_dir )
+        s.start
+      rescue Exception
+        puts "[ERROR] start failed.(#{$!.to_s})"
+        return
+      end
+    end
+
+    # サービスを停止
+    def stop
+      begin
+        host = ARGV[1] || "localhost"
+        conf = JIJI::Registry.new(data_dir)[:conf]
+        port = conf.get([:server,:port], 7000).to_i
+        service = JSONBroker:: JsonRpcRequestor.new( "system", "http://#{host}:#{port}" )
+        service.shutdown
+        sleep 10 # 停止完了を待つ。
+        puts "jiji stopped."
+      rescue Exception
+        puts "[ERROR] stop failed.(#{$!.to_s})"
+        return
+      end
+
+    end
+
+    # 初期化
+    def setting
+      h = HighLine.new
+      user = h.ask("> Please input a user name of CLICK Securities DEMO Trade.")
+      pass = h.ask("> Please input a password of CLICK Securities DEMO Trade."){|q| q.echo = '*' }
+      dir  = h.ask("> Please input a data directory of jiji. (default: #{JIJI_DIR_NAME} )")
+      dir = !dir || dir.empty? ? JIJI_DIR_NAME : dir
+
+      port = h.ask('> Please input a server port. (default: 7000 )')
+      port = !port || port.empty? ? "7000" : port
+      unless port =~ /\d+/
+        puts "[ERROR] setting failed.( illegal port number. port=#{port} )"
+        return
+      end
+
+      # ディレクトリ作成
+      begin
+        puts ""
+        ex_dir = File.expand_path(JIJI_DIR_NAME)
+        mkdir ex_dir
+        open( "#{ex_dir}/base", "w" ) {|f|
+          f << dir
+        }
+        puts "create. #{ex_dir}/base"
+
+        # ベースディレクトリの作成
+        dir = File.expand_path(dir)
+        mkdir(dir) if ( dir != ex_dir )
+        mkdir("#{dir}/conf")
+
+        # 設定ファイル
+        open( "#{dir}/conf/configuration.yaml", "w" ) {|f|
+          f << <<-DATA
+---
+server:
+ port: #{port}
+
+securities:
+  account:
+    user:     "#{user}"
+    password: "#{pass}"
+DATA
+        }
+        FileUtils.chmod(0600, "#{dir}/conf/configuration.yaml")
+      rescue Exception
+        puts "[ERROR] setting failed.(#{$!.to_s})"
+        return
+      end
+
+      puts "Setting was completed!"
+    end
+
+
+    def run( args )
+      case  args[0]
+        when "start"; start
+        when "stop";  stop
+        when "setting"; setting
+        when "restart"
+          stop
+          start
+        else
+          name = File.basename( File.expand_path( $0 ))
+          puts "usage : #{name} ( setting | start | stop | restart )"
+      end
+    end
+
+  private
+    # データディレクトリを得る
+    def data_dir
+      base = "#{File.expand_path(JIJI_DIR_NAME)}/base"
+      unless File.exist?( base  )
+        raise "'#{base}' is not found. You need to run 'jiji setting'."
+      end
+      return File.expand_path(IO.read( base  ))
+    end
+    # ディレクトリを作る。
+    def mkdir( path )
+      FileUtils.mkdir_p path
+      FileUtils.chmod(0755, path)
+      puts "create. #{path}"
+    end
+
+  end
+end