internethakai 0.2.0

data/lib/internethakai/concurrency_manager.rb.~1~

@@ -0,0 +1,331 @@
+module InternetHakai
+    class ConcurrencyManager
+        require 'thread'
+        def initialize
+            @fork_mode = false
+            @rev_mode = false
+            @process = 0
+            @suffix = ''
+            @mutex = nil
+        end
+        attr_accessor :suffix, :process
+        def prepare_rev
+            return if @rev_mode #2回実行しないように
+            require 'rubygems'
+            require 'rev'
+            require 'internethakai/hakairev'
+            #TimeRegistProcess::run
+            @config['http_client'] = 'RevHttpClient'
+            @config['scenario_executer'] = 'NonBlockScenarioExecuter'
+            @config['request_pool'] = 'RequestPoolNonThread'
+            @config['queue'] = 'TaskQueue'
+            #@config['response_handler'] = 'PipeTimeRegister'
+            @config['response_handler'] = 'RevTimeRegister'
+            @config['scan']
+            @rev_mode = true
+        end
+        def prepare_fork
+            return if @fork_mode
+            @concurrency = @config['concurrency']
+            @process_max = @config['fork']['max_process'] || 2
+            @fork_mode = true
+       end
+        def run config, basepath, starttime
+            @config = config
+            @scenario_handler = BaseHandler::get_handler("ScenarioHandler")
+            @failure = false
+            @basepath = basepath
+            BaseHandler::set_config(@config)
+            @logger = BaseHandler::get_handler(@config["logger"])
+            @threads = {}
+
+            @concurrency = @config['concurrency']
+            if @config['rev']
+                prepare_rev
+            end
+            if @config['fork']
+                prepare_fork
+            end
+            @register = BaseHandler::get_handler(@config['response_handler'])
+            reporter = BaseHandler::get_handler(@config["reporter"])
+
+            digit = @config['max_request'].to_s.size
+            @id_tmpl = "%0#{digit}d"
+            if @config['fork']
+                run_fork
+            else
+                run_process
+            end
+        end
+        def run_process
+            #並列数だけシナリオのコピーをつくっておく
+            @config['request_pool'] = 'RequestPoolNonThread' if @config["max_request"] <= 1
+            @scenarios = []
+            1.upto(@concurrency) do
+                @scenarios << @scenario_handler.create_scenario(@suffix)
+            end
+            @scenario_handler.on_scenarios_created
+            $REQUEST_COUNT = 0
+            begin
+                if @rev_mode
+                    rev_start
+                elsif @config["max_request"] <= 1
+                    single_start
+                else
+                    thread_start
+                end
+            rescue SystemExit
+                return
+            rescue Exception => e
+                raise e
+                puts "error: #{e.message}"
+                puts e.backtrace[0]
+                if @fork_mode
+                    #死ぬ前に親に連絡
+                    Process::kill(:USR1, Process::ppid)
+                else
+                    report_collect
+                end
+            end
+        end
+        def single_start
+            th_cnt = 1
+            @threads[1] = Thread::current
+            @scenarios.each do |sc|
+                sc.init
+            end
+            #シングルスレッドのときは先にプールにためておく
+            run_executer th_cnt
+            if @failure
+                page_check
+                exit 1
+            else
+                exit 0
+            end
+        end
+        def page_check
+            keys = @result_record.keys
+            pages = []
+            keys.each do |key|
+                err = @result_record[key][:errorcount] || 0
+                if(err > 0)
+                    pages << key
+                end
+            end
+            unless pages.empty?
+                @logger.run("ERROR URL: #{pages.join(',')}\n", 2)
+            end
+        end
+        def thread_start
+            @mutex = Mutex::new
+            @request_pool = BaseHandler::get_handler(@config['request_pool'])
+            @cv = ConditionVariable::new
+
+            @scenarios.each do |sc|
+                sc.init
+            end
+            @scenario_handler.set_on_turn_complete &method(:on_complete)
+            1.upto(@config["max_request"]) do |th_cnt|
+                @threads[th_cnt] = Thread::new(th_cnt) do |th_cnt|
+                    run_executer th_cnt
+                end
+            end
+            @threads[:main] = Thread::current
+            @mutex.synchronize{
+                @cv.wait(@mutex)
+            }
+            @threads.each do |k,th|
+                th.kill if th!=Thread::current && k!=:main
+            end
+            if @failure
+                exit 1
+            else
+                exit 0
+            end
+        end
+        def run_executer th_cnt
+            th_id = (sprintf(@id_tmpl, th_cnt) + @suffix).to_i
+            report = BaseHandler::get_handler(@config["response_handler"])
+            Thread.current[:result] = report
+            BaseHandler::set_thread_id(th_id)
+            cls = BaseHandler::get_class(@config['scenario_executer'])
+            @scenario_handler.set_on_turn_complete(&@register.method(:exec))
+            exec = cls::new
+            exec.set_on_complete &method(:on_complete)
+            @starttime = Time::now
+            exec.run
+        end
+        # = 1プロセス終了時に呼ばれる
+        def on_complete
+            total = Time::now - @starttime
+            @request_pool = BaseHandler::get_handler(@config['request_pool'])
+            @request_pool.close
+            #puts "thread collect start"
+            thread_collect
+            #puts "thread collect end"
+            report_collect
+            #puts "report collect end"
+            @logger.run("TotalTime: " + total.to_s + "\n", 2) unless @fork_mode
+            @failure = true if $error
+            @cv.signal if @cv
+        end
+        def create_id loop_c, th_c
+            (loop_c.to_s + sprintf(@id_tmpl, th_c) + @suffix).to_i
+        end
+        def thread_collect
+            count = 0
+            status = '.'
+            flag = false
+            count = 0
+            @threads.each do |k, th|
+                if(th[:result])
+                    status = 't'
+                    ect = 0
+                    th[:result].get_record.each do |name,res|
+                        ect += 1 if res[:errorcount] > 0
+                    end
+                    if ect > 0
+                        status = 'e'
+                        flag = true unless flag
+                    end
+                    #th.kill if th!=Thread::current && k!=:main
+                end
+                #@logger.run status, 2
+            end
+            @logger.run "\n", 2 unless @fork_mode
+            @logger.run "result: ", 2 unless @fork_mode
+            if flag
+                @logger.run "failure\n", 2 unless @fork_mode
+            else
+                @logger.run "success\n", 2 unless @fork_mode
+            end
+            @failure = flag
+        end
+        def report_collect
+            d = (Time::now - @starttime)*1000
+            if @fork_mode && @forkdb
+                @forkdb.transaction do
+                    if not @forkdb['time']
+                        @forkdb['time'] = d
+                    elsif @forkdb['time'] < d
+                        @forkdb['time'] = d
+                    end
+                    @forkdb['request_count'] = 0 unless @forkdb['request_count']
+                    @forkdb['request_count'] += $REQUEST_COUNT
+                end
+            else
+                @logger.run "\nTimePerRequest: #{d / ($REQUEST_COUNT / @config['max_request'])}\n", 2
+                @logger.run "RequestPerSec: #{$REQUEST_COUNT / (d/1000)}\n", 2
+            end
+            record = ResponseRecord::new
+            @threads.each do |k, th|
+                if th[:result]
+                    record += th[:result].get_record
+                end
+            end
+            @logger.run("\n\n", 2) unless @fork_mode
+            reporter = BaseHandler::get_handler(@config["reporter"])
+            reporter.run(record)
+            @result_record = record
+        end
+        def run_fork
+            raise "invalid config: fork: nil" unless @config['fork']
+            org_reporter = @config['reporter']
+
+            @logger.run("Process: #{@process_max}\n", 2)
+            @parent = false
+
+            flag = false
+            Signal::trap(:USR1){
+                return if flag
+                flag = true
+                #parent
+                puts "error: SIGUSR1"
+                @pids.each do |pid|
+                    Process::kill(:USR2, pid)
+                end
+            }
+            Signal::trap(:INT){
+                flag = true
+                puts "error: SIGINT"
+                @pids.each do |pid|
+                    Process::kill(:USR2, pid)
+                end
+            }
+            Signal::trap(:USR2){
+                #child
+                report_collect
+                exit
+            }
+
+            #各プロセスにはpstoreファイルに集計させる
+            @config['reporter'] = 'PStoreReporter'
+            fname = 'tmp.db'
+            fpath = File::join(@basepath, fname)
+            if FileTest::exists?(fpath)
+                raise 'cannot create db' unless FileTest::writable?(fpath)
+                raise 'cannot create db' unless File::delete(fpath)
+            end
+            db = PStore::new(fpath)
+            @forkdb = db
+
+            reporter = BaseHandler::get_handler(@config["reporter"])
+            reporter.set_dir(@basepath)
+            reporter.init_filename(fname)
+
+            begin
+                @pids = []
+                @process = @process_max
+                digit = @process_max.to_s.size
+                tmpl = "%0#{digit}d"
+                1.upto(@process_max) do |i|
+                    @pids << Process::fork {
+                        @suffix = sprintf(tmpl, i)
+                        run_process
+                    }
+                    #1プロセス目以外は出力を少なく
+                    @scenario_handler.silence if i==2
+                end
+                @forkreport = false
+                @org_fork_reporter = org_reporter
+                results = Process::waitall
+                failure = false
+                results.each do |r|
+                    if r[1].to_i != 0
+                        failure = true
+                        break
+                    end
+                end
+                @logger.run "\n", 2
+                @logger.run "result: ", 2
+                unless failure
+                    @logger.run "success\n", 2
+                else
+                    @logger.run "failure\n", 2
+                end
+                fork_report
+            ensure
+                fork_report unless @forkreport
+                File::delete(fpath) if File::exists?(fpath)
+            end
+        end
+        def fork_report
+            @forkreport = true
+            require 'pstore'
+            result = nil
+            time = nil
+            count = nil
+            @forkdb.transaction do
+                result = @forkdb['result']
+                time = @forkdb['time']
+                count = @forkdb['request_count']
+            end
+            @logger.run "\nTimePerRequest: #{time / (count / @config['max_request_show'])}\n", 2 if time && count
+            @logger.run "RequestPerSec: #{count / (time/1000)}\n", 2 if time && count
+
+            reporter = BaseHandler::get_handler(@org_fork_reporter)
+            reporter.run(result)
+            reporter = nil
+        end
+    end
+end

data/lib/internethakai/core.rb

@@ -0,0 +1,146 @@
+module InternetHakai
+    # = ハンドラー
+    # スレッドごと / プロセスごとに存在するマネージャー
+    class BaseHandler
+        #trueだとスレッドごとにインスタンス作成
+        UNIQUE_BY_THREAD = true
+
+        @@instances = nil
+
+        @@config = nil
+        @@scenario_id = nil
+        @@thread_id = nil
+        def self::get_config
+            @@config
+        end
+
+        def self::set_config config
+            @@config = config
+        end
+
+        #ゲッター
+        def self::unique_by_thread?
+            self::UNIQUE_BY_THREAD
+        end
+        #スレッドで一意なidを指定します
+        def self::set_thread_id tid
+            Thread::current[:thread_id] = tid
+        end
+        def self::get_thread_id
+            Thread::current[:thread_id]
+        end
+        #クラス名からクラスを取得
+        def self::get_class classname
+            if InternetHakai.const_defined? classname
+                return InternetHakai.const_get(classname)
+            else
+                c = classname.split(/::/).inject(Object) {|c,name|
+                    c.const_get(name) if c.const_defined? name
+                }
+            end
+        end
+        #名前からクラス名を取得し、インスタンスを返します
+        def self::get_handler name
+            begin
+                cl = self::get_class(name)
+            rescue
+                raise "invalid class name"
+            end
+            raise "invalid class" unless cl < BaseHandler
+
+            if cl.unique_by_thread?
+                o = cl::get_instance_thread
+            else
+                o = cl::get_instance
+            end
+            o
+        end
+        #スレッドで一意なインスタンスを返します
+        def self::get_instance_thread
+            cth = Thread::current
+            tid = cth[:thread_id]
+            sid = cth[:scenario_id]
+            cth[:handlers] = Hash::new unless cth[:handlers]
+            handlers = cth[:handlers]
+            unless handlers[self.to_s]
+                handlers[self.to_s] = self::new(tid)
+            end
+            handlers[self.to_s]
+        end
+        #スレッドローカルでないインスタンス
+        def self::get_instance
+            @@instances = Hash::new(nil) unless @@instances
+            @@instances[self.to_s] = self::new(nil) unless @@instances[self.to_s]
+            @@instances[self.to_s]
+        end
+        def self::clear
+            @@instances = nil
+        end
+        def self::clearall
+            InternetHakai::constants.each do |c|
+                cl = InternetHakai::const_get(c)
+                if cl.is_a? Class and cl.respond_to? :clear
+                    cl.clear
+                end
+            end
+        end
+        #作成時に何かしたい場合はこれをオーバーロード
+        def on_create
+
+        end
+        #コンストラクタ
+        #uid作成などに必要な場合にそなえ、スレッドidを持っている
+        def initialize(th_id)
+            @thread_id = th_id
+            on_create
+        end
+    end
+
+    # = ベースアクション
+    # アクションはこのクラスを継承して作成
+    class BaseAction
+        #設定ファイルで指定したオプションがわたされる
+        def initialize opt, scenario
+            @opt = get_default.merge(opt)
+            @scenario_handler = BaseHandler::get_handler('ScenarioHandler')
+            @queue = BaseHandler::get_handler(opt['queue'])
+            @method_quit = method(:quit)
+            @scenario = scenario
+            @scenario_id = @scenario.object_id
+        end
+        attr_accessor :performance_id
+
+        # オプションのデフォルト値を指定したい場合はここを上書き
+        def get_default
+            {"times"=>1, "follow_redirect"=>true}
+        end
+
+        def set_on_complete &block
+            @_on_complete_calback = block
+        end
+        def has_on_complete?
+            not not @_on_complete_calback
+        end
+        # コマンドの中身
+        def run
+            @_complete = false
+            #Thread.current[:heartbeat] = Time::now
+        end
+        # デストラクタ
+        def free
+            #puts "free: #{@_complete}: #{object_id}"
+            return if @_complete #1つのリクエストで2回呼ばないように
+
+            @_on_complete_calback.call if @_on_complete_calback
+            #@queue.add(@method_quit)
+            @scenario_handler.quit_action(@scenario_id)
+            @_complete = false
+        end
+        def dispatch_next
+            @_on_complete_calback.call if @_on_complete_calback
+        end
+        def quit
+            @scenario_handler.quit_action(@scenario_id)
+        end
+    end
+end