DSAS開発者の部屋

require 'net/http'
require 'benchmark'
require 'rubygems'
require 'rev'
require 'eventmachine'
require 'thread'

class RevHttp < Rev::HttpClient
    def on_body_data data
        @content = data
    end
    def on_connect
        super
    end
    def request method, path
        @starttime = Time::now
        super
    end
    def on_request_complete
    end
    event_callback :on_request_complete
end
class EMHttp2 < EventMachine::Protocols::HttpClient2
    def connection_completed
        super
    end
    def request args
        @starttime = Time::now
        super
    end
    attr_reader :starttime
end
class EventMachine::Protocols::HttpClient2::Request
    def starttime
        @conn.starttime
    end
end
def start_rev times, host, port, path, callback
    counter = times
    loop = Rev::Loop::default
    sumtime = 0
    on_complete = lambda{
        counter -= 1
        sumtime += Time::now - @starttime
        if counter==0
            #全リクエスト終了
            loop.stop
        end
    }
    1.upto(times) do
        m = RevHttp::connect(host, port)
        m.on_request_complete &on_complete
        #1秒待ってからリクエスト
        timer = Rev::TimerWatcher::new(1)
        timer.on_timer{
            m.request("GET", path)
        }
        m.attach(loop)
        timer.attach(loop)
    end
    loop.run
    puts "Rev/HttpClient"
    puts "	avg: #{sumtime*1000/times}"
end
def start_em2 times, host, port, path, callback
    counter = times
    sumtime = 0
    on_complete = lambda{|res|
        counter -= 1
        sumtime += Time::now - res.starttime
        if counter==0
            #全リクエスト終了
            callback.call
            EventMachine::stop
        end
    }
    EventMachine::run{
        1.upto(times) do
            m = EMHttp2::connect(host, port)
            #1秒待ってからリクエスト
            timer = EventMachine::Timer::new(1){
                req = m.get(path)
                req.callback &on_complete
            }
        end
    }
    puts "EventMachine/HttpClient2"
    puts "	avg: #{sumtime*1000/times}"
end
def start_nethttp times, host, port, path, callback
    Net::HTTP.version_1_2
    counter = times
    sumtime = 0
    1.upto(times) do
        Thread::start{
            sleep 1 #1秒待つ
            Net::HTTP.start(host, port){|http|
                starttime = Time::now
                res = http.get(path)
                sumtime += Time::now - starttime
            }
            counter -= 1
            if counter==0
                puts "net/http + thread"
                puts "	avg: #{sumtime*1000/times}"
                callback.call
            end
        }
    end
end

def wait &b
    cv = ConditionVariable::new
    mutex = Mutex::new
    f = lambda{
        mutex.synchronize{
            cv.signal
        }
    }
    th = Thread::start do
        mutex.synchronize do
            cv.wait(mutex)
            # fがcallされるまで待つ
        end
    end
    b.call(f)
    th.join
end
def main times=nil
    target = {
        :host => 'hornet.klab.org',
        :port => 8000,
        :path => '/'
    }

    url = "http://#{target[:host]}:#{target[:port]}#{target[:path]}"
    times = 10 if times.zero?
    puts "target: #{url}"
    puts "concurrency: #{times}"
    #以下スクリプト実行時の第2引数を見て、実行するコードを変更
    wait{|f|
        start_nethttp(times, target[:host], target[:port], target[:path], f)
    } if ARGV[1].to_i == 0
    e = lambda{}
    start_em2(times, target[:host], target[:port], target[:path], e) if ARGV[1].to_i == 1
    start_rev(times, target[:host], target[:port], target[:path], e) if ARGV[1].to_i == 2
end

main ARGV[0].to_i