roadrunner 4.0.3

data/lib/db.rb

@@ -0,0 +1,51 @@
+#
+
+module RoadRunnerModule
+
+  module Dbhelper
+
+    def migrate(tables)
+      tables.each do |table|
+        case table
+        when "scenarios"  then
+          unless ActiveRecord::Base.connection.tables.include?(table.to_s) then
+            ActiveRecord::Base.connection.create_table(table.to_sym) do |t|
+               t.column :name, :string, :limit => 256
+               t.column :create_at,:string, :limit => 32
+               t.column :script, :string,:limit => 10240
+               t.column :author, :string, :default => 'Anonymous'
+               t.column :author, :tps, :int
+               t.column :desc, :string
+             end
+          end
+
+        when "transactions"  then
+          unless ActiveRecord::Base.connection.tables.include?(table.to_s) then
+            ActiveRecord::Base.connection.create_table(table.to_sym) do |t|
+               t.column :name,:string,:limit => 256
+               t.column :scenario_id,:string,:limit => 256
+               t.column :success_rate,:string, :limit => 8
+               t.column :create_at,:string, :limit => 32
+
+             end
+          end
+          
+        when "records"  then
+          unless ActiveRecord::Base.connection.tables.include?(table.to_s) then
+            ActiveRecord::Base.connection.create_table(table.to_sym) do |t|
+               t.column :cost, :string, :limit => 32
+               t.column :ts, :string, :limit => 32
+               t.column :seq, :int
+               t.column :stats,:int
+               t.column :transaction_id,:string,:limit => 256
+               t.column :create_at,:string, :limit => 32
+             end
+          end
+        end
+      end
+    end
+
+    module_function :migrate
+  end
+
+end

data/lib/ended.rb

@@ -0,0 +1,14 @@
+#Here is LR End function
+
+module RoadRunnerModule
+  def ended(&blk)
+
+    if block_given?
+      @endBlk=blk
+      register_transactions('end',&blk)
+    else
+      raise ArgumentError, "no block"
+    end
+
+  end
+end

data/lib/init.rb

@@ -0,0 +1,14 @@
+#Here is LR init function
+
+module RoadRunnerModule
+  def init(&blk)
+
+    if block_given?
+      @initBlk=blk
+      register_transactions('init',&blk)
+    else
+      raise ArgumentError, "no block"
+    end
+
+  end
+end

data/lib/model.rb

@@ -0,0 +1,10 @@
+class Scenario < ActiveRecord::Base
+  has_many :transactions
+end
+class Transaction < ActiveRecord::Base
+  belongs_to :scenario
+  has_many :records
+end
+class Record < ActiveRecord::Base
+  belongs_to :transaction
+end

data/lib/report.rb

@@ -0,0 +1,100 @@
+#After roadRunner.run() executed,
+#execute roadRunner.report() show the Performance report
+
+module RoadRunnerModule
+
+  def report(label='',width=0)
+    p "      Wait for moment,the report is collecting......"
+    content = if @rep
+      @succRates = getSuccessRate @transactions
+      <<-DOC
+      #{"Performance Reports".center(50, '*')}
+      #{label.ljust(width)}
+      #{Benchmark::Tms::CAPTION}
+      #{@rep.format}
+      #{'--'*32}
+      The Virtual User is #{@users}.
+      Total Execute #{@iterations*@users} Action(s).
+      Total Cost #{@rep.real} Second(s).
+      This Scenario's TPS : #{@tps}.
+      The longest action cost #{@longest || 0} seconds.
+      #{'Transaction Report'.center(50, '-')}
+      #{@transactions.inject("") { |str,k|
+      str += "#{k[0].to_s} : count => #{k[1].size} time(s) , cost => #{k[1].inject(0){|c,v|c+=v[:cost].to_f}.to_s[0..3]} sec(s) , success rate => #{@succRates[k[0]]}\n      "
+      }.gsub(/\n$/,'')}
+      #{'--'*32}
+      User defined params as below: 
+      #{@global}
+      #{"End of Reports".center(50, '*')}
+      DOC
+    else
+      "None Report before RoadRunner run."
+    end
+    puts content
+    self.log.info content
+  end
+
+  def save_report(opts={:author=>'Anonymous',:script=>""})
+
+    p "      Saving report to database......"
+    opts={:author=>'Anonymous',:script=>""}.merge opts
+    if @data_write then
+      unless opts[:name] then
+        self.log.warn "scenario name may be needed."
+        require 'uuidtools' unless defined?UUID
+        # scenario || UUID.random_create.to_s is for debug
+        opts[:name] = opts[:name] || UUID.random_create.to_s
+        self.log.info "scenario is created as #{opts[:name]}"
+      end
+      # => scenario = Scenario.find_or_create_by_name(opts.merge({:create_at=>Time.now})).shift
+      scenario = Scenario.find_or_create_by_name(opts.merge({:create_at=>Time.now}))
+      scenario.tps+=@iterations*@users/@rep.real
+
+      # => if opts[:script] is set as <your script>.rb 's path
+      # => opts[:script] = __FILE__
+      # => then scenario.script will be set.
+      if FileTest.exist?(opts[:script]) then
+        scenario.script = ""
+        IO.foreach(opts[:script]){|x|scenario.script << x}
+      end
+
+      @succRates = @succRates || (getSuccessRate @transactions)
+      # k is transaction name ,
+      # v is reports in every transaction.
+      @transactions.each do |k,v|
+        transaction  = Transaction.new({:name=>k,:create_at=>Time.now,:success_rate=>@succRates[k]})
+        v.each_index do |id|
+          transaction.records << Record.new(v[id].merge({:seq=>id,:ts=>v[id][:create_at].to_f-@strat_time.to_f}))
+          self.log.debug "v[#{id}] = #{v[id].inspect}"
+        end
+        scenario.transactions << transaction
+      end
+      begin
+        scenario.save!
+        p "      Saved OK!"
+      rescue =>e
+        self.log.error e
+        p e
+      end
+      self.log.info "records has saved in DB."
+    else
+      p '      Error:You didn\'t connect any database.'
+      self.log.error 'You didn\'t connect any database.'
+    end
+  end
+
+  def getSuccessRate(transactions)
+    result = {}
+    transactions.each do |h|
+      success,faile = 0,0
+      h[1].each do |r|
+        r[:stats]==0?success+=1:faile+=1
+      end
+      result[h[0]]=success.to_f/(success+faile)
+    end
+    result
+  end
+
+  private :getSuccessRate
+
+end

data/lib/roadrunner.rb

@@ -0,0 +1,122 @@
+# Author : zheng.cuizh@gmail.com
+# RoadRunner named lik LoadRunner which is a industry performance test tool of HP.
+# I'm happy to user LR and Ruby,
+# so i coded the RoadRunner.
+# Using RR,you'll find somethings similar to LR.
+
+$:.unshift File.dirname(__FILE__)
+require 'rubygems'
+require 'benchmark'
+require 'logger'
+require 'pp'
+
+Dir[File.join(File.dirname(__FILE__),"*.rb")].select{|x|not (x =~ /.*model\.rb/ || x =~ /.*db\.rb/ || x =~ /.*roadrunner\.rb/)}.each { |x| require x  }
+
+class RoadRunner
+
+  include RoadRunnerModule
+  attr :iterations, true
+  attr :users,true
+  attr :global,true
+  attr :iterationId
+  attr :record
+  attr :userId
+  attr :mode,true
+  attr :log
+  attr :tps
+  alias_method :g,:global
+  alias_method :g=,:global=
+
+  def initialize(opts={})
+    # => DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+    opts = {:out=>File.join(File.dirname(__FILE__),'..','log',"stdout.log"),:frequency=>'daily',:size=>1048576,:level=>Logger::DEBUG}.merge opts
+    @users,@iterations,@longest,@userId,@iterationId=1,1,0,0,0
+    @initBlk,@actBlk,@endBlk=proc{},proc{},proc{}
+    @global,@transactions={},{}
+    @log=Logger.new(opts[:out],opts[:frequency],opts[:size])
+    @log.level=opts[:level]
+    # => mode : sequence<default>,thread|t,process|p
+    @mode='sequence'
+    
+    @transaction_blk={}
+
+    if block_given? then
+      begin
+        gem 'active_record'
+        require 'active_record'
+      rescue Exception => e
+        require 'activerecord'
+      end
+      
+      require 'db'
+      require "model"
+
+      session = {}      
+      _session = yield session
+      session = _session if session == {}
+
+      begin
+        ActiveRecord::Base.establish_connection(
+#
+#          === session defined in block :
+#          
+#          :adapter=>session[:adapter],
+#          :encoding=>session[:encoding],
+#          :database=>session[:database],
+#          :username=>session[:username],
+#          :password=>session[:password],
+#          :host=>session[:host]
+#
+          session
+        )
+        self.log.info "connect db ok."
+      rescue =>ex
+        self.log.error "adapter:#{session[:adapter]}.connect db faile."
+      end
+
+      default_report_table = %w"scenarios transactions records"
+
+      unless @data_write = default_report_table.inject(true){|r,t| r = r && ActiveRecord::Base.connection.tables.include?(t)} then
+        self.log.warn "table rreports doesn't defined and will be created."
+        Dbhelper::migrate default_report_table
+        if @data_write = default_report_table.inject(true){|r,t| r = r && ActiveRecord::Base.connection.tables.include?(t)} then
+          self.log.info "create table #{default_report_table.inspect} successful."
+        else
+          self.log.error "create table #{default_report_table.inspect} fail."
+        end
+      end
+      require 'model' unless defined? Scenario
+      self.log.debug 'model Rreport is reqruired.'
+    end
+  end
+
+  def transaction(name,&blk)
+    @transactions[name] || @transactions[name] = []
+    status = "AUTO"
+    # => Status is the last expression in the action block
+    rcost = Benchmark::realtime{status = yield} if block_given?
+    # => status's value is:
+    # => 0=>success
+    # => -1=>faile
+    case status
+    when false,'false','-1',-1 then status = -1
+    else status = 0
+    end
+    # {:stats=>status,:cost=>rcost,:create_at=>Time.now} is one record
+    @transactions[name] << {:stats=>status,:cost=>rcost,:create_at=>Time.now}
+    # => the below sentence cost a lot of system resource
+    # => if you run for production result,keep it annotated!!!
+#    self.log.debug @transactions[name].inspect
+    rcost
+  end
+  
+  def register_transactions(name,&blk)
+    @transaction_blk[name]=blk
+  end
+
+  def method_missing(name,*args,&blk)
+    # self.transaction(name.to_s,&blk)
+    register_transactions(name,&blk)
+  end
+    
+end

data/lib/rrhelper.rb

@@ -0,0 +1,25 @@
+# Rrhelper will include many helpful methods for RoadRunner
+
+module RoadRunnerModule
+
+  def iterationId
+    if(@mode=='thread')then
+      @thread_pool[Thread.current][:iterationId]
+    else
+      @iterationId
+    end
+  end
+
+  def userId
+    if(@mode=='thread')then
+      @thread_pool[Thread.current][:userId]
+    else
+      @userId
+    end
+  end
+
+  module Rrhelper
+
+  end
+  
+end

data/lib/rrmonitor.rb

@@ -0,0 +1,174 @@
+require "rubygems"
+require "net/ssh"
+require 'fileutils'
+
+module RoadRunnerModule
+  
+=begin
+  RRMonitor is used for Xnix system.
+=end
+
+class RRMonitor
+  def initialize(opt={:server=>"0.0.0.0", :username=>"admin", :password=>"123456"})
+    raise(ArgumentError,"Logger is needed!") unless opt[:log]
+    @log=opt[:log]
+    
+    @server=opt[:server]
+    
+    begin
+      @sess=Net::SSH.start(opt[:server], opt[:username], :password => opt[:password],:timeout => 120)
+      @log.info "#{opt[:server]} ssh connection OK."
+    rescue Exception => e
+      @log.error e
+      @log.error opt.inspect
+      raise e
+    end
+    
+    
+    @log.info("monitor initialize.".center(60,"*"))
+    @log.debug("monitor => #{self.inspect}")
+    
+    @ts=( opt[:ts] || Time.now.to_i )
+    
+    @path="#{File.join File.dirname(__FILE__),'..','log'}/monitor/#{@ts}"
+    @log.info "monitor local log path :#{@path}"
+    
+    @rpath="~/.monit/#{@ts}"
+    @log.info "monitor remote log path(rpath) :#{@rpath}"
+    
+    @sess.exec!("rm -rf #{@rpath}")
+    @sess.exec!("mkdir -p #{@rpath}")
+    
+    @pids={}
+  end
+  
+=begin
+  run!(cmd) =>
+  the cmd will be execed at remote server(0),
+  and the stdout will write in log file.
+  
+  cmd =>[
+    'ifstat',# network io
+    'iostat 3',# disk io
+    'vmstat 3',# memory info
+    'while((1>0));do sar -u -d 3 10; done',# disk and cpu info
+    'while((1>0));do sar -u -n DEV 3 10; done'# network and cpu info
+    ]
+  
+  "while((1>0));do #{cmd}; done" is needed for non-consist output cmd.
+  
+  cmd sample =>
+  
+    run!(["while((1>0));do /home/admin/apsara/build/debug64/bin/ku --command=getallpart --appname=blog1 --interactive=false|tail -n1; done"])
+    
+    when exec!(cmd)
+    =>
+    exec!("while((1>0));do /home/admin/apsara/build/debug64/bin/ku --command=getallpart --appname=blog1 --interactive=false|tail -n1; done  >> #{kupath} 2>/dev/null &")
+=end
+  
+  def run!(cmd=['ifstat','iostat 3','while((1>0));do sar -u -d 3 10; done','vmstat 3','while((1>0));do sar -u -n DEV 3 10; done'])
+    (@log.error "run!(cmd) cmd type require array.";exit) unless cmd.is_a?(Array)
+    (@log.error "run!(cmd) require commands.";exit) if cmd.none?
+    
+    @cmd=cmd
+    
+    begin
+      @log.info("RUN!".center(60,"*"))
+      @log.debug @server
+      cmd.each { |e|  self.exec!(e)}
+    rescue Exception => e
+      @log.error("#{self.inspect} run error!")
+      @log.error(e.to_s)
+      # raise e
+    end
+    
+  end
+
+  def exec!(cmd)
+    # >> cmd='while((1>0));do sar -u -d 3 10; # done';cmdpath="#{cmd.gsub(/([^a-zA-Z0-9\-])/,'_')}.log"
+    # => "while__1_0___do_sar_-u_-d_3_10__done.log"
+    
+    # cmdpath="#{@rpath}/#{cmd.gsub(/[\s|\t|\$|\`|\(|\)|\&|\>|\<|\;|\||\'|\"]/,'_')}.log"
+    cmdpath="#{@rpath}/#{cmd.gsub(/[^a-zA-Z0-9\-]/,'_')}.log"
+    @cmdpath=cmdpath
+    
+    @log.debug "#{cmd} path => #{cmdpath}"
+    @log.info "Start #{cmd}.".center(60,"*")
+    
+    @log.debug("#{cmd} >> #{cmdpath} 2>/dev/null &")
+    @sess.exec!("#{cmd} >> #{cmdpath} 2>/dev/null &")
+    
+    @pids[cmd]=@sess.exec!("echo $!")
+    @log.debug("#{cmd} pid => #{@pids[:ku]}")
+  end
+  
+  def stop!
+    @pids.each  do |key,value|
+      @sess.exec!("kill -9 #{value}")
+      @log.info("#{key} => #{value} stop!")
+    end
+    
+    # if other user exec the same cmd,
+    # below cmd will kill all of the cmd.
+    
+    # @sess.exec!(%q@ps axf|grep while|grep -v grep|awk '{printf "%s\n",$1}'|xargs kill -9@)
+    # 
+    # @cmd.each { |e| 
+    #   @sess.exec!(%q@ps axf|grep "#{e}"|grep -v grep|awk '{printf "%s\n",$1}'|xargs kill -9@)
+    # }
+    
+    @log.debug @server
+    @log.info("Monitor STOP!".center(60,"*"))
+  end
+  
+  def collect
+    @log.debug "mkdir -p #{@path}/#{@server}"
+    %x{mkdir -p #{@path}/#{@server}}
+    
+    path = @path.gsub('~',`echo ~`.gsub(/[\r\n]/,''))
+    @log.info "Collecting...".center(60,"*")
+    @log.debug "collect path => #{path}/#{@server}"
+    `scp -r admin@#{@server}:#{@rpath} #{path}/#{@server}`
+    @log.info "collected files => #{Dir[path+'/'+@server+'/**/*'].join($/)}"
+  end
+  
+  #-----------------------------monit method--------------------------------#
+
+  def self.monit(servers,log,cmd=['ifstat','iostat 3','while((1>0));do sar -u -d 3 10; done','vmstat 3','while((1>0));do sar -u -n DEV 3 10; done'],ts="PerformanceTest")
+
+    case servers
+    when Hash
+      # do nothing
+    when String
+      File.open( servers ) { |yf| 
+        begin
+          servers=YAML::load( yf ) 
+        rescue Exception => e
+          log.error("Servers' config YAML Load Error!Plz check your yaml file => #{servers}.#{$/}#{e.to_s}")
+          exit 1
+        end
+      }
+    end
+    
+    _servers = {}
+
+    servers.each do |ip,obj|
+      _servers[ip] = RoadRunnerModule::RRMonitor.new({:server=>ip, :log=>log, :username=>obj[:username], :password=>obj[:password], :ts=>obj[:obj]||ts})
+
+      _servers[ip].run! cmd
+    end
+
+    yield
+
+    _servers.each do |k,v|
+      v.stop!
+      v.collect
+    end
+
+  end
+  
+end
+
+end
+
+

data/lib/run.rb

@@ -0,0 +1,113 @@
+#After roadRunner.run() executed,
+#execute roadRunner.report() show the Performance report
+
+module RoadRunnerModule
+  def run
+    @strat_time = Time.now
+    @initBlk.call
+    @thread_pool = {}
+    @counter = 0
+
+    @log.debug "Mode => #{@mode}"
+    iterationBlk = case @mode
+    when /thread/,/t/ then
+      proc {      
+        @users.times do |userId|
+          @thread_pool[Thread.start(){
+            @iterations.times do |iterationId|
+              
+              rcost = 0
+              @transaction_blk.each_pair{|k,v|
+                rcost = self.transaction(k,v)
+              }
+              
+              # rcost = self.transaction('Action',&@actBlk)
+              self.log.debug "IterationID is #{self.iterationId};UserID is #{self.userId};This Action Cost #{rcost} seconds"
+              @longest = (@longest<rcost)?rcost:@longest
+              @thread_pool[Thread.current][:iterationId] = iterationId
+            end
+            @counter += 1
+          }]={:userId=>userId}
+        end
+  #      @thread_pool.keys.each{|t|t.join}
+        while @counter != @users do
+          Thread.pass
+        end
+      }
+    when /process/,/p/ then
+      proc {
+        ppid=Process.pid
+        @log.info("Main Process pid => #{ppid}")
+        
+        pids=[]
+        @users.times { |userId|
+          pids << Process.fork { 
+            @userId=userId
+            @iterations.times do |iterationId|
+              @iterationId=iterationId
+              
+              rcost = 0
+              @transaction_blk.each_pair{|k,v|
+                rcost = self.transaction(k,v)
+              }
+              
+              # rcost = self.transaction('Action',&@actBlk)
+              @longest = (@longest<rcost)?rcost:@longest
+            end
+            @log.info("<PID:#{Process.pid}> going down.Longest job cost #{@longest}")
+            
+            Process.kill("HUP", ppid)
+          }
+        }
+        
+        switch=true
+        c=0
+        Signal.trap("HUP", proc { @log.info("One User(Process) done."); (switch = false;p "Main process<#{Process.pid}> going down.") if ((c+=1) == @users) })
+        
+        @log.info "Waiting Processes => #{pids.inspect}"
+        
+        p "Processes<#{pids.inspect}> working."
+        while switch
+          STDOUT.puts '.'
+          sleep 5
+        end
+        p $/
+        
+        Process.waitall
+        @log.info "Processes down."
+      }
+    else
+      proc {
+        @iterations.times do |iterationId|
+          @iterationId=iterationId
+          @users.times do |userId|
+            @userId=userId
+            
+            rcost = 0
+            @transaction_blk.each_pair{|k,v|
+              rcost = self.transaction(k,v)
+            }
+            
+            # rcost = self.transaction('Action',&@actBlk)
+            
+            # => the below sentence cost a lot of system resource
+            # => if you run for production result,keep it annotated!!!
+  #          self.log.debug "IterationID is #{self.iterationId};UserID is #{self.userId};This Action Cost #{rcost} seconds"
+            @longest = (@longest<rcost)?rcost:@longest
+          end
+        end
+      }
+    end
+
+    p '      '+"RoadRunner".center(50, '*')
+    p '      *'+"---Run , on your way.".rjust(48, ' ')+'*'
+    p '      '+'*'*50
+    p
+    p "      Running......"
+    @rep = Benchmark::measure(&iterationBlk)
+    p "      Ending......"
+    @endBlk.call
+
+    @tps = @iterations*@users/@rep.real
+  end
+end