internethakai 0.2.0

data/lib/internethakai/hakairev/task.rb

@@ -0,0 +1,39 @@
+module InternetHakai
+    class TaskQueue < BaseHandler
+        UNIQUE_BY_THREAD = false
+        require 'thread'
+        def initialize id
+            super(id)
+            @queue = []
+            #@queue = Queue::new
+            #@watcher = Rev::AsyncWatcher::new
+            #this = self
+            #task = lambda{
+            #    this.run
+            #}
+            #@watcher.on_signal(&task)
+        end
+        def get
+            @queue.shift
+            #@queue.deq
+        end
+        def empty?
+            @queue.empty?
+        end
+        def add v
+            #puts "add"
+            @queue.push(v)
+            #@queue.enq(v)
+            #@watcher.signal
+        end
+        def clear
+            while !@queue.empty?
+                run
+            end
+        end
+        def run
+            task, args = @queue.shift
+            task.call(*args) if task
+        end
+    end
+end

data/lib/internethakai/hakairev/time_register.rb

@@ -0,0 +1,116 @@
+module InternetHakai
+    class RevTimeRegister < TimeRegister
+        def next_record
+            @reports << @report
+            @report = ResponseRecord::new
+            @cnt = 0
+        end
+        def get_record
+            exec
+            return @report if @reports.empty?
+            next_record
+            @reports.each do |r|
+                @report += r
+            end
+            @reports = []
+            @report
+        end
+        def on_create
+            @report = ResponseRecord::new
+            @reports = []
+            @stack = []
+            @cnt = 0
+        end
+        def exec
+            @stack.each do |arg|
+                do_regist(*arg)
+            end
+            @stack = []
+            @cnt += 1
+            next_record if @cnt == 10
+        end
+    end
+    class PipeTimeRegister < TimeRegister
+        def on_create
+            super
+            @wpipe = TimeRegistProcess::wpipe
+        end
+        def get_record
+            return @data if @data
+            @wpipe.write("get\n")
+            io = TimeRegistProcess::rpipe
+            @data = Marshal::load(io)
+        end
+        attr_accessor :wpipe
+        def do_regist name, time, response, error
+            if response.nil?
+                status = 0; size = 0
+            else
+                status = response.status; size = response.body.size
+            end
+            @wpipe.write(['regist', name, time, status, size, error].join("\t")+"\n")
+        end
+    end
+    class TimeRegistProcess
+        def self::wpipe
+            @@wpipe
+        end
+        def self::rpipe
+            @@rpipe
+        end
+        def self::run
+            @@alive = true
+            @@rpipe, w = ::IO::pipe
+            r, @@wpipe = ::IO::pipe
+            @@wpipe = Rev::IO::new(@@wpipe)
+            @@wpipe.attach(Rev::Loop::default)
+            fork do
+                revio = RWatcher::new(r)
+                revio.attach(Rev::Loop::default)
+                self::new(revio, w)
+                Rev::Loop::default.run
+            end
+        end
+        def initialize(rpipe, wpipe)
+            @report = ResponseRecord::new
+            @rpipe = rpipe
+            @wpipe = wpipe
+            @rpipe.on_read(&method(:on_read))
+        end
+        def on_read str
+            str.each_line do |l|
+                parse l
+            end
+        end
+        def parse line
+            method, name, time, status, size, err = line.chomp.split("\t")
+            case method
+                when 'regist'
+                regist name, time.to_f, status, size.to_i, err.to_i
+                when 'get'
+                Marshal::dump(@report, @wpipe)
+                Rev::Loop::default.stop
+            end
+        end
+        def regist name, time, status, size, err
+            time = time.to_f
+            v = @report[name]
+            v[:size]          += size
+
+            if v[:min].nil? and time != 0
+                v[:min] = time
+                v[:max] = time
+            elsif time != 0
+                v[:min] = v[:min] < time ? v[:min] : time
+            end
+            if time != 0
+                v[:max] = v[:max] > time ? v[:max] : time
+            end
+            v[:totaltime]     += time ## 総合時間
+            v[:accesscount]   += 1 if time > 0
+            v[:errorcount] += err
+            v["status:#{status}"] = v["status:#{status}"].to_i + 1 unless status!=0
+            v["time:#{((time*1000).to_i/100)*100}"] = v["time:#{((time*1000).to_i/100)*100}"].to_i + 1
+        end
+    end
+end

data/lib/internethakai/hakairev/timer_factory.rb

@@ -0,0 +1,38 @@
+module InternetHakai
+    class TimerFactory
+        @@instance = nil
+        def self::instance
+            @@instance
+        end
+        def initialize timeout, concurrency, loop
+            @timeout = timeout
+            @concurrency = concurrency
+            @loop = loop
+            @stack = []
+            @@instance = self
+            prepare
+        end
+        def prepare
+            1.upto(@concurrency) do
+                @stack << create
+            end
+        end
+        def create
+            timer = Rev::TimerWatcher::new(@timeout, true)
+            timer.attach(@loop)
+            timer.disable
+            return timer
+        end
+        def collect timer
+            return if timer.nil?
+            timer.disable if timer.enabled?
+            @stack.push(timer)
+        end
+        def get
+            timer = @stack.shift || create
+            timer.reset
+            timer.enable unless timer.enabled?
+            return timer
+        end
+    end
+end

data/lib/internethakai/http_client.rb

@@ -0,0 +1,120 @@
+module InternetHakai
+    module HttpClientIf
+        def release
+        end
+        def reconnect 
+        end
+        def set_callback(on_complete, on_error)
+        end
+        def set_cookie cookie
+        end
+    end
+    class HttpClient
+        include HttpClientIf
+        require 'net/http'
+        require 'uri'
+        attr_reader :requestURL, :response, :busy
+        attr_accessor :timeout
+        def self::create host, port
+            o = self::new(host,port)
+            o
+        end
+        # コンストラクタ
+        def initialize(host, port)
+            @host = host
+            @port = port
+            @on_error = nil
+            @on_success = nil
+            free()
+            @header = Hash::new
+            Net::HTTP.version_1_2
+            if ENV["HTTP_PROXY"]
+                @proxy = ENV["HTTP_PROXY"].split(':')
+            end
+        end
+        # コンストラクタ/デストラクタヘルパ
+        def free()
+            @client     = nil
+            @ca_path    = nil
+            @requestURL = nil
+            @response   = nil
+            @timeout = nil
+            @header = nil
+            @proxy = nil
+            @post_string = nil
+            @response_time = nil
+            @busy = false
+        end
+        def set_headers header
+            @header = header
+        end
+        def set_cookie cookie
+            @cookie = cookie
+        end
+        def set_header key, value
+            @header[key] = value
+        end
+        def has_callback
+            !@on_success.nil? and !@on_error.nil?
+        end
+        def set_callback on_success, on_error
+            @on_success = on_success
+            @on_error = on_error
+        end
+        def encode_cookie req
+            return unless @cookie
+            req['Cookie'] = @cookie.map{|k,v|
+                "#{k}=#{v}"
+            }.join(';')
+        end
+        def request_send method, path, body = nil
+            if method == GET
+                req = Net::HTTP::Get::new(path, @header)
+            elsif method == POST
+                req = Net::HTTP::Post::new(path, @header)
+                if body
+                    @post_string = body
+                end
+            else
+                raise 'invalid method'
+            end
+            encode_cookie(req)
+            begin
+                response = nil
+                @busy = true
+                if @proxy
+                    Net::HTTP::Proxy(@proxy[0], @proxy[1]).start(@host, @port) do |http|
+                        http.read_timeout = @timeout
+                        @starttime = Time::now
+                        response = http.request(req, @post_string)
+                        @response_time = Time::now - @starttime
+                    end
+                else
+                    Net::HTTP.start(@host, @port) do |http|
+                        http.read_timeout = @timeout
+                        #puts "send: #{object_id}"
+                        @starttime = Time::now
+                        response = http.request(req, @post_string)
+                        @response_time = Time::now - @starttime
+                    end
+                end
+                $REQUEST_COUNT += 1
+            rescue Exception => err
+                @on_error.call(err) if @on_error
+                @busy = false
+                return
+            end
+            if response.nil?
+                @response = nil
+            else
+                @response = ResponseObject::create_from_nethttp(response)
+            end
+            #puts "starttime: #{@starttime.usec} : #{object_id}"
+            #puts "restime: #{@response_time} : #{object_id}"
+            @response.time = @response_time
+            @on_success.call(@response) if @on_success
+            @busy = false
+            @response
+        end
+    end
+end

data/lib/internethakai/logger.rb

@@ -0,0 +1,52 @@
+module InternetHakai
+    # = ロガー
+    class Logger < BaseHandler
+        UNIQUE_BY_THREAD = false
+        def init(config)
+            @config = config
+            level = @config['log_level']
+            if level <= 3
+                def debugverbose text
+                end
+            end
+            if level <= 2
+                def debug text
+                end
+            end
+            if level == 1
+                def emerg text
+                end
+            end
+            @level = level
+        end
+        # 出力ログレベルより小さいレベルの場合に出力
+        def run text, level = 3
+            case level
+                when 4
+                debugverbose text
+                when 3
+                debug text
+                when 2
+                emerg text
+                when 1
+                crit text
+            end
+        end
+        def crit text
+            print text
+            STDOUT.flush
+        end
+        def emerg text
+            print text
+            STDOUT.flush
+        end
+        def debug text
+            print Util::recover_encoding(text, @config)
+            STDOUT.flush
+        end
+        def debugverbose text
+            print Util::recover_encoding(text, @config)
+            STDOUT.flush
+        end
+    end
+end

data/lib/internethakai/main.rb

@@ -0,0 +1,90 @@
+module InternetHakai
+    class Main
+        require 'optparse'
+        def load_config configpath, basepath = nil, args = nil
+            args ||= {}
+            @basepath = basepath || File::dirname(configpath)
+            @scenario_builder = ScenarioBuilder::new(nil)
+            @scenario_builder.load(configpath)
+            @scenario_handler = BaseHandler::get_handler("ScenarioHandler")
+            @config = @scenario_builder.get_config
+            BaseHandler::set_config(@config)
+            @scenario_handler.init(@config)
+
+            reporter = BaseHandler::get_handler(@config["reporter"])
+            if(@config["log_dir"])
+                @basepath = @config["log_dir"]
+            end
+            starttime = Time::now
+            @starttime = starttime
+            start = starttime.strftime( '%Y%m%d_%H%M%S' )
+            reporter.set_dir(@basepath)
+            reporter.init_filename(start)
+            @config['loop'] = args[:loop] if args.has_key? :loop
+            @config['max_request'] = args[:max_request] if args.has_key? :max_request
+            @config['max_scenario'] = args[:concurrency] if args.has_key? :concurrency
+            if @test
+                @config['loop'] = 1
+                @config['max_request'] = 1
+                @config['concurrency'] = 1
+                @config['max_scenario'] = 1
+                @config.delete('fork')
+                @config.delete('max_process')
+                @config['max_request_show'] = 1
+                @config['max_scenario_show'] = 1
+                @config['log_level'] = 3
+            end
+
+            @report_path = reporter.get_filename
+            @logger = BaseHandler::get_handler(@config["logger"])
+            @logger.init(@config)
+            @logger.run(start + "\n", 2)
+            @logger.run("Rev Mode\n", 2) if @config['rev']
+            @logger.run("Target domain = #{@config['domain']}\n", 2)
+            @logger.run("Loop: #{@config['loop']}\n", 2)
+            @logger.run("Request Concurrency: #{@config['max_request_show']}\n", 2)
+            @logger.run("Scenario Concurrency: #{@config['max_scenario_show']}\n", 2)
+        end
+        def main config=nil
+            #引数か、同じディレクトリの「scenario.yml」を読み込みます。
+            if config.nil?
+                config = ARGV[0]
+            end
+            unless config
+                puts "Usage: #{File::basename($0)} SCENARIO"
+                exit
+            end
+            args = {}
+            @test = false
+            opts = OptionParser.new("Usage: #{File::basename($0)} SCENARIO")
+            opts.on("-v", "--version", "show version") do
+                puts "%s %s" %[File.basename($0), InternetHakai::VERSION]
+                puts "ruby %s" % RUBY_VERSION
+                exit
+            end
+            opts.on("--test", "exec in testmode") do
+                @test = true
+            end
+            opts.on('-l', '--loop' 'loop') do |loop|
+                args[:loop] = loop
+            end
+            opts.on('-s', '--max-scenario', 'max-scenario') do |conc|
+                args[:concurrency] = conc
+            end
+            opts.on('-r', '--max-request', 'max-request') do |mr|
+                args[:max_request] = mr
+            end
+            opts.on_tail("-h", "--help", "show this message") do
+                puts opts
+                exit
+            end
+            opts.version = InternetHakai::VERSION
+            opts.parse!(ARGV)
+
+            load_config config, nil, args
+
+            @test = InternetHakai::ConcurrencyManager::new
+            @test.run(@config, @basepath, @starttime)
+        end
+    end
+end