jiji 1.2.5

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,226 @@
+
+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
+    #証券会社アクセスクライアント
+    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.list_pairs.inject({}){|r,i|
+            r[i.name.to_sym] = i
+            r
+          }
+        }
+        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 }
+
+          # リスナに通知
+          callback( :on_finished, @state, Time.at(@now || Time.now) )
+        }
+      end
+    end
+    def collect
+      while( @end_mutex.synchronize { @alive } ) #停止されるまでループ
+        JIJI::Util.log_if_error( @logger ) {
+          begin
+            #レート
+            list = @client.list_rates
+            #オブザーバーに通知
+            @observer_manager.next_rates Rates.new( @pair_infos, list )
+            @now = Time.now # 現在時刻を更新
+          ensure
+            # 一定期間待つ
+            sleep @conf.get([:collector, :wait_time], 10 )
+          end
+        }
+      end
+    end
+    # リスナにイベントを通知する
+    def callback( method, *args )
+      @listeners.each {|l|
+        JIJI::Util.log_if_error( @logger ) {
+          l.send(method, *args ) if l.respond_to? method
+        }
+      }
+    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 ) {
+        callback( :on_progress_changed, @progress )
+        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) )
+          else
+            @start_date = @start_date || 0
+            @end_date = @end_date || Time.now
+          end
+          @now = @start_date.to_i
+          @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
+          }
+          callback( :on_progress_changed, @progress )
+        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
+          }
+          callback( :on_progress_changed, @progress )
+        end
+      end
+    end
+
+  end
+
+end

data/lib/jiji/command.rb

@@ -0,0 +1,204 @@
+
+require 'rubygems'
+require "highline"
+require 'logger'
+require 'jiji/server'
+require 'jiji/util/json_rpc_requestor'
+require 'jiji/plugin/plugin_loader'
+require 'jiji/plugin/securities_plugin'
+
+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
+      
+      # アクセス先証券会社
+      JIJI::Plugin::Loader.new.load
+      mng = JIJI::Plugin::SecuritiesPluginManager.new
+      plugins = mng.all
+      index = 0
+      str = plugins.map {|p| "#{index+=1} : #{p.display_name.to_s}" }.join( "\n    " ) 
+      value = h.ask("> Please select a securities.\n    " + str)
+      unless value =~ /\d+/
+        puts "[ERROR] setting failed.( Illegal value. vlaue=#{value} )"
+        return
+      end
+      begin
+        type = plugins[value.to_i-1]
+        unless type
+          puts "[ERROR] setting failed.( Illegal value. vlaue=#{value} )"
+          return
+        end
+      rescue Exception
+        puts "[ERROR] setting failed.( Illegal value. vlaue=#{value} )"
+        return
+      end
+      
+      # 入力
+      values = {:type=>type.plugin_id}
+      type.input_infos.each {|i|
+         value = i.secure ? h.ask("> #{i.description}") {|q| q.echo = '*' } : h.ask("> #{i.description}")
+         if i.validator && error = i.validator.call( value )
+           puts "[ERROR] setting failed.( #{error}. value=#{value} )"
+           return
+         end
+         values[i.key.to_sym] = value
+      }
+      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 << YAML.dump( {
+            :server => { :port=>port.to_i },
+            :securities => values
+          } )
+        }
+        FileUtils.chmod(0600, "#{dir}/conf/configuration.yaml")
+
+        # サンプルエージェント
+        copy_base_files( dir, h  )
+      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 copy_base_files( dir, h  )
+      src_dir = File.expand_path("#{__FILE__}/../../../base/")
+      files = []
+      ["agents","shared_lib"].each {|d| 
+        files += Dir.glob(File.expand_path("#{src_dir}/#{d}/**/*")).reject {|i|
+          File.directory? i
+        }
+      }
+      overwrite = :yes
+      files.each {|f|
+        new_path = f.sub( /#{src_dir}/, dir )
+        if File.exist?(new_path) && overwrite != :all
+          overwrite = ask_overwrite( h, new_path )
+        else
+          overwrite = overwrite != :all ? :yes : :all
+        end
+        if overwrite != :no
+          mkdir( File.dirname( new_path ) )
+          copy( f, new_path )
+        end
+      }
+    end
+    #上書きするかどうか確認する。
+    def ask_overwrite( h, f )
+      result = nil
+      while ( !result )
+        tmp = h.ask("> File #{f} is already exist. Do you want to overwrite? ([y]es/[n]o/[a]ll files)")
+        next if !tmp || tmp.length == 0
+        result = case tmp[0,1].downcase
+          when "y";  :yes
+          when "n";  :no
+          when "a";  :all
+        end
+      end
+      result
+    end
+  
+    # データディレクトリを得る
+    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 )
+      return if File.exist? path
+      FileUtils.mkdir_p path
+      FileUtils.chmod(0755, path)
+      puts "create. #{path}"
+    end
+    # ファイルをコピーする。
+    def copy( path, to )
+      FileUtils.copy( path, to )
+      FileUtils.chmod(0644, to)
+      puts "create. #{to}"
+    end
+  end
+end

data/lib/jiji/configuration.rb

@@ -0,0 +1,86 @@
+
+require 'jiji/util/fix_yaml_bug'
+require 'jiji/util/file_lock'
+
+module JIJI
+
+  #
+  #==設定値
+  #
+  class Configuration
+
+    #コンストラクタ
+    #configuration_file:: 設定ファイルのパス
+    def initialize( configuration_file=nil )
+      @configuration_file=configuration_file
+      load
+    end
+    
+    # データをロードする
+    def load
+      if @configuration_file && File.exist?( @configuration_file )
+        FileLock.new( @configuration_file ).readlock {|f|
+          tmp = YAML.load f
+          @conf = key_to_sym( tmp )
+        }
+      else
+        @conf = {}
+      end
+    end
+
+    #値を取得する。
+    #names:: 値を示すパス 例) [:foo, :var]
+    #default:: 値が存在しない場合の初期値
+    #return:: 値
+    def get( names, default )
+      v = names.inject(@conf) {|conf,i|
+        if conf.kind_of?(Hash)
+          conf[i]
+        else
+          break default
+        end
+      }
+      v == nil ? default : v
+    end
+
+    #値を設定する。
+    #※設定した値は元のファイルには反映されない。プログラムを終了すると失われる。
+    #names:: 値を示すパス 例) [:foo, :var]
+    #value:: 値
+    def set( names, value=nil)
+      key = names.pop
+      names.inject(@conf) {|conf, i|
+        if conf[i].kind_of?(Hash)
+          conf[i]
+        elsif conf[i] == nil
+          conf[i] = {}
+        else
+          raise "illegal key."
+        end
+      }[key] = value
+    end
+
+    #値が存在するか評価する。
+    #names:: 値を示すパス 例) [:foo, :var]
+    #return:: 値があればtrue
+    def key?( names )
+      v = names.inject(@conf) {|conf,i|
+        if conf.kind_of?(Hash)
+          conf[i]
+        else
+          break nil
+        end
+      }
+      v != nil
+    end
+
+    private
+    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