#!/usr/bin/env ruby
|
|
# Funning xeno-test once with each option takes a long time (around 15 minutes)
|
# For each test a full log is stored in the logs subdirectory.
|
# Therefore the results of the tests (the ruby variable) is stored using Pstore in
|
# the file logs/xeno-test.store.
|
# If this file exists and is newer than xeno-test and the first parameter is != clean
|
# The tst variable is fetched from the file.
|
# This is convenient if you want to add new checks.
|
#
|
# Todo: - Why do the mailing tests not work ?
|
# - How does xeno-test react to Ctrl-C ?
|
# - Thorougher analyses of the log files
|
#
|
require 'timeout'
|
require 'ostruct'
|
require 'ftools'
|
require 'pstore'
|
require 'tempfile'
|
|
XenoInstall = "/usr/xenomai/bin"
|
XenoHead = File.expand_path(File.dirname(File.dirname(__FILE__)))
|
XenoTestOrg = XenoHead+'/xeno-test.in'
|
XenoTestRun = XenoInstall+'/xeno-test'
|
LogDir = XenoHead+'/logs'
|
MainLog = LogDir+'/runtest.log'
|
StorageName = LogDir+'/xeno-test.store'
|
withFinished = `grep finished /usr/xenomai/bin/xeno*`
|
withFinished.size > 0 ? FinishedMsg = "xeno-test: finished" : FinishedMsg = nil
|
|
$clean = ARGV[0] == 'clean' && ! (
|
File.exists?(XenoTestRun) &&
|
File.exists?(StorageName) &&
|
File.stat(XenoTestRun).mtime > File.stat(StorageName).mtime
|
)
|
if $clean && File.exists?(StorageName) then
|
puts "Do you really want to run all tesst? <Ctrl-C> to abort"
|
STDIN.getc
|
end
|
|
class XenoTest
|
attr_reader :mainLog
|
attr_reader :blockDevice
|
attr_writer :maxTimeout
|
attr_writer :chkProc
|
|
def initialize(options)
|
@from = XenoHead
|
@inst = XenoInstall
|
@busybox = false
|
File.makedirs(LogDir) if defined?(LogDir) && ! File.directory?(LogDir)
|
@@mainLog = open(MainLog,"w");
|
@@mainLog.puts("#{Time.now}: started run")
|
@@mainLog.sync = true
|
options.each { |name,val|
|
if val.class == String then
|
cmd = "@#{name}='#{val}'"
|
else
|
cmd = "@#{name}=#{val}"
|
end
|
eval cmd
|
}
|
end
|
|
def add(opts, chkProc=nil)
|
@nr = -1 if !defined?(@nr)
|
@tsts = Array.new if !defined?(@tsts)
|
@nr += 1
|
elem = OpenStruct.new({'nr' => @nr, 'opts'=>opts})
|
elem.chkProc = chkProc if chkProc
|
@tsts << elem
|
return elem
|
end
|
|
def runTests
|
@tsts.each { |x| runOneTest(x) ; }
|
end
|
|
def XenoTest::writeLogEntry(tst, logMsg)
|
msg = "#{Time.now}: #{sprintf("%2d", tst.nr)} "+ logMsg
|
if ! File.exists?(MainLog) then
|
puts msg
|
end
|
outs = [ STDOUT]
|
outs << @@mainLog if defined?(@@mainLog) && @@mainLog
|
outs.each {|dev| dev.puts msg }
|
end
|
|
def runOneTest(x)
|
puts "runOneTest #{x.inspect}" if $VERBOSE
|
opts = x.opts
|
startTime = Time.now
|
tstRes = nil
|
x.tst = `which xeno-test`.chomp
|
x.log = "#{LogDir}/test_xeno_test.log.#{x.nr}"
|
x.cmd = "#{x.tst} -T 1 #{x.opts} | tee #{x.log}" # -T 1 to make the test time shorter
|
|
# Start thread to enfore maxTimeout
|
if @maxTimeout then
|
@rThread = Thread.new{
|
puts "@rThread: "+Process.pid.to_s if $VERBOSE
|
writeLogEntry(x, "started: #{opts} Timeout #{@maxTimeout}")
|
sleep(@maxTimeout);
|
writeLogEntry(x, "rThread will kill #{$childPid.inspect}")
|
system("kill -9 #{$childPid}") if $childPid
|
raise Timeout::Error
|
}
|
end
|
# Now we are doing calling our script
|
$childPid = nil
|
Dir.chdir(@inst)
|
res = IO.popen(x.cmd) { |f|
|
puts "cmd: "+Process.pid.to_s if $VERBOSE
|
$childPid = Process.pid
|
f.each{|a| puts a}
|
}
|
tstRes = $?
|
rescue Timeout::Error => details
|
puts detail.backtrace.join("\n")
|
writeLogEntry(x, "FAILED: #{opts} Timeout error #{$childPid}")
|
system("kill -9 #{$childPid}")
|
rescue => details
|
writeLogEntry(x, "FAILED: #{opts} runtime error #{@rThread.inspect} pid #{$childPid.inspect}")
|
puts details.backtrace.join("\n")
|
system("kill -9 #{$childPid}")
|
@rThread.kill if defined?(@rThread)
|
ensure
|
# save results,
|
# clean up dd process if there are any, if xeno-test did not clean it up as it should have
|
endTime = Time.now
|
duration = (endTime-startTime).round
|
if duration <= 5 then
|
str = "FAILED"
|
tstRes = 'too fast'
|
else
|
str = tstRes ? 'PASSED' : 'FAILED'
|
end
|
x.tstRes = tstRes
|
x.duration = duration
|
XenoTest::writeLogEntry(x, "#{str}: #{sprintf("%3d", duration)} seconds. opts <#{x.opts}> returned #{tstRes}")
|
|
IO.popen("ps -ef | grep -w dd") { |f|
|
line= f.gets
|
if ! line.index('grep') then
|
msg = "#{Time.now}: #{sprintf("%2d", x.nr)} FAILED: dd not killed \n >>> #{line}"
|
[ STDOUT, @@mainLog].each {|dev| dev.puts msg if dev}
|
system "killall dd"
|
end
|
}
|
@rThread.kill if @rThread
|
@rThread = nil
|
end
|
|
def runChecks
|
puts "running all Checks"
|
@tsts.each { |aTst|
|
checkFinished(aTst)
|
chks = aTst.chkProc
|
next if ! chks
|
z = eval "#{chks[0]}"+"(aTst, chks[1])" if chks[1]
|
}
|
puts "completed all Checks"
|
end
|
|
def checkFinished(tst)
|
return if ! FinishedMsg
|
logInhalt = IO.readlines(tst.log)
|
finished = false
|
logInhalt.each{|line|
|
finished = true if line.index(FinishedMsg)
|
}
|
if !finished then
|
puts "CHK #{tst.nr} FAILED opts #{tst.opts} could not find #{FinishedMsg}"
|
puts " searched in #{tst.log}"
|
end
|
end
|
|
def getTstByOpt(opts)
|
@tsts.each{ |aTst|
|
return aTst if aTst.opts == opts
|
}
|
return nil
|
end
|
end
|
|
# Here follow the various routines, that check the effect of each options
|
def expectInLogFile(x, string)
|
puts "x #{x.inspect}\nlooking for #{string}" if $VERBOSE
|
logInhalt = IO.readlines(x.log)
|
found = false
|
logInhalt.each{|line|
|
found = true if line.index(string)
|
}
|
puts "CHK #{x.nr} FAILED, could not find #{string} in #{x.log}" if !found
|
end
|
|
# Get a name for a temporary file as a target to upload via curl (option -U)
|
tf = Tempfile.new("xeno-test")
|
TstUrlTarget = tf.path
|
tf.close
|
File.delete if File.exists?(TstUrlTarget)
|
|
tst = nil
|
store = nil
|
File.delete(StorageName) if $clean && File.exists?(StorageName)
|
if File.exists?(StorageName) then
|
# Read in our saved test state (if we have a valid combination)
|
store = PStore.new(StorageName)
|
puts "reading tst from #{StorageName}"
|
store.transaction do
|
tst = store['tst']
|
end
|
else
|
# we prepare to run our tests
|
|
# Get the first block-Device
|
blockDevices = `mount | cut -d\\ -f1 | egrep -ve 'sysfs|proc|depts'`
|
blockDevices = blockDevices[0..blockDevices.index("\n")].chomp
|
bDev = blockDevices
|
|
tst = XenoTest.new({'blockDevice' => bDev})
|
tst.maxTimeout = 120
|
|
# Define test run for each option and/or combination thereof
|
|
# Test for a bad option. This happens to be fast, too
|
tst_0 = tst.add("-O", [ 'expectInLogFile', "xeno-test [options]"])
|
tst_1 = tst.add("", [ 'expectInLogFile', FinishedMsg])
|
tst_2 = tst.add("-T 5")
|
if true then # To speed up our test,s we may turn off defining more testruns
|
tst_3 = tst.add("-p 200", ['expectInLogFile',"Sampling period: 200 us"])
|
tst_4 = tst.add("-w 2", ['expectInLogFile',FinishedMsg])
|
tst_5 = tst.add("-d #{bDev}",
|
['expectInLogFile',"creating workload using dd if=#{bDev}"])
|
|
tst_6 = tst.add("-w /bin/dd #{bDev}",
|
['expectInLogFile',FinishedMsg])
|
tst_7 = tst.add("-P 'echo marker'",
|
['expectInLogFile',FinishedMsg])
|
tst_8 = tst.add("-L", ['expectInLogFile',FinishedMsg])
|
tst_9 = tst.add("-N marker", ['expectInLogFile',FinishedMsg])
|
tst_10 = tst.add("-v", ['expectInLogFile',FinishedMsg])
|
tst_11 = tst.add("-U #{TstUrlTarget}",
|
['expectInLogFile',FinishedMsg])
|
tst_12 = tst.add("-D '%Ymarker%Mmarker%D'",
|
['expectInLogFile',FinishedMsg])
|
# tst_13 = tst.add("-M #{ENV['USER']}@localhost",
|
# ['expectInLogFile',FinishedMsg])
|
# tst_14 = tst.add("-m", ['expectInLogFile',FinishedMsg])
|
end
|
|
# Remove files, we might have left behind in a previous test
|
( Dir.glob("/tmp/test-#{`uname -r`.chomp}*") +
|
Dir.glob("#{XenoInstall}/marker*")).each { |file|
|
puts "Removing #{file}"
|
File.delete file
|
}
|
tst.runTests
|
|
# Now we are ready to store our testresult (our ruby variable) to file
|
puts "Writing tst to #{StorageName}"
|
store = PStore.new(StorageName)
|
store.transaction do
|
store['tst'] = tst
|
end
|
end
|
|
# If we did run the curl/-N, -L test, did it generate the expected file?
|
{
|
"-U #{TstUrlTarget}" => TstUrlTarget,
|
"-L" => "/tmp/test-#{`uname -r`.chomp}*",
|
"-N marker" => "#{XenoInstall}/marker*",
|
}.each { |opt, path|
|
myTst = tst.getTstByOpt(opt)
|
if myTst && Dir.glob(path).size == 0 then
|
XenoTest::writeLogEntry(myTst, "FAILED: #{opt}: no file #{path} found")
|
else
|
XenoTest::writeLogEntry(myTst, "PASSED: #{opt}: #{Dir.glob(path).inspect}")
|
end if myTst
|
}
|
|
# This string is probably wrong, but I think xeno-test doesn't accept this
|
# string as it should neither
|
myTst = tst.getTstByOpt("-D '%Ymarker%Mmarker%D'")
|
tstString = "-D #{Time.now.strftime('%Ymarker%Mmarker%D')}"
|
tstString = "marker"
|
expectInLogFile(myTst, tstString) if myTst
|
|
# Test whether we really take more time with -T 5 than with the default -T 1
|
long = tst.getTstByOpt("-T 5")
|
short = tst.getTstByOpt("")
|
if long and short then
|
if long.duration < short.duration + 5
|
then
|
XenoTest::writeLogEntry(long,
|
"FAILED: with '#{short.opts}' #{sprintf("%3d", short.duration)} "+
|
"+ 5 not smaller < #{sprintf("%3d", long.duration)} seconds with '#{long.opts}'.")
|
end
|
end
|
|
tst.runChecks
|
