Convert all python code to use four-space indents instead of eight-space tabs.
Signed-off-by: John Admanski <[email protected]>
git-svn-id: http://test.kernel.org/svn/autotest/trunk@1658 592f7852-d20e-0410-864c-8624ca9c26a4
diff --git a/client/bin/autotest b/client/bin/autotest
index 9d3a968..34c1e26 100755
--- a/client/bin/autotest
+++ b/client/bin/autotest
@@ -28,27 +28,27 @@
parser = OptionParser()
parser.add_option("-c", "--continue", dest="cont", action="store_true",
- default=False, help="continue previously started job")
+ default=False, help="continue previously started job")
parser.add_option("-t", "--tag", dest="tag", type="string", default="default",
- help="set the job tag")
+ help="set the job tag")
parser.add_option("-H", "--harness", dest="harness", type="string", default='',
- help="set the harness type")
+ help="set the harness type")
parser.add_option("-l", "--external_logging", dest="log", action="store_true",
- default=False, help="enable external logging")
+ default=False, help="enable external logging")
def usage():
- parser.print_help()
- sys.exit(1)
+ parser.print_help()
+ sys.exit(1)
options, args = parser.parse_args()
# Check for a control file.
if len(args) != 1:
- usage()
+ usage()
# JOB: run the specified job control file.
job.runjob(os.path.abspath(args[0]), options.cont, options.tag, options.harness,
- options.log)
+ options.log)
diff --git a/client/bin/autotest.py b/client/bin/autotest.py
index 9d4faa7..7695892 100755
--- a/client/bin/autotest.py
+++ b/client/bin/autotest.py
@@ -1,17 +1,17 @@
import os, sys
class system:
- def __init__(self):
- self.autodir = os.environ['AUTODIR']
- self.resultdir = self.autodir + '/results'
- self.tmpdir = self.autodir + '/tmp'
+ def __init__(self):
+ self.autodir = os.environ['AUTODIR']
+ self.resultdir = self.autodir + '/results'
+ self.tmpdir = self.autodir + '/tmp'
- if not os.path.isdir(self.resultdir):
- os.mkdir(self.resultdir)
- if not os.path.isdir(self.tmpdir):
- os.mkdir(self.tmpdir)
- return None
+ if not os.path.isdir(self.resultdir):
+ os.mkdir(self.resultdir)
+ if not os.path.isdir(self.tmpdir):
+ os.mkdir(self.tmpdir)
+ return None
- def boot(self, tag=None):
- print "I OUGHT TO REBOOT NOW!"
+ def boot(self, tag=None):
+ print "I OUGHT TO REBOOT NOW!"
diff --git a/client/bin/autotest_client b/client/bin/autotest_client
index 762d0cb..1e275a4 100755
--- a/client/bin/autotest_client
+++ b/client/bin/autotest_client
@@ -17,11 +17,11 @@
# If we're using cpusets, run inside the root one by default
if os.path.exists("/dev/cpuset/tasks") and getpass.getuser() == "root":
- utils.write_one_line("/dev/cpuset/tasks", str(os.getpid()))
+ utils.write_one_line("/dev/cpuset/tasks", str(os.getpid()))
autodir = os.path.dirname(sys.argv[0])
autotest = os.path.join(autodir, 'autotest')
cmd = ' '.join([autotest, '-H simple'] + sys.argv[1:])
exit_code = subprocess.call(cmd, shell=True, stderr=subprocess.STDOUT,
- close_fds=False)
+ close_fds=False)
sys.exit(exit_code) # pass on the exit status from autotest
diff --git a/client/bin/autotest_utils.py b/client/bin/autotest_utils.py
index 1e6c725..f6eb86e 100755
--- a/client/bin/autotest_utils.py
+++ b/client/bin/autotest_utils.py
@@ -8,593 +8,593 @@
def grep(pattern, file):
- """
- This is mainly to fix the return code inversion from grep
- Also handles compressed files.
+ """
+ This is mainly to fix the return code inversion from grep
+ Also handles compressed files.
- returns 1 if the pattern is present in the file, 0 if not.
- """
- command = 'grep "%s" > /dev/null' % pattern
- ret = cat_file_to_cmd(file, command, ignore_status=True)
- return not ret
+ returns 1 if the pattern is present in the file, 0 if not.
+ """
+ command = 'grep "%s" > /dev/null' % pattern
+ ret = cat_file_to_cmd(file, command, ignore_status=True)
+ return not ret
def difflist(list1, list2):
- """returns items in list2 that are not in list1"""
- diff = [];
- for x in list2:
- if x not in list1:
- diff.append(x)
- return diff
+ """returns items in list2 that are not in list1"""
+ diff = [];
+ for x in list2:
+ if x not in list1:
+ diff.append(x)
+ return diff
def cat_file_to_cmd(file, command, ignore_status=0, return_output=False):
- """
- equivalent to 'cat file | command' but knows to use
- zcat or bzcat if appropriate
- """
- if return_output:
- run_cmd = utils.system_output
- else:
- run_cmd = utils.system
+ """
+ equivalent to 'cat file | command' but knows to use
+ zcat or bzcat if appropriate
+ """
+ if return_output:
+ run_cmd = utils.system_output
+ else:
+ run_cmd = utils.system
- if not os.path.isfile(file):
- raise NameError('invalid file %s to cat to command %s'
- % (file, command))
- if file.endswith('.bz2'):
- return run_cmd('bzcat ' + file + ' | ' + command, ignore_status)
- elif (file.endswith('.gz') or file.endswith('.tgz')):
- return run_cmd('zcat ' + file + ' | ' + command, ignore_status)
- else:
- return run_cmd('cat ' + file + ' | ' + command, ignore_status)
+ if not os.path.isfile(file):
+ raise NameError('invalid file %s to cat to command %s'
+ % (file, command))
+ if file.endswith('.bz2'):
+ return run_cmd('bzcat ' + file + ' | ' + command, ignore_status)
+ elif (file.endswith('.gz') or file.endswith('.tgz')):
+ return run_cmd('zcat ' + file + ' | ' + command, ignore_status)
+ else:
+ return run_cmd('cat ' + file + ' | ' + command, ignore_status)
def extract_tarball_to_dir(tarball, dir):
- """
- Extract a tarball to a specified directory name instead of whatever
- the top level of a tarball is - useful for versioned directory names, etc
- """
- if os.path.exists(dir):
- raise NameError, 'target %s already exists' % dir
- pwd = os.getcwd()
- os.chdir(os.path.dirname(os.path.abspath(dir)))
- newdir = extract_tarball(tarball)
- os.rename(newdir, dir)
- os.chdir(pwd)
+ """
+ Extract a tarball to a specified directory name instead of whatever
+ the top level of a tarball is - useful for versioned directory names, etc
+ """
+ if os.path.exists(dir):
+ raise NameError, 'target %s already exists' % dir
+ pwd = os.getcwd()
+ os.chdir(os.path.dirname(os.path.abspath(dir)))
+ newdir = extract_tarball(tarball)
+ os.rename(newdir, dir)
+ os.chdir(pwd)
def extract_tarball(tarball):
- """Returns the directory extracted by the tarball."""
- extracted = cat_file_to_cmd(tarball, 'tar xvf - 2>/dev/null',
- return_output=True).splitlines()
+ """Returns the directory extracted by the tarball."""
+ extracted = cat_file_to_cmd(tarball, 'tar xvf - 2>/dev/null',
+ return_output=True).splitlines()
- dir = None
+ dir = None
- for line in extracted:
- line = re.sub(r'^./', '', line)
- if not line or line == '.':
- continue
- topdir = line.split('/')[0]
- if os.path.isdir(topdir):
- if dir:
- assert(dir == topdir)
- else:
- dir = topdir
- if dir:
- return dir
- else:
- raise NameError('extracting tarball produced no dir')
+ for line in extracted:
+ line = re.sub(r'^./', '', line)
+ if not line or line == '.':
+ continue
+ topdir = line.split('/')[0]
+ if os.path.isdir(topdir):
+ if dir:
+ assert(dir == topdir)
+ else:
+ dir = topdir
+ if dir:
+ return dir
+ else:
+ raise NameError('extracting tarball produced no dir')
def get_md5sum(file_path):
- """Gets the md5sum of a file. You must provide a valid path to the file"""
- if not os.path.isfile(file_path):
- raise ValueError, 'invalid file %s to verify' % file_path
- return utils.system_output("md5sum " + file_path + " | awk '{print $1}'")
+ """Gets the md5sum of a file. You must provide a valid path to the file"""
+ if not os.path.isfile(file_path):
+ raise ValueError, 'invalid file %s to verify' % file_path
+ return utils.system_output("md5sum " + file_path + " | awk '{print $1}'")
def unmap_url_cache(cachedir, url, expected_md5):
- """\
- Downloads a file from a URL to a cache directory. If the file is already
- at the expected position and has the expected md5 number, let's not
- download it again.
- """
- # Let's convert cachedir to a canonical path, if it's not already
- cachedir = os.path.realpath(cachedir)
- if not os.path.isdir(cachedir):
- try:
- system('mkdir -p ' + cachedir)
- except:
- raise ValueError('Could not create cache directory %s' % cachedir)
- file_from_url = os.path.basename(url)
- file_local_path = os.path.join(cachedir, file_from_url)
- if os.path.isfile(file_local_path):
- file_md5 = get_md5sum(file_local_path)
- if file_md5 == expected_md5:
- # File is already at the expected position and ready to go
- src = file_from_url
- else:
- # Let's download the package again, it's corrupted...
- src = url
- else:
- # File is not there, let's download it
- src = url
- return utils.unmap_url(cachedir, src, cachedir)
+ """\
+ Downloads a file from a URL to a cache directory. If the file is already
+ at the expected position and has the expected md5 number, let's not
+ download it again.
+ """
+ # Let's convert cachedir to a canonical path, if it's not already
+ cachedir = os.path.realpath(cachedir)
+ if not os.path.isdir(cachedir):
+ try:
+ system('mkdir -p ' + cachedir)
+ except:
+ raise ValueError('Could not create cache directory %s' % cachedir)
+ file_from_url = os.path.basename(url)
+ file_local_path = os.path.join(cachedir, file_from_url)
+ if os.path.isfile(file_local_path):
+ file_md5 = get_md5sum(file_local_path)
+ if file_md5 == expected_md5:
+ # File is already at the expected position and ready to go
+ src = file_from_url
+ else:
+ # Let's download the package again, it's corrupted...
+ src = url
+ else:
+ # File is not there, let's download it
+ src = url
+ return utils.unmap_url(cachedir, src, cachedir)
def basename(path):
- i = path.rfind('/');
- return path[i+1:]
+ i = path.rfind('/');
+ return path[i+1:]
def force_copy(src, dest):
- """Replace dest with a new copy of src, even if it exists"""
- if os.path.isfile(dest):
- os.remove(dest)
- if os.path.isdir(dest):
- dest = os.path.join(dest, os.path.basename(src))
- shutil.copyfile(src, dest)
- return dest
+ """Replace dest with a new copy of src, even if it exists"""
+ if os.path.isfile(dest):
+ os.remove(dest)
+ if os.path.isdir(dest):
+ dest = os.path.join(dest, os.path.basename(src))
+ shutil.copyfile(src, dest)
+ return dest
def force_link(src, dest):
- """Link src to dest, overwriting it if it exists"""
- return utils.system("ln -sf %s %s" % (src, dest))
+ """Link src to dest, overwriting it if it exists"""
+ return utils.system("ln -sf %s %s" % (src, dest))
def file_contains_pattern(file, pattern):
- """Return true if file contains the specified egrep pattern"""
- if not os.path.isfile(file):
- raise NameError('file %s does not exist' % file)
- return not utils.system('egrep -q "' + pattern + '" ' + file, ignore_status=True)
+ """Return true if file contains the specified egrep pattern"""
+ if not os.path.isfile(file):
+ raise NameError('file %s does not exist' % file)
+ return not utils.system('egrep -q "' + pattern + '" ' + file, ignore_status=True)
def list_grep(list, pattern):
- """True if any item in list matches the specified pattern."""
- compiled = re.compile(pattern)
- for line in list:
- match = compiled.search(line)
- if (match):
- return 1
- return 0
+ """True if any item in list matches the specified pattern."""
+ compiled = re.compile(pattern)
+ for line in list:
+ match = compiled.search(line)
+ if (match):
+ return 1
+ return 0
def get_os_vendor():
- """Try to guess what's the os vendor
- """
- issue = '/etc/issue'
+ """Try to guess what's the os vendor
+ """
+ issue = '/etc/issue'
- if not os.path.isfile(issue):
- return 'Unknown'
+ if not os.path.isfile(issue):
+ return 'Unknown'
- if file_contains_pattern(issue, 'Red Hat'):
- return 'Red Hat'
- elif file_contains_pattern(issue, 'Fedora Core'):
- return 'Fedora Core'
- elif file_contains_pattern(issue, 'SUSE'):
- return 'SUSE'
- elif file_contains_pattern(issue, 'Ubuntu'):
- return 'Ubuntu'
- elif file_contains_pattern(issue, 'Debian'):
- return 'Debian'
- else:
- return 'Unknown'
+ if file_contains_pattern(issue, 'Red Hat'):
+ return 'Red Hat'
+ elif file_contains_pattern(issue, 'Fedora Core'):
+ return 'Fedora Core'
+ elif file_contains_pattern(issue, 'SUSE'):
+ return 'SUSE'
+ elif file_contains_pattern(issue, 'Ubuntu'):
+ return 'Ubuntu'
+ elif file_contains_pattern(issue, 'Debian'):
+ return 'Debian'
+ else:
+ return 'Unknown'
def get_vmlinux():
- """Return the full path to vmlinux
+ """Return the full path to vmlinux
- Ahem. This is crap. Pray harder. Bad Martin.
- """
- vmlinux = '/boot/vmlinux-%s' % utils.system_output('uname -r')
- if os.path.isfile(vmlinux):
- return vmlinux
- vmlinux = '/lib/modules/%s/build/vmlinux' % utils.system_output('uname -r')
- if os.path.isfile(vmlinux):
- return vmlinux
- return None
+ Ahem. This is crap. Pray harder. Bad Martin.
+ """
+ vmlinux = '/boot/vmlinux-%s' % utils.system_output('uname -r')
+ if os.path.isfile(vmlinux):
+ return vmlinux
+ vmlinux = '/lib/modules/%s/build/vmlinux' % utils.system_output('uname -r')
+ if os.path.isfile(vmlinux):
+ return vmlinux
+ return None
def get_systemmap():
- """Return the full path to System.map
+ """Return the full path to System.map
- Ahem. This is crap. Pray harder. Bad Martin.
- """
- map = '/boot/System.map-%s' % utils.system_output('uname -r')
- if os.path.isfile(map):
- return map
- map = '/lib/modules/%s/build/System.map' % utils.system_output('uname -r')
- if os.path.isfile(map):
- return map
- return None
+ Ahem. This is crap. Pray harder. Bad Martin.
+ """
+ map = '/boot/System.map-%s' % utils.system_output('uname -r')
+ if os.path.isfile(map):
+ return map
+ map = '/lib/modules/%s/build/System.map' % utils.system_output('uname -r')
+ if os.path.isfile(map):
+ return map
+ return None
def get_modules_dir():
- """Return the modules dir for the running kernel version"""
- kernel_version = utils.system_output('uname -r')
- return '/lib/modules/%s/kernel' % kernel_version
+ """Return the modules dir for the running kernel version"""
+ kernel_version = utils.system_output('uname -r')
+ return '/lib/modules/%s/kernel' % kernel_version
def get_cpu_arch():
- """Work out which CPU architecture we're running on"""
- f = open('/proc/cpuinfo', 'r')
- cpuinfo = f.readlines()
- f.close()
- if list_grep(cpuinfo, '^cpu.*(RS64|POWER3|Broadband Engine)'):
- return 'power'
- elif list_grep(cpuinfo, '^cpu.*POWER4'):
- return 'power4'
- elif list_grep(cpuinfo, '^cpu.*POWER5'):
- return 'power5'
- elif list_grep(cpuinfo, '^cpu.*POWER6'):
- return 'power6'
- elif list_grep(cpuinfo, '^cpu.*PPC970'):
- return 'power970'
- elif list_grep(cpuinfo, 'Opteron'):
- return 'x86_64'
- elif list_grep(cpuinfo, 'GenuineIntel') and list_grep(cpuinfo, '48 bits virtual'):
- return 'x86_64'
- else:
- return 'i386'
+ """Work out which CPU architecture we're running on"""
+ f = open('/proc/cpuinfo', 'r')
+ cpuinfo = f.readlines()
+ f.close()
+ if list_grep(cpuinfo, '^cpu.*(RS64|POWER3|Broadband Engine)'):
+ return 'power'
+ elif list_grep(cpuinfo, '^cpu.*POWER4'):
+ return 'power4'
+ elif list_grep(cpuinfo, '^cpu.*POWER5'):
+ return 'power5'
+ elif list_grep(cpuinfo, '^cpu.*POWER6'):
+ return 'power6'
+ elif list_grep(cpuinfo, '^cpu.*PPC970'):
+ return 'power970'
+ elif list_grep(cpuinfo, 'Opteron'):
+ return 'x86_64'
+ elif list_grep(cpuinfo, 'GenuineIntel') and list_grep(cpuinfo, '48 bits virtual'):
+ return 'x86_64'
+ else:
+ return 'i386'
def get_current_kernel_arch():
- """Get the machine architecture, now just a wrap of 'uname -m'."""
- return os.popen('uname -m').read().rstrip()
+ """Get the machine architecture, now just a wrap of 'uname -m'."""
+ return os.popen('uname -m').read().rstrip()
def get_file_arch(filename):
- # -L means follow symlinks
- file_data = utils.system_output('file -L ' + filename)
- if file_data.count('80386'):
- return 'i386'
- return None
+ # -L means follow symlinks
+ file_data = utils.system_output('file -L ' + filename)
+ if file_data.count('80386'):
+ return 'i386'
+ return None
def count_cpus():
- """number of CPUs in the local machine according to /proc/cpuinfo"""
- f = file('/proc/cpuinfo', 'r')
- cpus = 0
- for line in f.readlines():
- if line.startswith('processor'):
- cpus += 1
- return cpus
+ """number of CPUs in the local machine according to /proc/cpuinfo"""
+ f = file('/proc/cpuinfo', 'r')
+ cpus = 0
+ for line in f.readlines():
+ if line.startswith('processor'):
+ cpus += 1
+ return cpus
# Returns total memory in kb
def read_from_meminfo(key):
- meminfo = utils.system_output('grep %s /proc/meminfo' % key)
- return int(re.search(r'\d+', meminfo).group(0))
+ meminfo = utils.system_output('grep %s /proc/meminfo' % key)
+ return int(re.search(r'\d+', meminfo).group(0))
def memtotal():
- return read_from_meminfo('MemTotal')
+ return read_from_meminfo('MemTotal')
def freememtotal():
- return read_from_meminfo('MemFree')
+ return read_from_meminfo('MemFree')
def sysctl_kernel(key, value=None):
- """(Very) partial implementation of sysctl, for kernel params"""
- if value:
- # write
- utils.write_one_line('/proc/sys/kernel/%s' % key, str(value))
- else:
- # read
- out = utils.read_one_line('/proc/sys/kernel/%s' % key)
- return int(re.search(r'\d+', out).group(0))
+ """(Very) partial implementation of sysctl, for kernel params"""
+ if value:
+ # write
+ utils.write_one_line('/proc/sys/kernel/%s' % key, str(value))
+ else:
+ # read
+ out = utils.read_one_line('/proc/sys/kernel/%s' % key)
+ return int(re.search(r'\d+', out).group(0))
def _convert_exit_status(sts):
- if os.WIFSIGNALED(sts):
- return -os.WTERMSIG(sts)
- elif os.WIFEXITED(sts):
- return os.WEXITSTATUS(sts)
- else:
- # impossible?
- raise RuntimeError("Unknown exit status %d!" % sts)
+ if os.WIFSIGNALED(sts):
+ return -os.WTERMSIG(sts)
+ elif os.WIFEXITED(sts):
+ return os.WEXITSTATUS(sts)
+ else:
+ # impossible?
+ raise RuntimeError("Unknown exit status %d!" % sts)
def where_art_thy_filehandles():
- """Dump the current list of filehandles"""
- os.system("ls -l /proc/%d/fd >> /dev/tty" % os.getpid())
+ """Dump the current list of filehandles"""
+ os.system("ls -l /proc/%d/fd >> /dev/tty" % os.getpid())
def print_to_tty(string):
- """Output string straight to the tty"""
- open('/dev/tty', 'w').write(string + '\n')
+ """Output string straight to the tty"""
+ open('/dev/tty', 'w').write(string + '\n')
def dump_object(object):
- """Dump an object's attributes and methods
+ """Dump an object's attributes and methods
- kind of like dir()
- """
- for item in object.__dict__.iteritems():
- print item
- try:
- (key,value) = item
- dump_object(value)
- except:
- continue
+ kind of like dir()
+ """
+ for item in object.__dict__.iteritems():
+ print item
+ try:
+ (key,value) = item
+ dump_object(value)
+ except:
+ continue
def environ(env_key):
- """return the requested environment variable, or '' if unset"""
- if (os.environ.has_key(env_key)):
- return os.environ[env_key]
- else:
- return ''
+ """return the requested environment variable, or '' if unset"""
+ if (os.environ.has_key(env_key)):
+ return os.environ[env_key]
+ else:
+ return ''
def prepend_path(newpath, oldpath):
- """prepend newpath to oldpath"""
- if (oldpath):
- return newpath + ':' + oldpath
- else:
- return newpath
+ """prepend newpath to oldpath"""
+ if (oldpath):
+ return newpath + ':' + oldpath
+ else:
+ return newpath
def append_path(oldpath, newpath):
- """append newpath to oldpath"""
- if (oldpath):
- return oldpath + ':' + newpath
- else:
- return newpath
+ """append newpath to oldpath"""
+ if (oldpath):
+ return oldpath + ':' + newpath
+ else:
+ return newpath
def avgtime_print(dir):
- """ Calculate some benchmarking statistics.
- Input is a directory containing a file called 'time'.
- File contains one-per-line results of /usr/bin/time.
- Output is average Elapsed, User, and System time in seconds,
- and average CPU percentage.
- """
- f = open(dir + "/time")
- user = system = elapsed = cpu = count = 0
- r = re.compile('([\d\.]*)user ([\d\.]*)system (\d*):([\d\.]*)elapsed (\d*)%CPU')
- for line in f.readlines():
- try:
- s = r.match(line);
- user += float(s.group(1))
- system += float(s.group(2))
- elapsed += (float(s.group(3)) * 60) + float(s.group(4))
- cpu += float(s.group(5))
- count += 1
- except:
- raise ValueError("badly formatted times")
+ """ Calculate some benchmarking statistics.
+ Input is a directory containing a file called 'time'.
+ File contains one-per-line results of /usr/bin/time.
+ Output is average Elapsed, User, and System time in seconds,
+ and average CPU percentage.
+ """
+ f = open(dir + "/time")
+ user = system = elapsed = cpu = count = 0
+ r = re.compile('([\d\.]*)user ([\d\.]*)system (\d*):([\d\.]*)elapsed (\d*)%CPU')
+ for line in f.readlines():
+ try:
+ s = r.match(line);
+ user += float(s.group(1))
+ system += float(s.group(2))
+ elapsed += (float(s.group(3)) * 60) + float(s.group(4))
+ cpu += float(s.group(5))
+ count += 1
+ except:
+ raise ValueError("badly formatted times")
- f.close()
- return "Elapsed: %0.2fs User: %0.2fs System: %0.2fs CPU: %0.0f%%" % \
- (elapsed/count, user/count, system/count, cpu/count)
+ f.close()
+ return "Elapsed: %0.2fs User: %0.2fs System: %0.2fs CPU: %0.0f%%" % \
+ (elapsed/count, user/count, system/count, cpu/count)
def running_config():
- """
- Return path of config file of the currently running kernel
- """
- version = utils.system_output('uname -r')
- for config in ('/proc/config.gz', \
- '/boot/config-%s' % version,
- '/lib/modules/%s/build/.config' % version):
- if os.path.isfile(config):
- return config
- return None
+ """
+ Return path of config file of the currently running kernel
+ """
+ version = utils.system_output('uname -r')
+ for config in ('/proc/config.gz', \
+ '/boot/config-%s' % version,
+ '/lib/modules/%s/build/.config' % version):
+ if os.path.isfile(config):
+ return config
+ return None
def check_for_kernel_feature(feature):
- config = running_config()
+ config = running_config()
- if not config:
- raise TypeError("Can't find kernel config file")
+ if not config:
+ raise TypeError("Can't find kernel config file")
- if config.endswith('.gz'):
- grep = 'zgrep'
- else:
- grep = 'grep'
- grep += ' ^CONFIG_%s= %s' % (feature, config)
+ if config.endswith('.gz'):
+ grep = 'zgrep'
+ else:
+ grep = 'grep'
+ grep += ' ^CONFIG_%s= %s' % (feature, config)
- if not utils.system_output(grep, ignore_status=True):
- raise ValueError("Kernel doesn't have a %s feature" % (feature))
+ if not utils.system_output(grep, ignore_status=True):
+ raise ValueError("Kernel doesn't have a %s feature" % (feature))
def cpu_online_map():
- """
- Check out the available cpu online map
- """
- cpus = []
- for line in open('/proc/cpuinfo', 'r').readlines():
- if line.startswith('processor'):
- cpus.append(line.split()[2]) # grab cpu number
- return cpus
+ """
+ Check out the available cpu online map
+ """
+ cpus = []
+ for line in open('/proc/cpuinfo', 'r').readlines():
+ if line.startswith('processor'):
+ cpus.append(line.split()[2]) # grab cpu number
+ return cpus
def check_glibc_ver(ver):
- glibc_ver = commands.getoutput('ldd --version').splitlines()[0]
- glibc_ver = re.search(r'(\d+\.\d+(\.\d+)?)', glibc_ver).group()
- if glibc_ver.split('.') < ver.split('.'):
- raise error.TestError("Glibc is too old (%s). Glibc >= %s is needed." % \
- (glibc_ver, ver))
+ glibc_ver = commands.getoutput('ldd --version').splitlines()[0]
+ glibc_ver = re.search(r'(\d+\.\d+(\.\d+)?)', glibc_ver).group()
+ if glibc_ver.split('.') < ver.split('.'):
+ raise error.TestError("Glibc is too old (%s). Glibc >= %s is needed." % \
+ (glibc_ver, ver))
def check_kernel_ver(ver):
- kernel_ver = utils.system_output('uname -r')
- kv_tmp = re.split(r'[-]', kernel_ver)[0:3]
- if kv_tmp[0].split('.') < ver.split('.'):
- raise error.TestError("Kernel is too old (%s). Kernel > %s is needed." % \
- (kernel_ver, ver))
+ kernel_ver = utils.system_output('uname -r')
+ kv_tmp = re.split(r'[-]', kernel_ver)[0:3]
+ if kv_tmp[0].split('.') < ver.split('.'):
+ raise error.TestError("Kernel is too old (%s). Kernel > %s is needed." % \
+ (kernel_ver, ver))
def human_format(number):
- # Convert number to kilo / mega / giga format.
- if number < 1024:
- return "%d" % number
- kilo = float(number) / 1024.0
- if kilo < 1024:
- return "%.2fk" % kilo
- meg = kilo / 1024.0
- if meg < 1024:
- return "%.2fM" % meg
- gig = meg / 1024.0
- return "%.2fG" % gig
+ # Convert number to kilo / mega / giga format.
+ if number < 1024:
+ return "%d" % number
+ kilo = float(number) / 1024.0
+ if kilo < 1024:
+ return "%.2fk" % kilo
+ meg = kilo / 1024.0
+ if meg < 1024:
+ return "%.2fM" % meg
+ gig = meg / 1024.0
+ return "%.2fG" % gig
def numa_nodes():
- node_paths = glob.glob('/sys/devices/system/node/node*')
- nodes = [int(re.sub(r'.*node(\d+)', r'\1', x)) for x in node_paths]
- return (sorted(nodes))
+ node_paths = glob.glob('/sys/devices/system/node/node*')
+ nodes = [int(re.sub(r'.*node(\d+)', r'\1', x)) for x in node_paths]
+ return (sorted(nodes))
def node_size():
- nodes = max(len(numa_nodes()), 1)
- return ((memtotal() * 1024) / nodes)
+ nodes = max(len(numa_nodes()), 1)
+ return ((memtotal() * 1024) / nodes)
def to_seconds(time_string):
- """Converts a string in M+:SS.SS format to S+.SS"""
- elts = time_string.split(':')
- if len(elts) == 1:
- return time_string
- return str(int(elts[0]) * 60 + float(elts[1]))
+ """Converts a string in M+:SS.SS format to S+.SS"""
+ elts = time_string.split(':')
+ if len(elts) == 1:
+ return time_string
+ return str(int(elts[0]) * 60 + float(elts[1]))
def extract_all_time_results(results_string):
- """Extract user, system, and elapsed times into a list of tuples"""
- pattern = re.compile(r"(.*?)user (.*?)system (.*?)elapsed")
- results = []
- for result in pattern.findall(results_string):
- results.append(tuple([to_seconds(elt) for elt in result]))
- return results
+ """Extract user, system, and elapsed times into a list of tuples"""
+ pattern = re.compile(r"(.*?)user (.*?)system (.*?)elapsed")
+ results = []
+ for result in pattern.findall(results_string):
+ results.append(tuple([to_seconds(elt) for elt in result]))
+ return results
def pickle_load(filename):
- return pickle.load(open(filename, 'r'))
+ return pickle.load(open(filename, 'r'))
# Return the kernel version and build timestamp.
def running_os_release():
- return os.uname()[2:4]
+ return os.uname()[2:4]
def running_os_ident():
- (version, timestamp) = running_os_release()
- return version + '::' + timestamp
+ (version, timestamp) = running_os_release()
+ return version + '::' + timestamp
# much like find . -name 'pattern'
def locate(pattern, root=os.getcwd()):
- for path, dirs, files in os.walk(root):
- for f in [os.path.abspath(os.path.join(path, f))
- for f in files if fnmatch.fnmatch(f, pattern)]:
- yield f
+ for path, dirs, files in os.walk(root):
+ for f in [os.path.abspath(os.path.join(path, f))
+ for f in files if fnmatch.fnmatch(f, pattern)]:
+ yield f
def freespace(path):
- """Return the disk free space, in bytes"""
- s = os.statvfs(path)
- return s.f_bavail * s.f_bsize
+ """Return the disk free space, in bytes"""
+ s = os.statvfs(path)
+ return s.f_bavail * s.f_bsize
def disk_block_size(path):
- """Return the disk block size, in bytes"""
- return os.statvfs(path).f_bsize
+ """Return the disk block size, in bytes"""
+ return os.statvfs(path).f_bsize
def get_cpu_family():
- procinfo = utils.system_output('cat /proc/cpuinfo')
- CPU_FAMILY_RE = re.compile(r'^cpu family\s+:\s+(\S+)', re.M)
- matches = CPU_FAMILY_RE.findall(procinfo)
- if matches:
- return int(matches[0])
- else:
- raise error.TestError('Could not get valid cpu family data')
+ procinfo = utils.system_output('cat /proc/cpuinfo')
+ CPU_FAMILY_RE = re.compile(r'^cpu family\s+:\s+(\S+)', re.M)
+ matches = CPU_FAMILY_RE.findall(procinfo)
+ if matches:
+ return int(matches[0])
+ else:
+ raise error.TestError('Could not get valid cpu family data')
def get_disks():
- df_output = utils.system_output('df')
- disk_re = re.compile(r'^(/dev/hd[a-z]+)3', re.M)
- return disk_re.findall(df_output)
+ df_output = utils.system_output('df')
+ disk_re = re.compile(r'^(/dev/hd[a-z]+)3', re.M)
+ return disk_re.findall(df_output)
def load_module(module_name):
- # Checks if a module has already been loaded
- if module_is_loaded(module_name):
- return False
+ # Checks if a module has already been loaded
+ if module_is_loaded(module_name):
+ return False
- utils.system('/sbin/modprobe ' + module_name)
- return True
+ utils.system('/sbin/modprobe ' + module_name)
+ return True
def unload_module(module_name):
- utils.system('/sbin/rmmod ' + module_name)
+ utils.system('/sbin/rmmod ' + module_name)
def module_is_loaded(module_name):
- module_name = module_name.replace('-', '_')
- modules = utils.system_output('/sbin/lsmod').splitlines()
- for module in modules:
- if module.startswith(module_name) and module[len(module_name)] == ' ':
- return True
- return False
+ module_name = module_name.replace('-', '_')
+ modules = utils.system_output('/sbin/lsmod').splitlines()
+ for module in modules:
+ if module.startswith(module_name) and module[len(module_name)] == ' ':
+ return True
+ return False
def get_loaded_modules():
- lsmod_output = utils.system_output('/sbin/lsmod').splitlines()[1:]
- return [line.split(None, 1)[0] for line in lsmod_output]
+ lsmod_output = utils.system_output('/sbin/lsmod').splitlines()[1:]
+ return [line.split(None, 1)[0] for line in lsmod_output]
def get_huge_page_size():
- output = utils.system_output('grep Hugepagesize /proc/meminfo')
- return int(output.split()[1]) # Assumes units always in kB. :(
+ output = utils.system_output('grep Hugepagesize /proc/meminfo')
+ return int(output.split()[1]) # Assumes units always in kB. :(
def get_num_huge_pages():
- raw_hugepages = utils.system_output('/sbin/sysctl vm.nr_hugepages')
- return int(raw_hugepages.split()[2])
+ raw_hugepages = utils.system_output('/sbin/sysctl vm.nr_hugepages')
+ return int(raw_hugepages.split()[2])
def set_num_huge_pages(num):
- utils.system('/sbin/sysctl vm.nr_hugepages=%d' % num)
+ utils.system('/sbin/sysctl vm.nr_hugepages=%d' % num)
def get_system_nodes():
- nodes = os.listdir('/sys/devices/system/node')
- nodes.sort()
- return nodes
+ nodes = os.listdir('/sys/devices/system/node')
+ nodes.sort()
+ return nodes
def get_cpu_vendor():
- cpuinfo = open('/proc/cpuinfo').read()
- vendors = re.findall(r'(?m)^vendor_id\s*:\s*(\S+)\s*$', cpuinfo)
- for i in xrange(1, len(vendors)):
- if vendors[i] != vendors[0]:
- raise error.TestError('multiple cpu vendors found: ' + str(vendors))
- return vendors[0]
+ cpuinfo = open('/proc/cpuinfo').read()
+ vendors = re.findall(r'(?m)^vendor_id\s*:\s*(\S+)\s*$', cpuinfo)
+ for i in xrange(1, len(vendors)):
+ if vendors[i] != vendors[0]:
+ raise error.TestError('multiple cpu vendors found: ' + str(vendors))
+ return vendors[0]
def probe_cpus():
- """
- This routine returns a list of cpu devices found under /sys/devices/system/cpu.
- """
- output = utils.system_output(
- 'find /sys/devices/system/cpu/ -maxdepth 1 -type d -name cpu*')
- return output.splitlines()
+ """
+ This routine returns a list of cpu devices found under /sys/devices/system/cpu.
+ """
+ output = utils.system_output(
+ 'find /sys/devices/system/cpu/ -maxdepth 1 -type d -name cpu*')
+ return output.splitlines()
def ping_default_gateway():
- """Ping the default gateway."""
-
- network = open('/etc/sysconfig/network')
- m = re.search('GATEWAY=(\S+)', network.read())
+ """Ping the default gateway."""
- if m:
- gw = m.group(1)
- cmd = 'ping %s -c 5 > /dev/null' % gw
- return utils.system(cmd, ignore_status=True)
-
- raise error.TestError('Unable to find default gateway')
+ network = open('/etc/sysconfig/network')
+ m = re.search('GATEWAY=(\S+)', network.read())
+
+ if m:
+ gw = m.group(1)
+ cmd = 'ping %s -c 5 > /dev/null' % gw
+ return utils.system(cmd, ignore_status=True)
+
+ raise error.TestError('Unable to find default gateway')
try:
- from site_utils import *
+ from site_utils import *
except ImportError:
- pass
+ pass
diff --git a/client/bin/boottool.py b/client/bin/boottool.py
index 43f7f39..7c10618 100644
--- a/client/bin/boottool.py
+++ b/client/bin/boottool.py
@@ -2,125 +2,124 @@
from autotest_lib.client.common_lib import utils, error
class boottool:
- def __init__(self, boottool_exec=None):
- #variable to indicate if in mode to write entries for Xen
- self.xen_mode = False
+ def __init__(self, boottool_exec=None):
+ #variable to indicate if in mode to write entries for Xen
+ self.xen_mode = False
- if boottool_exec:
- self.boottool_exec = boottool_exec
- else:
- autodir = os.environ['AUTODIR']
- self.boottool_exec = autodir + '/tools/boottool'
+ if boottool_exec:
+ self.boottool_exec = boottool_exec
+ else:
+ autodir = os.environ['AUTODIR']
+ self.boottool_exec = autodir + '/tools/boottool'
- if not self.boottool_exec:
- raise error.AutotestError('Failed to set boottool_exec')
+ if not self.boottool_exec:
+ raise error.AutotestError('Failed to set boottool_exec')
- def run_boottool(self, params):
- return utils.system_output('%s %s' % (self.boottool_exec, params))
+ def run_boottool(self, params):
+ return utils.system_output('%s %s' % (self.boottool_exec, params))
- def bootloader(self):
- return self.run_boottool('--bootloader-probe')
+ def bootloader(self):
+ return self.run_boottool('--bootloader-probe')
- def architecture(self):
- return self.run_boottool('--arch-probe')
+ def architecture(self):
+ return self.run_boottool('--arch-probe')
- def list_titles(self):
- print self.run_boottool('--info all | grep title')
+ def list_titles(self):
+ print self.run_boottool('--info all | grep title')
- def print_entry(self, index):
- print self.run_boottool('--info=%s' % index)
+ def print_entry(self, index):
+ print self.run_boottool('--info=%s' % index)
- def get_default(self):
- self.run_boottool('--default')
+ def get_default(self):
+ self.run_boottool('--default')
- def set_default(self, index):
- print self.run_boottool('--set-default=%s' % index)
+ def set_default(self, index):
+ print self.run_boottool('--set-default=%s' % index)
- def enable_xen_mode(self):
- self.xen_mode = True
+ def enable_xen_mode(self):
+ self.xen_mode = True
- def disable_xen_mode(self):
- self.xen_mode = False
+ def disable_xen_mode(self):
+ self.xen_mode = False
- def get_xen_mode(self):
- return self.xen_mode
+ def get_xen_mode(self):
+ return self.xen_mode
- # 'kernel' can be an position number or a title
- def add_args(self, kernel, args):
- parameters = '--update-kernel=%s --args="%s"' % (kernel, args)
+ # 'kernel' can be an position number or a title
+ def add_args(self, kernel, args):
+ parameters = '--update-kernel=%s --args="%s"' % (kernel, args)
- #add parameter if this is a Xen entry
- if self.xen_mode:
- parameters += ' --xen'
+ #add parameter if this is a Xen entry
+ if self.xen_mode:
+ parameters += ' --xen'
- print self.run_boottool(parameters)
+ print self.run_boottool(parameters)
- def add_xen_hypervisor_args(self, kernel, args):
- self.run_boottool('--xen --update-xenhyper=%s --xha="%s"') %(kernel, args)
-
-
- def remove_args(self, kernel, args):
- parameters = '--update-kernel=%s --remove-args=%s' % (kernel, args)
-
- #add parameter if this is a Xen entry
- if self.xen_mode:
- parameters += ' --xen'
-
- print self.run_boottool(parameters)
+ def add_xen_hypervisor_args(self, kernel, args):
+ self.run_boottool('--xen --update-xenhyper=%s --xha="%s"') %(kernel, args)
- def remove_xen_hypervisor_args(self, kernel, args):
- self.run_boottool('--xen --update-xenhyper=%s --remove-args="%s"') \
- % (kernel, args)
+ def remove_args(self, kernel, args):
+ parameters = '--update-kernel=%s --remove-args=%s' % (kernel, args)
+
+ #add parameter if this is a Xen entry
+ if self.xen_mode:
+ parameters += ' --xen'
+
+ print self.run_boottool(parameters)
- def add_kernel(self, path, title='autotest', initrd='', xen_hypervisor='', args=None, root=None, position='end'):
- parameters = '--add-kernel=%s --title=%s' % (path, title)
-
- # add an initrd now or forever hold your peace
- if initrd:
- parameters += ' --initrd=%s' % initrd
-
- # add parameter if this is a Xen entry
- if self.xen_mode:
- parameters += ' --xen'
- if xen_hypervisor:
- parameters += ' --xenhyper=%s' % xen_hypervisor
-
- if args:
- parameters += ' --args="%s"' % args
- if root:
- parameters += ' --root="%s"' % root
- if position:
- parameters += ' --position="%s"' % position
-
- print self.run_boottool(parameters)
+ def remove_xen_hypervisor_args(self, kernel, args):
+ self.run_boottool('--xen --update-xenhyper=%s --remove-args="%s"') \
+ % (kernel, args)
- def remove_kernel(self, kernel):
- print self.run_boottool('--remove-kernel=%s' % kernel)
+ def add_kernel(self, path, title='autotest', initrd='', xen_hypervisor='', args=None, root=None, position='end'):
+ parameters = '--add-kernel=%s --title=%s' % (path, title)
+
+ # add an initrd now or forever hold your peace
+ if initrd:
+ parameters += ' --initrd=%s' % initrd
+
+ # add parameter if this is a Xen entry
+ if self.xen_mode:
+ parameters += ' --xen'
+ if xen_hypervisor:
+ parameters += ' --xenhyper=%s' % xen_hypervisor
+
+ if args:
+ parameters += ' --args="%s"' % args
+ if root:
+ parameters += ' --root="%s"' % root
+ if position:
+ parameters += ' --position="%s"' % position
+
+ print self.run_boottool(parameters)
- def boot_once(self, title):
- print self.run_boottool('--boot-once --title=%s' % title)
+ def remove_kernel(self, kernel):
+ print self.run_boottool('--remove-kernel=%s' % kernel)
- def info(self, index):
- return self.run_boottool('--info=%s' % index)
+ def boot_once(self, title):
+ print self.run_boottool('--boot-once --title=%s' % title)
+
+
+ def info(self, index):
+ return self.run_boottool('--info=%s' % index)
# TODO: backup()
# TODO: set_timeout()
-
diff --git a/client/bin/common.py b/client/bin/common.py
index 74ed759..6881386 100644
--- a/client/bin/common.py
+++ b/client/bin/common.py
@@ -5,4 +5,4 @@
import setup_modules
sys.path.pop(0)
setup_modules.setup(base_path=client_dir,
- root_module_name="autotest_lib.client")
+ root_module_name="autotest_lib.client")
diff --git a/client/bin/config.py b/client/bin/config.py
index 59b8279..477bece 100644
--- a/client/bin/config.py
+++ b/client/bin/config.py
@@ -8,7 +8,7 @@
Please no StudlyCaps.
For example:
- boot.default_args
+ boot.default_args
"""
__author__ = """Copyright Andy Whitcroft 2006"""
@@ -16,33 +16,33 @@
import os
class config:
- """The BASIC job configuration
+ """The BASIC job configuration
- Properties:
- job
- The job object for this job
- config
- The job configuration dictionary
- """
+ Properties:
+ job
+ The job object for this job
+ config
+ The job configuration dictionary
+ """
- def __init__(self, job):
- """
- job
- The job object for this job
- """
- self.job = job
- self.config = {}
+ def __init__(self, job):
+ """
+ job
+ The job object for this job
+ """
+ self.job = job
+ self.config = {}
- def set(self, name, value):
- if name == "proxy":
- os.environ['http_proxy'] = value
- os.environ['ftp_proxy'] = value
+ def set(self, name, value):
+ if name == "proxy":
+ os.environ['http_proxy'] = value
+ os.environ['ftp_proxy'] = value
- self.config[name] = value
+ self.config[name] = value
- def get(self, name):
- if name in self.config:
- return self.config[name]
- else:
- return None
+ def get(self, name):
+ if name in self.config:
+ return self.config[name]
+ else:
+ return None
diff --git a/client/bin/cpuset.py b/client/bin/cpuset.py
index a870e76..fe583ac 100644
--- a/client/bin/cpuset.py
+++ b/client/bin/cpuset.py
@@ -9,265 +9,265 @@
# Convert '1-3,7,9-12' to [1,2,3,7,9,10,11,12]
def rangelist_to_list(rangelist):
- result = []
- if not rangelist:
- return result
- for x in rangelist.split(','):
- if re.match(r'^(\d+)$', x):
- result.append(int(x))
- continue
- m = re.match(r'^(\d+)-(\d+)$', x)
- if m:
- start = int(m.group(1))
- end = int(m.group(2))
- result += range(start, end+1)
- continue
- msg = 'Cannot understand data input: %s %s' % (x, rangelist)
- raise ValueError(msg)
- return result
+ result = []
+ if not rangelist:
+ return result
+ for x in rangelist.split(','):
+ if re.match(r'^(\d+)$', x):
+ result.append(int(x))
+ continue
+ m = re.match(r'^(\d+)-(\d+)$', x)
+ if m:
+ start = int(m.group(1))
+ end = int(m.group(2))
+ result += range(start, end+1)
+ continue
+ msg = 'Cannot understand data input: %s %s' % (x, rangelist)
+ raise ValueError(msg)
+ return result
def rounded_memtotal():
- # Get total of all physical mem, in Kbytes
- usable_Kbytes = autotest_utils.memtotal()
- # usable_Kbytes is system's usable DRAM in Kbytes,
- # as reported by memtotal() from device /proc/meminfo memtotal
- # after Linux deducts 1.5% to 5.1% for system table overhead
- # Undo the unknown actual deduction by rounding up
- # to next small multiple of a big power-of-two
- # eg 12GB - 5.1% gets rounded back up to 12GB
- mindeduct = 0.015 # 1.5 percent
- maxdeduct = 0.055 # 5.5 percent
- # deduction range 1.5% .. 5.5% supports physical mem sizes
- # 6GB .. 12GB in steps of .5GB
- # 12GB .. 24GB in steps of 1 GB
- # 24GB .. 48GB in steps of 2 GB ...
- # Finer granularity in physical mem sizes would require
- # tighter spread between min and max possible deductions
+ # Get total of all physical mem, in Kbytes
+ usable_Kbytes = autotest_utils.memtotal()
+ # usable_Kbytes is system's usable DRAM in Kbytes,
+ # as reported by memtotal() from device /proc/meminfo memtotal
+ # after Linux deducts 1.5% to 5.1% for system table overhead
+ # Undo the unknown actual deduction by rounding up
+ # to next small multiple of a big power-of-two
+ # eg 12GB - 5.1% gets rounded back up to 12GB
+ mindeduct = 0.015 # 1.5 percent
+ maxdeduct = 0.055 # 5.5 percent
+ # deduction range 1.5% .. 5.5% supports physical mem sizes
+ # 6GB .. 12GB in steps of .5GB
+ # 12GB .. 24GB in steps of 1 GB
+ # 24GB .. 48GB in steps of 2 GB ...
+ # Finer granularity in physical mem sizes would require
+ # tighter spread between min and max possible deductions
- # increase mem size by at least min deduction, without rounding
- min_Kbytes = int(usable_Kbytes / (1.0 - mindeduct))
- # increase mem size further by 2**n rounding, by 0..roundKb or more
- round_Kbytes = int(usable_Kbytes / (1.0 - maxdeduct)) - min_Kbytes
- # find least binary roundup 2**n that covers worst-cast roundKb
- mod2n = 1 << int(math.ceil(math.log(round_Kbytes, 2)))
- # have round_Kbytes <= mod2n < round_Kbytes*2
- # round min_Kbytes up to next multiple of mod2n
- phys_Kbytes = min_Kbytes + mod2n - 1
- phys_Kbytes = phys_Kbytes - (phys_Kbytes % mod2n) # clear low bits
- return phys_Kbytes
+ # increase mem size by at least min deduction, without rounding
+ min_Kbytes = int(usable_Kbytes / (1.0 - mindeduct))
+ # increase mem size further by 2**n rounding, by 0..roundKb or more
+ round_Kbytes = int(usable_Kbytes / (1.0 - maxdeduct)) - min_Kbytes
+ # find least binary roundup 2**n that covers worst-cast roundKb
+ mod2n = 1 << int(math.ceil(math.log(round_Kbytes, 2)))
+ # have round_Kbytes <= mod2n < round_Kbytes*2
+ # round min_Kbytes up to next multiple of mod2n
+ phys_Kbytes = min_Kbytes + mod2n - 1
+ phys_Kbytes = phys_Kbytes - (phys_Kbytes % mod2n) # clear low bits
+ return phys_Kbytes
def my_container_name():
- # Get current process's inherited or self-built container name
- # within /dev/cpuset. Is '/' for root container, '/sys', etc.
- return utils.read_one_line('/proc/%i/cpuset' % os.getpid())
+ # Get current process's inherited or self-built container name
+ # within /dev/cpuset. Is '/' for root container, '/sys', etc.
+ return utils.read_one_line('/proc/%i/cpuset' % os.getpid())
def get_mem_nodes(container_full_name):
- file_name = os.path.join(container_full_name, "mems")
- if os.path.exists(file_name):
- return rangelist_to_list(utils.read_one_line(file_name))
- else:
- return []
+ file_name = os.path.join(container_full_name, "mems")
+ if os.path.exists(file_name):
+ return rangelist_to_list(utils.read_one_line(file_name))
+ else:
+ return []
def available_exclusive_mem_nodes(parent_container):
- # Get list of numa memory nodes of parent container which could
- # be allocated exclusively to new child containers.
- # This excludes any nodes now allocated (exclusively or not)
- # to existing children.
- available = set(get_mem_nodes(parent_container))
- for child_container in glob.glob('%s/*/mems' % parent_container):
- child_container = os.path.dirname(child_container)
- busy = set(get_mem_nodes(child_container))
- available -= busy
- return list(available)
+ # Get list of numa memory nodes of parent container which could
+ # be allocated exclusively to new child containers.
+ # This excludes any nodes now allocated (exclusively or not)
+ # to existing children.
+ available = set(get_mem_nodes(parent_container))
+ for child_container in glob.glob('%s/*/mems' % parent_container):
+ child_container = os.path.dirname(child_container)
+ busy = set(get_mem_nodes(child_container))
+ available -= busy
+ return list(available)
def my_mem_nodes():
- # Get list of numa memory nodes owned by current process's container.
- return get_mem_nodes('/dev/cpuset%s' % my_container_name())
+ # Get list of numa memory nodes owned by current process's container.
+ return get_mem_nodes('/dev/cpuset%s' % my_container_name())
def my_available_exclusive_mem_nodes():
- # Get list of numa memory nodes owned by current process's
- # container, which could be allocated exclusively to new child
- # containers. This excludes any nodes now allocated
- # (exclusively or not) to existing children.
- return available_exclusive_mem_nodes('/dev/cpuset%s' % my_container_name())
+ # Get list of numa memory nodes owned by current process's
+ # container, which could be allocated exclusively to new child
+ # containers. This excludes any nodes now allocated
+ # (exclusively or not) to existing children.
+ return available_exclusive_mem_nodes('/dev/cpuset%s' % my_container_name())
def mbytes_per_mem_node():
- # Get mbyte size of each numa mem node, as float
- # Replaces autotest_utils.node_size().
- # Based on guessed total physical mem size, not on kernel's
- # lesser 'available memory' after various system tables.
- # Can be non-integer when kernel sets up 15 nodes instead of 16.
- return rounded_memtotal() / (len(autotest_utils.numa_nodes()) * 1024.0)
+ # Get mbyte size of each numa mem node, as float
+ # Replaces autotest_utils.node_size().
+ # Based on guessed total physical mem size, not on kernel's
+ # lesser 'available memory' after various system tables.
+ # Can be non-integer when kernel sets up 15 nodes instead of 16.
+ return rounded_memtotal() / (len(autotest_utils.numa_nodes()) * 1024.0)
def get_cpus(container_full_name):
- file_name = os.path.join(container_full_name, "cpus")
- if os.path.exists(file_name):
- return rangelist_to_list(utils.read_one_line(file_name))
- else:
- return []
+ file_name = os.path.join(container_full_name, "cpus")
+ if os.path.exists(file_name):
+ return rangelist_to_list(utils.read_one_line(file_name))
+ else:
+ return []
def my_cpus():
- # Get list of cpu cores owned by current process's container.
- return get_cpus('/dev/cpuset%s' % my_container_name())
+ # Get list of cpu cores owned by current process's container.
+ return get_cpus('/dev/cpuset%s' % my_container_name())
def get_tasks(setname):
- return [x.rstrip() for x in open(setname+'/tasks').readlines()]
+ return [x.rstrip() for x in open(setname+'/tasks').readlines()]
def print_one_cpuset(name):
- dir = os.path.join('/dev/cpuset', name)
- cpus = utils.read_one_line(dir + '/cpus')
- mems = utils.read_one_line(dir + '/mems')
- node_size_ = int(mbytes_per_mem_node()) << 20
- memtotal = node_size_ * len(rangelist_to_list(mems))
- tasks = ','.join(get_tasks(dir))
- print "cpuset %s: size %s; tasks %s; cpus %s; mems %s" % \
- (name, autotest_utils.human_format(memtotal), tasks, cpus, mems)
+ dir = os.path.join('/dev/cpuset', name)
+ cpus = utils.read_one_line(dir + '/cpus')
+ mems = utils.read_one_line(dir + '/mems')
+ node_size_ = int(mbytes_per_mem_node()) << 20
+ memtotal = node_size_ * len(rangelist_to_list(mems))
+ tasks = ','.join(get_tasks(dir))
+ print "cpuset %s: size %s; tasks %s; cpus %s; mems %s" % \
+ (name, autotest_utils.human_format(memtotal), tasks, cpus, mems)
def print_all_cpusets():
- for cpuset in glob.glob('/dev/cpuset/*'):
- print_one_cpuset(re.sub(r'.*/', '', cpuset))
+ for cpuset in glob.glob('/dev/cpuset/*'):
+ print_one_cpuset(re.sub(r'.*/', '', cpuset))
def release_dead_containers(parent=super_root):
- # Delete temp subcontainers nested within parent container
- # that are now dead (having no tasks and no sub-containers)
- # and recover their cpu and mem resources.
- # Must not call when a parallel task may be allocating containers!
- # Limit to test* names to preserve permanent containers.
- for child in glob.glob('%s/test*' % parent):
- print 'releasing dead container', child
- release_dead_containers(child) # bottom-up tree walk
- # rmdir has no effect when container still
- # has tasks or sub-containers
- os.rmdir(child)
+ # Delete temp subcontainers nested within parent container
+ # that are now dead (having no tasks and no sub-containers)
+ # and recover their cpu and mem resources.
+ # Must not call when a parallel task may be allocating containers!
+ # Limit to test* names to preserve permanent containers.
+ for child in glob.glob('%s/test*' % parent):
+ print 'releasing dead container', child
+ release_dead_containers(child) # bottom-up tree walk
+ # rmdir has no effect when container still
+ # has tasks or sub-containers
+ os.rmdir(child)
class cpuset:
- def display(self):
- print_one_cpuset(os.path.join(self.root, self.name))
+ def display(self):
+ print_one_cpuset(os.path.join(self.root, self.name))
- def release(self):
- print "releasing ", self.cpudir
- parent_t = os.path.join(self.root, 'tasks')
- # Transfer survivors (and self) to parent
- for task in get_tasks(self.cpudir):
- utils.write_one_line(parent_t, task)
- os.rmdir(self.cpudir)
- if os.path.exists(self.cpudir):
- raise error.AutotestError('Could not delete container '
- + self.cpudir)
+ def release(self):
+ print "releasing ", self.cpudir
+ parent_t = os.path.join(self.root, 'tasks')
+ # Transfer survivors (and self) to parent
+ for task in get_tasks(self.cpudir):
+ utils.write_one_line(parent_t, task)
+ os.rmdir(self.cpudir)
+ if os.path.exists(self.cpudir):
+ raise error.AutotestError('Could not delete container '
+ + self.cpudir)
- def __init__(self, name, job_size=None, job_pid=None, cpus=None,
- root=None):
- """\
- Create a cpuset container and move job_pid into it
- Allocate the list "cpus" of cpus to that container
+ def __init__(self, name, job_size=None, job_pid=None, cpus=None,
+ root=None):
+ """\
+ Create a cpuset container and move job_pid into it
+ Allocate the list "cpus" of cpus to that container
- name = arbitrary string tag
- job_size = reqested memory for job in megabytes
- job_pid = pid of job we're putting into the container
- cpu = list of cpu indicies to associate with the cpuset
- root = the cpuset to create this new set in
- """
- if not os.path.exists(os.path.join(super_root, "cpus")):
- raise error.AutotestError('Root container /dev/cpuset '
- 'is empty; please reboot')
+ name = arbitrary string tag
+ job_size = reqested memory for job in megabytes
+ job_pid = pid of job we're putting into the container
+ cpu = list of cpu indicies to associate with the cpuset
+ root = the cpuset to create this new set in
+ """
+ if not os.path.exists(os.path.join(super_root, "cpus")):
+ raise error.AutotestError('Root container /dev/cpuset '
+ 'is empty; please reboot')
- self.name = name
+ self.name = name
- if root == None:
- # default to nested in process's current container
- root = my_container_name()[1:]
- self.root = os.path.join(super_root, root)
- if not os.path.exists(self.root):
- raise error.AutotestError(('Parent container %s'
- ' does not exist')
- % self.root)
+ if root == None:
+ # default to nested in process's current container
+ root = my_container_name()[1:]
+ self.root = os.path.join(super_root, root)
+ if not os.path.exists(self.root):
+ raise error.AutotestError(('Parent container %s'
+ ' does not exist')
+ % self.root)
- if job_size == None:
- # default to biggest container we can make under root
- job_size = int( mbytes_per_mem_node() *
- len(available_exclusive_mem_nodes(self.root)) )
- if not job_size:
- raise error.AutotestError('Creating container '
- 'with no mem')
- self.memory = job_size
+ if job_size == None:
+ # default to biggest container we can make under root
+ job_size = int( mbytes_per_mem_node() *
+ len(available_exclusive_mem_nodes(self.root)) )
+ if not job_size:
+ raise error.AutotestError('Creating container '
+ 'with no mem')
+ self.memory = job_size
- if cpus == None:
- # default to biggest container we can make under root
- cpus = get_cpus(self.root)
- if not cpus:
- raise error.AutotestError('Creating container '
- 'with no cpus')
- self.cpus = cpus
+ if cpus == None:
+ # default to biggest container we can make under root
+ cpus = get_cpus(self.root)
+ if not cpus:
+ raise error.AutotestError('Creating container '
+ 'with no cpus')
+ self.cpus = cpus
- # default to the current pid
- if not job_pid:
- job_pid = os.getpid()
+ # default to the current pid
+ if not job_pid:
+ job_pid = os.getpid()
- print "cpuset(name=%s, root=%s, job_size=%d, pid=%d)" % \
- (name, root, job_size, job_pid)
+ print "cpuset(name=%s, root=%s, job_size=%d, pid=%d)" % \
+ (name, root, job_size, job_pid)
- self.cpudir = os.path.join(self.root, name)
- if os.path.exists(self.cpudir):
- self.release() # destructively replace old
+ self.cpudir = os.path.join(self.root, name)
+ if os.path.exists(self.cpudir):
+ self.release() # destructively replace old
- nodes_needed = int(math.ceil( float(job_size) /
- math.ceil(mbytes_per_mem_node()) ))
+ nodes_needed = int(math.ceil( float(job_size) /
+ math.ceil(mbytes_per_mem_node()) ))
- if nodes_needed > len(get_mem_nodes(self.root)):
- raise error.AutotestError("Container's memory "
- "is bigger than parent's")
+ if nodes_needed > len(get_mem_nodes(self.root)):
+ raise error.AutotestError("Container's memory "
+ "is bigger than parent's")
- while True:
- # Pick specific free mem nodes for this cpuset
- mems = available_exclusive_mem_nodes(self.root)
- if len(mems) < nodes_needed:
- raise error.AutotestError(('Existing container'
- ' hold %d mem nodes'
- ' needed by new'
- 'container')
- % (nodes_needed
- - len(mems)))
- mems = mems[-nodes_needed:]
- mems_spec = ','.join(['%d' % x for x in mems])
- os.mkdir(self.cpudir)
- utils.write_one_line(os.path.join(self.cpudir,
- 'mem_exclusive'), '1')
- utils.write_one_line(os.path.join(self.cpudir,
- 'mems'),
- mems_spec)
- # Above sends err msg to client.log.0, but no exception,
- # if mems_spec contained any now-taken nodes
- # Confirm that siblings didn't grab our chosen mems:
- nodes_gotten = len(get_mem_nodes(self.cpudir))
- if nodes_gotten >= nodes_needed:
- break # success
- print "cpuset %s lost race for nodes" % name, mems_spec
- # Return any mem we did get, and try again
- os.rmdir(self.cpudir)
+ while True:
+ # Pick specific free mem nodes for this cpuset
+ mems = available_exclusive_mem_nodes(self.root)
+ if len(mems) < nodes_needed:
+ raise error.AutotestError(('Existing container'
+ ' hold %d mem nodes'
+ ' needed by new'
+ 'container')
+ % (nodes_needed
+ - len(mems)))
+ mems = mems[-nodes_needed:]
+ mems_spec = ','.join(['%d' % x for x in mems])
+ os.mkdir(self.cpudir)
+ utils.write_one_line(os.path.join(self.cpudir,
+ 'mem_exclusive'), '1')
+ utils.write_one_line(os.path.join(self.cpudir,
+ 'mems'),
+ mems_spec)
+ # Above sends err msg to client.log.0, but no exception,
+ # if mems_spec contained any now-taken nodes
+ # Confirm that siblings didn't grab our chosen mems:
+ nodes_gotten = len(get_mem_nodes(self.cpudir))
+ if nodes_gotten >= nodes_needed:
+ break # success
+ print "cpuset %s lost race for nodes" % name, mems_spec
+ # Return any mem we did get, and try again
+ os.rmdir(self.cpudir)
- # add specified cpu cores and own task pid to container:
- cpu_spec = ','.join(['%d' % x for x in cpus])
- utils.write_one_line(os.path.join(self.cpudir,
- 'cpus'),
- cpu_spec)
- utils.write_one_line(os.path.join(self.cpudir,
- 'tasks'),
- "%d" % job_pid)
- self.display()
+ # add specified cpu cores and own task pid to container:
+ cpu_spec = ','.join(['%d' % x for x in cpus])
+ utils.write_one_line(os.path.join(self.cpudir,
+ 'cpus'),
+ cpu_spec)
+ utils.write_one_line(os.path.join(self.cpudir,
+ 'tasks'),
+ "%d" % job_pid)
+ self.display()
diff --git a/client/bin/fd_stack.py b/client/bin/fd_stack.py
index c377cf0..e0f3f4c 100755
--- a/client/bin/fd_stack.py
+++ b/client/bin/fd_stack.py
@@ -3,137 +3,137 @@
import sys, os
class fd_stack:
- """a stack of fd redirects
+ """a stack of fd redirects
- Redirects cause existing fd's to be pushed on the stack; restore()
- causes the current set of redirects to be popped, restoring the previous
- filehandle destinations.
+ Redirects cause existing fd's to be pushed on the stack; restore()
+ causes the current set of redirects to be popped, restoring the previous
+ filehandle destinations.
- Note that we need to redirect both the sys.stdout type descriptor
- (which print, etc use) and the low level OS numbered descriptor
- which os.system() etc use.
- """
+ Note that we need to redirect both the sys.stdout type descriptor
+ (which print, etc use) and the low level OS numbered descriptor
+ which os.system() etc use.
+ """
- def __init__(self, fd, filehandle):
- self.fd = fd # eg 1
- self.filehandle = filehandle # eg sys.stdout
- self.stack = [(fd, filehandle)]
+ def __init__(self, fd, filehandle):
+ self.fd = fd # eg 1
+ self.filehandle = filehandle # eg sys.stdout
+ self.stack = [(fd, filehandle)]
- def update_handle(self, new):
- if (self.filehandle == sys.stdout):
- sys.stdout = new
- if (self.filehandle == sys.stderr):
- sys.stderr = new
- self.filehandle = new
+ def update_handle(self, new):
+ if (self.filehandle == sys.stdout):
+ sys.stdout = new
+ if (self.filehandle == sys.stderr):
+ sys.stderr = new
+ self.filehandle = new
- def redirect(self, filename):
- """Redirect output to the specified file
+ def redirect(self, filename):
+ """Redirect output to the specified file
- Overwrites the previous contents, if any.
- """
- self.filehandle.flush()
- fdcopy = os.dup(self.fd)
- self.stack.append( (fdcopy, self.filehandle, 0) )
- # self.filehandle = file(filename, 'w')
- if (os.path.isfile(filename)):
- newfd = os.open(filename, os.O_WRONLY)
- else:
- newfd = os.open(filename, os.O_WRONLY | os.O_CREAT)
- os.dup2(newfd, self.fd)
- os.close(newfd)
- self.update_handle(os.fdopen(self.fd, 'w'))
+ Overwrites the previous contents, if any.
+ """
+ self.filehandle.flush()
+ fdcopy = os.dup(self.fd)
+ self.stack.append( (fdcopy, self.filehandle, 0) )
+ # self.filehandle = file(filename, 'w')
+ if (os.path.isfile(filename)):
+ newfd = os.open(filename, os.O_WRONLY)
+ else:
+ newfd = os.open(filename, os.O_WRONLY | os.O_CREAT)
+ os.dup2(newfd, self.fd)
+ os.close(newfd)
+ self.update_handle(os.fdopen(self.fd, 'w'))
- def tee_redirect(self, filename):
- """Tee output to the specified file
+ def tee_redirect(self, filename):
+ """Tee output to the specified file
- Overwrites the previous contents, if any.
- """
- self.filehandle.flush()
- #print_to_tty("tee_redirect to " + filename)
- #where_art_thy_filehandles()
- fdcopy = os.dup(self.fd)
- r, w = os.pipe()
- pid = os.fork()
- if pid: # parent
- os.close(r)
- os.dup2(w, self.fd)
- os.close(w)
- self.stack.append( (fdcopy, self.filehandle, pid) )
- self.update_handle(os.fdopen(self.fd, 'w', 0))
- #where_art_thy_filehandles()
- #print_to_tty("done tee_redirect to " + filename)
- else: # child
- os.close(w)
- os.dup2(r, 0)
- os.dup2(fdcopy, 1)
- os.close(r)
- os.close(fdcopy)
- os.execlp('tee', 'tee', '-a', filename)
+ Overwrites the previous contents, if any.
+ """
+ self.filehandle.flush()
+ #print_to_tty("tee_redirect to " + filename)
+ #where_art_thy_filehandles()
+ fdcopy = os.dup(self.fd)
+ r, w = os.pipe()
+ pid = os.fork()
+ if pid: # parent
+ os.close(r)
+ os.dup2(w, self.fd)
+ os.close(w)
+ self.stack.append( (fdcopy, self.filehandle, pid) )
+ self.update_handle(os.fdopen(self.fd, 'w', 0))
+ #where_art_thy_filehandles()
+ #print_to_tty("done tee_redirect to " + filename)
+ else: # child
+ os.close(w)
+ os.dup2(r, 0)
+ os.dup2(fdcopy, 1)
+ os.close(r)
+ os.close(fdcopy)
+ os.execlp('tee', 'tee', '-a', filename)
-
- def restore(self):
- """unredirect one level"""
- self.filehandle.flush()
- # print_to_tty("ENTERING RESTORE %d" % self.fd)
- # where_art_thy_filehandles()
- (old_fd, old_filehandle, pid) = self.stack.pop()
- # print_to_tty("old_fd %d" % old_fd)
- # print_to_tty("self.fd %d" % self.fd)
- self.filehandle.close() # seems to close old_fd as well.
- if pid:
- os.waitpid(pid, 0)
- # where_art_thy_filehandles()
- os.dup2(old_fd, self.fd)
- # print_to_tty("CLOSING FD %d" % old_fd)
- os.close(old_fd)
- # where_art_thy_filehandles()
- self.update_handle(old_filehandle)
- # where_art_thy_filehandles()
- # print_to_tty("EXIT RESTORE %d" % self.fd)
+
+ def restore(self):
+ """unredirect one level"""
+ self.filehandle.flush()
+ # print_to_tty("ENTERING RESTORE %d" % self.fd)
+ # where_art_thy_filehandles()
+ (old_fd, old_filehandle, pid) = self.stack.pop()
+ # print_to_tty("old_fd %d" % old_fd)
+ # print_to_tty("self.fd %d" % self.fd)
+ self.filehandle.close() # seems to close old_fd as well.
+ if pid:
+ os.waitpid(pid, 0)
+ # where_art_thy_filehandles()
+ os.dup2(old_fd, self.fd)
+ # print_to_tty("CLOSING FD %d" % old_fd)
+ os.close(old_fd)
+ # where_art_thy_filehandles()
+ self.update_handle(old_filehandle)
+ # where_art_thy_filehandles()
+ # print_to_tty("EXIT RESTORE %d" % self.fd)
def tee_output_logdir(fn):
- """\
- Method decorator for a class to tee the output to the objects log_dir.
- """
- def tee_logdir_wrapper(self, *args, **dargs):
- self.job.stdout.tee_redirect(os.path.join(self.log_dir, 'stdout'))
- self.job.stderr.tee_redirect(os.path.join(self.log_dir, 'stderr'))
- try:
- result = fn(self, *args, **dargs)
- finally:
- self.job.stderr.restore()
- self.job.stdout.restore()
- return result
- return tee_logdir_wrapper
+ """\
+ Method decorator for a class to tee the output to the objects log_dir.
+ """
+ def tee_logdir_wrapper(self, *args, **dargs):
+ self.job.stdout.tee_redirect(os.path.join(self.log_dir, 'stdout'))
+ self.job.stderr.tee_redirect(os.path.join(self.log_dir, 'stderr'))
+ try:
+ result = fn(self, *args, **dargs)
+ finally:
+ self.job.stderr.restore()
+ self.job.stdout.restore()
+ return result
+ return tee_logdir_wrapper
def __mark(filename, msg):
- file = open(filename, 'a')
- file.write(msg)
- file.close()
+ file = open(filename, 'a')
+ file.write(msg)
+ file.close()
def tee_output_logdir_mark(fn):
- def tee_logdir_mark_wrapper(self, *args, **dargs):
- mark = self.__class__.__name__ + "." + fn.__name__
- outfile = os.path.join(self.log_dir, 'stdout')
- errfile = os.path.join(self.log_dir, 'stderr')
- __mark(outfile, "--- START " + mark + " ---\n")
- __mark(errfile, "--- START " + mark + " ---\n")
- self.job.stdout.tee_redirect(outfile)
- self.job.stderr.tee_redirect(errfile)
- try:
- result = fn(self, *args, **dargs)
- finally:
- self.job.stderr.restore()
- self.job.stdout.restore()
- __mark(outfile, "--- END " + mark + " ---\n")
- __mark(errfile, "--- END " + mark + " ---\n")
+ def tee_logdir_mark_wrapper(self, *args, **dargs):
+ mark = self.__class__.__name__ + "." + fn.__name__
+ outfile = os.path.join(self.log_dir, 'stdout')
+ errfile = os.path.join(self.log_dir, 'stderr')
+ __mark(outfile, "--- START " + mark + " ---\n")
+ __mark(errfile, "--- START " + mark + " ---\n")
+ self.job.stdout.tee_redirect(outfile)
+ self.job.stderr.tee_redirect(errfile)
+ try:
+ result = fn(self, *args, **dargs)
+ finally:
+ self.job.stderr.restore()
+ self.job.stdout.restore()
+ __mark(outfile, "--- END " + mark + " ---\n")
+ __mark(errfile, "--- END " + mark + " ---\n")
- return result
+ return result
- tee_logdir_mark_wrapper.__name__ = fn.__name__
- return tee_logdir_mark_wrapper
+ tee_logdir_mark_wrapper.__name__ = fn.__name__
+ return tee_logdir_mark_wrapper
diff --git a/client/bin/filesystem.py b/client/bin/filesystem.py
index 2c24141..47c8c44 100755
--- a/client/bin/filesystem.py
+++ b/client/bin/filesystem.py
@@ -5,170 +5,170 @@
from autotest_lib.client.common_lib import error, utils
def list_mount_devices():
- devices = []
- # list mounted filesystems
- for line in utils.system_output('mount').splitlines():
- devices.append(line.split()[0])
- # list mounted swap devices
- for line in utils.system_output('swapon -s').splitlines():
- if line.startswith('/'): # skip header line
- devices.append(line.split()[0])
- return devices
+ devices = []
+ # list mounted filesystems
+ for line in utils.system_output('mount').splitlines():
+ devices.append(line.split()[0])
+ # list mounted swap devices
+ for line in utils.system_output('swapon -s').splitlines():
+ if line.startswith('/'): # skip header line
+ devices.append(line.split()[0])
+ return devices
def list_mount_points():
- mountpoints = []
- for line in utils.system_output('mount').splitlines():
- mountpoints.append(line.split()[2])
- return mountpoints
+ mountpoints = []
+ for line in utils.system_output('mount').splitlines():
+ mountpoints.append(line.split()[2])
+ return mountpoints
class filesystem:
- """
- Class for handling filesystems
- """
+ """
+ Class for handling filesystems
+ """
- def __init__(self, job, device, mountpoint, loop_size = 0):
- """
- device should be able to be a file as well
- which we mount as loopback
+ def __init__(self, job, device, mountpoint, loop_size = 0):
+ """
+ device should be able to be a file as well
+ which we mount as loopback
- device
- The device in question (eg "/dev/hda2")
- mountpoint
- Default mountpoint for the device.
- loop_size
- size of loopback device (in MB)
- """
+ device
+ The device in question (eg "/dev/hda2")
+ mountpoint
+ Default mountpoint for the device.
+ loop_size
+ size of loopback device (in MB)
+ """
- part = re.compile(r'^part(\d+)$')
- m = part.match(device)
- if m:
- number = int(m.groups()[0])
- partitions = job.config_get('filesystem.partitions')
- try:
- device = partitions[number]
- except:
- raise NameError("Partition '" + device + "' not available")
+ part = re.compile(r'^part(\d+)$')
+ m = part.match(device)
+ if m:
+ number = int(m.groups()[0])
+ partitions = job.config_get('filesystem.partitions')
+ try:
+ device = partitions[number]
+ except:
+ raise NameError("Partition '" + device + "' not available")
- self.device = device
- self.mountpoint = mountpoint
- self.job = job
- self.fstype = None
- self.loop = loop_size
- if self.loop:
- utils.system('dd if=/dev/zero of=%s bs=1M count=%d' % \
- (device, loop_size))
+ self.device = device
+ self.mountpoint = mountpoint
+ self.job = job
+ self.fstype = None
+ self.loop = loop_size
+ if self.loop:
+ utils.system('dd if=/dev/zero of=%s bs=1M count=%d' % \
+ (device, loop_size))
- def mkfs(self, fstype = 'ext2', args = ''):
- """
- Format a partition to fstype
- """
- if list_mount_devices().count(self.device):
- raise NameError('Attempted to format mounted device')
- if fstype == 'xfs':
- args += ' -f'
- if self.loop:
- # BAH. Inconsistent mkfs syntax SUCKS.
- if fstype == 'ext2' or fstype == 'ext3':
- args += ' -F'
- if fstype == 'reiserfs':
- args += ' -f'
- args = args.lstrip()
- mkfs_cmd = "mkfs -t %s %s %s" % (fstype, args, self.device)
- print mkfs_cmd
- sys.stdout.flush()
- try:
- utils.system("yes | " + mkfs_cmd)
- except:
- self.job.record('FAIL', None, mkfs_cmd, error.format_error())
- raise
- else:
- self.job.record('GOOD', None, mkfs_cmd)
- self.fstype = fstype
+ def mkfs(self, fstype = 'ext2', args = ''):
+ """
+ Format a partition to fstype
+ """
+ if list_mount_devices().count(self.device):
+ raise NameError('Attempted to format mounted device')
+ if fstype == 'xfs':
+ args += ' -f'
+ if self.loop:
+ # BAH. Inconsistent mkfs syntax SUCKS.
+ if fstype == 'ext2' or fstype == 'ext3':
+ args += ' -F'
+ if fstype == 'reiserfs':
+ args += ' -f'
+ args = args.lstrip()
+ mkfs_cmd = "mkfs -t %s %s %s" % (fstype, args, self.device)
+ print mkfs_cmd
+ sys.stdout.flush()
+ try:
+ utils.system("yes | " + mkfs_cmd)
+ except:
+ self.job.record('FAIL', None, mkfs_cmd, error.format_error())
+ raise
+ else:
+ self.job.record('GOOD', None, mkfs_cmd)
+ self.fstype = fstype
- def fsck(self, args = '-n'):
- # I hate reiserfstools.
- # Requires an explit Yes for some inane reason
- fsck_cmd = 'fsck %s %s' % (self.device, args)
- if self.fstype == 'reiserfs':
- fsck_cmd = 'yes "Yes" | ' + fsck_cmd
- print fsck_cmd
- sys.stdout.flush()
- try:
- utils.system("yes | " + fsck_cmd)
- except:
- self.job.record('FAIL', None, fsck_cmd, error.format_error())
- raise
- else:
- self.job.record('GOOD', None, fsck_cmd)
-
-
- def mount(self, mountpoint = None, args = ''):
- if self.fstype:
- args += ' -t ' + self.fstype
- if self.loop:
- args += ' -o loop'
- args = args.lstrip()
-
- if not mountpoint:
- mountpoint = self.mountpoint
- mount_cmd = "mount %s %s %s" % (args, self.device, mountpoint)
-
- if list_mount_devices().count(self.device):
- err = 'Attempted to mount mounted device'
- self.job.record('FAIL', None, mount_cmd, err)
- raise NameError(err)
- if list_mount_points().count(mountpoint):
- err = 'Attempted to mount busy mountpoint'
- self.job.record('FAIL', None, mount_cmd, err)
- raise NameError(err)
-
- print mount_cmd
- sys.stdout.flush()
- try:
- utils.system(mount_cmd)
- except:
- self.job.record('FAIL', None, mount_cmd, error.format_error())
- raise
- else:
- self.job.record('GOOD', None, mount_cmd)
+ def fsck(self, args = '-n'):
+ # I hate reiserfstools.
+ # Requires an explit Yes for some inane reason
+ fsck_cmd = 'fsck %s %s' % (self.device, args)
+ if self.fstype == 'reiserfs':
+ fsck_cmd = 'yes "Yes" | ' + fsck_cmd
+ print fsck_cmd
+ sys.stdout.flush()
+ try:
+ utils.system("yes | " + fsck_cmd)
+ except:
+ self.job.record('FAIL', None, fsck_cmd, error.format_error())
+ raise
+ else:
+ self.job.record('GOOD', None, fsck_cmd)
- def unmount(self, handle=None):
- if not handle:
- handle = self.device
- umount_cmd = "umount " + handle
- print umount_cmd
- sys.stdout.flush()
- try:
- utils.system(umount_cmd)
- except:
- self.job.record('FAIL', None, umount_cmd, error.format_error())
- raise
- else:
- self.job.record('GOOD', None, umount_cmd)
+ def mount(self, mountpoint = None, args = ''):
+ if self.fstype:
+ args += ' -t ' + self.fstype
+ if self.loop:
+ args += ' -o loop'
+ args = args.lstrip()
+
+ if not mountpoint:
+ mountpoint = self.mountpoint
+ mount_cmd = "mount %s %s %s" % (args, self.device, mountpoint)
+
+ if list_mount_devices().count(self.device):
+ err = 'Attempted to mount mounted device'
+ self.job.record('FAIL', None, mount_cmd, err)
+ raise NameError(err)
+ if list_mount_points().count(mountpoint):
+ err = 'Attempted to mount busy mountpoint'
+ self.job.record('FAIL', None, mount_cmd, err)
+ raise NameError(err)
+
+ print mount_cmd
+ sys.stdout.flush()
+ try:
+ utils.system(mount_cmd)
+ except:
+ self.job.record('FAIL', None, mount_cmd, error.format_error())
+ raise
+ else:
+ self.job.record('GOOD', None, mount_cmd)
- def get_io_scheduler_list(self, device_name):
- names = open(self.__sched_path(device_name)).read()
- return names.translate(string.maketrans('[]', ' ')).split()
+ def unmount(self, handle=None):
+ if not handle:
+ handle = self.device
+ umount_cmd = "umount " + handle
+ print umount_cmd
+ sys.stdout.flush()
+ try:
+ utils.system(umount_cmd)
+ except:
+ self.job.record('FAIL', None, umount_cmd, error.format_error())
+ raise
+ else:
+ self.job.record('GOOD', None, umount_cmd)
- def get_io_scheduler(self, device_name):
- return re.split('[\[\]]',
- open(self.__sched_path(device_name)).read())[1]
+ def get_io_scheduler_list(self, device_name):
+ names = open(self.__sched_path(device_name)).read()
+ return names.translate(string.maketrans('[]', ' ')).split()
- def set_io_scheduler(self, device_name, name):
- if name not in self.get_io_scheduler_list(device_name):
- raise NameError('No such IO scheduler: %s' % name)
- f = open(self.__sched_path(device_name), 'w')
- print >> f, name
- f.close()
+ def get_io_scheduler(self, device_name):
+ return re.split('[\[\]]',
+ open(self.__sched_path(device_name)).read())[1]
- def __sched_path(self, device_name):
- return '/sys/block/%s/queue/scheduler' % device_name
+ def set_io_scheduler(self, device_name, name):
+ if name not in self.get_io_scheduler_list(device_name):
+ raise NameError('No such IO scheduler: %s' % name)
+ f = open(self.__sched_path(device_name), 'w')
+ print >> f, name
+ f.close()
+
+
+ def __sched_path(self, device_name):
+ return '/sys/block/%s/queue/scheduler' % device_name
diff --git a/client/bin/grub.py b/client/bin/grub.py
index 68b9bc5..81ea3de 100755
--- a/client/bin/grub.py
+++ b/client/bin/grub.py
@@ -4,139 +4,139 @@
import shutil
import re
-import os
+import os
import os.path
import string
class grub:
- config_locations = ['/boot/grub/grub.conf', '/boot/grub/menu.lst',
- '/etc/grub.conf']
+ config_locations = ['/boot/grub/grub.conf', '/boot/grub/menu.lst',
+ '/etc/grub.conf']
- def __init__(self, config_file=None):
- if config_file:
- self.config = config_file
- else:
- self.config = self.detect()
- self.read()
+ def __init__(self, config_file=None):
+ if config_file:
+ self.config = config_file
+ else:
+ self.config = self.detect()
+ self.read()
- def read(self):
- conf_file = file(self.config, 'r')
- self.lines = conf_file.readlines()
- conf_file.close()
+ def read(self):
+ conf_file = file(self.config, 'r')
+ self.lines = conf_file.readlines()
+ conf_file.close()
- self.entries = [] # list of stanzas
- self.titles = {} # dictionary of titles
- entry = grub_entry(-1)
- count = 0
- for line in self.lines:
- if re.match(r'\s*title', line):
- self.entries.append(entry)
- entry = grub_entry(count)
- count = count + 1
- title = line.replace('title ', '')
- title = title.rstrip('\n')
- entry.set('title', title)
- self.titles[title] = entry
- # if line.startswith('initrd'):
- if re.match(r'\s*initrd', line):
- entry.set('initrd',
- re.sub(r'\s*initrd\s+', '', line))
- if re.match(r'\s*kernel', line):
- entry.set('kernel',
- re.sub(r'\s*kernel\s+', '', line))
- entry.lines.append(line)
- self.entries.append(entry)
- self.preamble = self.entries.pop(0) # separate preamble
+ self.entries = [] # list of stanzas
+ self.titles = {} # dictionary of titles
+ entry = grub_entry(-1)
+ count = 0
+ for line in self.lines:
+ if re.match(r'\s*title', line):
+ self.entries.append(entry)
+ entry = grub_entry(count)
+ count = count + 1
+ title = line.replace('title ', '')
+ title = title.rstrip('\n')
+ entry.set('title', title)
+ self.titles[title] = entry
+ # if line.startswith('initrd'):
+ if re.match(r'\s*initrd', line):
+ entry.set('initrd',
+ re.sub(r'\s*initrd\s+', '', line))
+ if re.match(r'\s*kernel', line):
+ entry.set('kernel',
+ re.sub(r'\s*kernel\s+', '', line))
+ entry.lines.append(line)
+ self.entries.append(entry)
+ self.preamble = self.entries.pop(0) # separate preamble
- def write(self):
- conf_file = file(self.config, 'w')
- conf_file.write(self.preamble)
- for entry in self.entries:
- conf_file.write(entry.lines)
- conf_file.close()
+ def write(self):
+ conf_file = file(self.config, 'w')
+ conf_file.write(self.preamble)
+ for entry in self.entries:
+ conf_file.write(entry.lines)
+ conf_file.close()
- def dump(self):
- for line in self.preamble.lines:
- print line,
- for entry in self.entries:
- for line in entry.lines:
- print line,
+ def dump(self):
+ for line in self.preamble.lines:
+ print line,
+ for entry in self.entries:
+ for line in entry.lines:
+ print line,
- def backup(self):
- shutil.copyfile(self.config, self.config+'.bak')
- restore = file(autodir + '/var/autotest.boot.restore', 'w')
- restore.write('cp ' + self.config+'.bak ' + self.config + '\n')
- restore.close()
+ def backup(self):
+ shutil.copyfile(self.config, self.config+'.bak')
+ restore = file(autodir + '/var/autotest.boot.restore', 'w')
+ restore.write('cp ' + self.config+'.bak ' + self.config + '\n')
+ restore.close()
- def bootloader(self):
- return 'grub'
+ def bootloader(self):
+ return 'grub'
- def detect(self):
- for config in grub.config_locations:
- if os.path.isfile(config) and not os.path.islink(config):
- return config
+ def detect(self):
+ for config in grub.config_locations:
+ if os.path.isfile(config) and not os.path.islink(config):
+ return config
- def list_titles(self):
- list = []
- for entry in self.entries:
- list.append(entry.get('title'))
- return list
+ def list_titles(self):
+ list = []
+ for entry in self.entries:
+ list.append(entry.get('title'))
+ return list
- def print_entry(self, index):
- entry = self.entries[index]
- entry.print_entry()
+ def print_entry(self, index):
+ entry = self.entries[index]
+ entry.print_entry()
- def renamed_entry(self, index, newname, args=False):
- "print a specified entry, renaming it as specified"
- entry = self.entries[index]
- entry.set('title', newname)
- if args:
- entry.set_autotest_kernel()
- entry.print_entry()
+ def renamed_entry(self, index, newname, args=False):
+ "print a specified entry, renaming it as specified"
+ entry = self.entries[index]
+ entry.set('title', newname)
+ if args:
+ entry.set_autotest_kernel()
+ entry.print_entry()
- def omit_markers(self, marker):
- # print, ommitting entries between specified markers
- print_state = True
- for line in lines:
- if line.count(marker):
- print_state = not print_state
- else:
- if print_state:
- print line
+ def omit_markers(self, marker):
+ # print, ommitting entries between specified markers
+ print_state = True
+ for line in lines:
+ if line.count(marker):
+ print_state = not print_state
+ else:
+ if print_state:
+ print line
- def select(self, title, boot_options=None):
- entry = self.titles[title]
- print "grub: will boot entry %d (0-based)" % entry.index
- self.set_default(entry.index)
- self.set_timeout()
+ def select(self, title, boot_options=None):
+ entry = self.titles[title]
+ print "grub: will boot entry %d (0-based)" % entry.index
+ self.set_default(entry.index)
+ self.set_timeout()
- def set_default(self, index):
- lines = (self.preamble).lines
- for i in range(len(lines)):
- default = 'default %d' % index
- lines[i] = re.sub(r'^\s*default.*',
- default, lines[i])
+ def set_default(self, index):
+ lines = (self.preamble).lines
+ for i in range(len(lines)):
+ default = 'default %d' % index
+ lines[i] = re.sub(r'^\s*default.*',
+ default, lines[i])
- def set_timeout(self):
- lines = (self.preamble).lines
- for i in range(len(lines)):
- lines[i] = re.sub(r'^timeout.*/',
- 'timeout 60', lines[i])
- lines[i] = re.sub(r'^(\s*terminal .*--timeout)=\d+',
- r'\1=30', lines[i])
-
+ def set_timeout(self):
+ lines = (self.preamble).lines
+ for i in range(len(lines)):
+ lines[i] = re.sub(r'^timeout.*/',
+ 'timeout 60', lines[i])
+ lines[i] = re.sub(r'^(\s*terminal .*--timeout)=\d+',
+ r'\1=30', lines[i])
+
# ----------------------------------------------------------------------
@@ -145,49 +145,49 @@
# and bits we don't understand.
class grub_entry:
- def __init__(self, count):
- self.lines = []
- self.fields = {} # title, initrd, kernel, etc
- self.index = count
+ def __init__(self, count):
+ self.lines = []
+ self.fields = {} # title, initrd, kernel, etc
+ self.index = count
- def set(self, field, value):
- print "setting '%s' to '%s'" % (field, value)
- self.fields[field] = value
- for i in range(len(self.lines)):
- m = re.match(r'\s*' + field + r'\s+', self.lines[i])
- if m:
- self.lines[i] = m.group() + value + '\n'
+ def set(self, field, value):
+ print "setting '%s' to '%s'" % (field, value)
+ self.fields[field] = value
+ for i in range(len(self.lines)):
+ m = re.match(r'\s*' + field + r'\s+', self.lines[i])
+ if m:
+ self.lines[i] = m.group() + value + '\n'
- def get(self, field):
- return self.fields[field]
+ def get(self, field):
+ return self.fields[field]
- def print_entry(self):
- print self.lines
+ def print_entry(self):
+ print self.lines
- def set_kernel_options(self, options):
- kernel = self.get('kernel')
- re.sub(r'(autotest_args:).*', r'\1'+options, kernel)
- self.set('kernel', kernel)
+ def set_kernel_options(self, options):
+ kernel = self.get('kernel')
+ re.sub(r'(autotest_args:).*', r'\1'+options, kernel)
+ self.set('kernel', kernel)
- def set_autotest_kernel(self):
- kernel_words = []
- found_path = False
- # Want to copy most of the entry, replacing the 'path'
- # part of the entry with vmlinux-autotest in the same
- # dir, and make sure autotest_args: is (uniquely) added
- for word in (self.get('kernel')).split():
- if word.startswith('--'):
- kernel_words.append(word)
- continue
- if not found_path:
- word = os.path.dirname(word)+'vmlinuz-autotest'
- found_path = True
- if re.match(r'auto(bench|test)_args:', word):
- break
- kernel_words.append(word)
- kernel_words.append('autotest_args: ')
- self.set('kernel', string.join(kernel_words))
+ def set_autotest_kernel(self):
+ kernel_words = []
+ found_path = False
+ # Want to copy most of the entry, replacing the 'path'
+ # part of the entry with vmlinux-autotest in the same
+ # dir, and make sure autotest_args: is (uniquely) added
+ for word in (self.get('kernel')).split():
+ if word.startswith('--'):
+ kernel_words.append(word)
+ continue
+ if not found_path:
+ word = os.path.dirname(word)+'vmlinuz-autotest'
+ found_path = True
+ if re.match(r'auto(bench|test)_args:', word):
+ break
+ kernel_words.append(word)
+ kernel_words.append('autotest_args: ')
+ self.set('kernel', string.join(kernel_words))
diff --git a/client/bin/harness.py b/client/bin/harness.py
index 2a6378f..86441b8 100755
--- a/client/bin/harness.py
+++ b/client/bin/harness.py
@@ -8,77 +8,77 @@
import os, sys
class harness:
- """The NULL server harness
+ """The NULL server harness
- Properties:
- job
- The job object for this job
- """
+ Properties:
+ job
+ The job object for this job
+ """
- def __init__(self, job):
- """
- job
- The job object for this job
- """
- self.setup(job)
+ def __init__(self, job):
+ """
+ job
+ The job object for this job
+ """
+ self.setup(job)
- def setup(self, job):
- """
- job
- The job object for this job
- """
- self.job = job
+ def setup(self, job):
+ """
+ job
+ The job object for this job
+ """
+ self.job = job
- configd = os.path.join(os.environ['AUTODIR'], 'configs')
- if os.path.isdir(configd):
- (name, dirs, files) = os.walk(configd).next()
- job.config_set('kernel.default_config_set',
- [ configd + '/' ] + files)
+ configd = os.path.join(os.environ['AUTODIR'], 'configs')
+ if os.path.isdir(configd):
+ (name, dirs, files) = os.walk(configd).next()
+ job.config_set('kernel.default_config_set',
+ [ configd + '/' ] + files)
- def run_start(self):
- """A run within this job is starting"""
- pass
+ def run_start(self):
+ """A run within this job is starting"""
+ pass
- def run_pause(self):
- """A run within this job is completing (expect continue)"""
- pass
+ def run_pause(self):
+ """A run within this job is completing (expect continue)"""
+ pass
- def run_reboot(self):
- """A run within this job is performing a reboot
- (expect continue following reboot)
- """
- pass
+ def run_reboot(self):
+ """A run within this job is performing a reboot
+ (expect continue following reboot)
+ """
+ pass
- def run_abort(self):
- """A run within this job is aborting. It all went wrong"""
- pass
+ def run_abort(self):
+ """A run within this job is aborting. It all went wrong"""
+ pass
- def run_complete(self):
- """A run within this job is completing (all done)"""
- pass
+ def run_complete(self):
+ """A run within this job is completing (all done)"""
+ pass
- def test_status(self, status, tag):
- """A test within this job is completing"""
- pass
+ def test_status(self, status, tag):
+ """A test within this job is completing"""
+ pass
- def test_status_detail(self, code, subdir, operation, status, tag):
- """A test within this job is completing (detail)"""
- pass
+ def test_status_detail(self, code, subdir, operation, status, tag):
+ """A test within this job is completing (detail)"""
+ pass
def select(which, job):
- if not which:
- which = 'standalone'
-
- exec "import harness_%s" % (which)
- exec "myharness = harness_%s.harness_%s(job)" % (which, which)
+ if not which:
+ which = 'standalone'
- return myharness
+ exec "import harness_%s" % (which)
+ exec "myharness = harness_%s.harness_%s(job)" % (which, which)
+
+ return myharness
diff --git a/client/bin/harness_ABAT.py b/client/bin/harness_ABAT.py
index e5f2f63..8fadb2a 100755
--- a/client/bin/harness_ABAT.py
+++ b/client/bin/harness_ABAT.py
@@ -10,145 +10,145 @@
import os, harness, time, re
def autobench_load(fn):
- disks = re.compile(r'^\s*DATS_FREE_DISKS\s*=(.*\S)\s*$')
- parts = re.compile(r'^\s*DATS_FREE_PARTITIONS\s*=(.*\S)\s*$')
- modules = re.compile(r'^\s*INITRD_MODULES\s*=(.*\S)\s*$')
+ disks = re.compile(r'^\s*DATS_FREE_DISKS\s*=(.*\S)\s*$')
+ parts = re.compile(r'^\s*DATS_FREE_PARTITIONS\s*=(.*\S)\s*$')
+ modules = re.compile(r'^\s*INITRD_MODULES\s*=(.*\S)\s*$')
- conf = {}
+ conf = {}
- try:
- fd = file(fn, "r")
- except:
- return conf
- for ln in fd.readlines():
- m = disks.match(ln)
- if m:
- val = m.groups()[0]
- conf['disks'] = val.strip('"').split()
- m = parts.match(ln)
- if m:
- val = m.groups()[0]
- conf['partitions'] = val.strip('"').split()
- m = modules.match(ln)
- if m:
- val = m.groups()[0]
- conf['modules'] = val.strip('"').split()
- fd.close()
+ try:
+ fd = file(fn, "r")
+ except:
+ return conf
+ for ln in fd.readlines():
+ m = disks.match(ln)
+ if m:
+ val = m.groups()[0]
+ conf['disks'] = val.strip('"').split()
+ m = parts.match(ln)
+ if m:
+ val = m.groups()[0]
+ conf['partitions'] = val.strip('"').split()
+ m = modules.match(ln)
+ if m:
+ val = m.groups()[0]
+ conf['modules'] = val.strip('"').split()
+ fd.close()
- return conf
+ return conf
class harness_ABAT(harness.harness):
- """The ABAT server harness
+ """The ABAT server harness
- Properties:
- job
- The job object for this job
- """
+ Properties:
+ job
+ The job object for this job
+ """
- def __init__(self, job):
- """
- job
- The job object for this job
- """
- self.setup(job)
+ def __init__(self, job):
+ """
+ job
+ The job object for this job
+ """
+ self.setup(job)
- if 'ABAT_STATUS' in os.environ:
- self.status = file(os.environ['ABAT_STATUS'], "w")
- else:
- self.status = None
+ if 'ABAT_STATUS' in os.environ:
+ self.status = file(os.environ['ABAT_STATUS'], "w")
+ else:
+ self.status = None
- def __send(self, msg):
- if self.status:
- msg = msg.rstrip()
- self.status.write(msg + "\n")
- self.status.flush()
+ def __send(self, msg):
+ if self.status:
+ msg = msg.rstrip()
+ self.status.write(msg + "\n")
+ self.status.flush()
- def __send_status(self, code, subdir, operation, msg):
- self.__send("STATUS %s %s %s %s" % \
- (code, subdir, operation, msg))
+ def __send_status(self, code, subdir, operation, msg):
+ self.__send("STATUS %s %s %s %s" % \
+ (code, subdir, operation, msg))
- def __root_device(self):
- device = None
- root = re.compile(r'^\S*(/dev/\S+).*\s/\s*$')
-
- df = utils.system_output('df -lP')
- for line in df.split("\n"):
- m = root.match(line)
- if m:
- device = m.groups()[0]
+ def __root_device(self):
+ device = None
+ root = re.compile(r'^\S*(/dev/\S+).*\s/\s*$')
- return device
+ df = utils.system_output('df -lP')
+ for line in df.split("\n"):
+ m = root.match(line)
+ if m:
+ device = m.groups()[0]
+
+ return device
- def run_start(self):
- """A run within this job is starting"""
- self.__send_status('GOOD', '----', '----', 'run starting')
+ def run_start(self):
+ """A run within this job is starting"""
+ self.__send_status('GOOD', '----', '----', 'run starting')
- # Load up the autobench.conf if it exists.
- conf = autobench_load("/etc/autobench.conf")
- if 'partitions' in conf:
- self.job.config_set('filesystem.partitions',
- conf['partitions'])
+ # Load up the autobench.conf if it exists.
+ conf = autobench_load("/etc/autobench.conf")
+ if 'partitions' in conf:
+ self.job.config_set('filesystem.partitions',
+ conf['partitions'])
- # Search the boot loader configuration for the autobench entry,
- # and extract its args.
- entry_args = None
- args = None
- for line in self.job.bootloader.info('all').split('\n'):
- if line.startswith('args'):
- entry_args = line.split(None, 2)[2]
- if line.startswith('title'):
- title = line.split()[2]
- if title == 'autobench':
- args = entry_args
+ # Search the boot loader configuration for the autobench entry,
+ # and extract its args.
+ entry_args = None
+ args = None
+ for line in self.job.bootloader.info('all').split('\n'):
+ if line.startswith('args'):
+ entry_args = line.split(None, 2)[2]
+ if line.startswith('title'):
+ title = line.split()[2]
+ if title == 'autobench':
+ args = entry_args
- if args:
- args = re.sub(r'autobench_args:.*', '', args)
- args = re.sub(r'root=\S*', '', args)
- args += " root=" + self.__root_device()
+ if args:
+ args = re.sub(r'autobench_args:.*', '', args)
+ args = re.sub(r'root=\S*', '', args)
+ args += " root=" + self.__root_device()
- self.job.config_set('boot.default_args', args)
+ self.job.config_set('boot.default_args', args)
- # Turn off boot_once semantics.
- self.job.config_set('boot.set_default', True)
+ # Turn off boot_once semantics.
+ self.job.config_set('boot.set_default', True)
- # For RedHat installs we do not load up the module.conf
- # as they cannot be builtin. Pass them as arguments.
- vendor = autotest_utils.get_os_vendor()
- if vendor in ['Red Hat', 'Fedora Core'] and 'modules' in conf:
- args = '--allow-missing'
- for mod in conf['modules']:
- args += " --with " + mod
- self.job.config_set('kernel.mkinitrd_extra_args', args)
+ # For RedHat installs we do not load up the module.conf
+ # as they cannot be builtin. Pass them as arguments.
+ vendor = autotest_utils.get_os_vendor()
+ if vendor in ['Red Hat', 'Fedora Core'] and 'modules' in conf:
+ args = '--allow-missing'
+ for mod in conf['modules']:
+ args += " --with " + mod
+ self.job.config_set('kernel.mkinitrd_extra_args', args)
- def run_reboot(self):
- """A run within this job is performing a reboot
- (expect continue following reboot)
- """
- self.__send("REBOOT")
+ def run_reboot(self):
+ """A run within this job is performing a reboot
+ (expect continue following reboot)
+ """
+ self.__send("REBOOT")
- def run_complete(self):
- """A run within this job is completing (all done)"""
- self.__send("DONE")
+ def run_complete(self):
+ """A run within this job is completing (all done)"""
+ self.__send("DONE")
- def test_status_detail(self, code, subdir, operation, msg, tag):
- """A test within this job is completing (detail)"""
+ def test_status_detail(self, code, subdir, operation, msg, tag):
+ """A test within this job is completing (detail)"""
- # Send the first line with the status code as a STATUS message.
- lines = msg.split("\n")
- self.__send_status(code, subdir, operation, lines[0])
+ # Send the first line with the status code as a STATUS message.
+ lines = msg.split("\n")
+ self.__send_status(code, subdir, operation, lines[0])
- def test_status(self, msg, tag):
- lines = msg.split("\n")
+ def test_status(self, msg, tag):
+ lines = msg.split("\n")
- # Send each line as a SUMMARY message.
- for line in lines:
- self.__send("SUMMARY :" + line)
+ # Send each line as a SUMMARY message.
+ for line in lines:
+ self.__send("SUMMARY :" + line)
diff --git a/client/bin/harness_simple.py b/client/bin/harness_simple.py
index 7f104da..5ff90d4 100755
--- a/client/bin/harness_simple.py
+++ b/client/bin/harness_simple.py
@@ -7,31 +7,31 @@
import os, harness, time
class harness_simple(harness.harness):
- """
- The simple server harness
+ """
+ The simple server harness
- Properties:
- job
- The job object for this job
- """
+ Properties:
+ job
+ The job object for this job
+ """
- def __init__(self, job):
- """
- job
- The job object for this job
- """
- self.setup(job)
+ def __init__(self, job):
+ """
+ job
+ The job object for this job
+ """
+ self.setup(job)
- self.status = os.fdopen(3, 'w')
+ self.status = os.fdopen(3, 'w')
- def test_status(self, status, tag):
- """A test within this job is completing"""
- if self.status:
- for line in status.split('\n'):
- # prepend status messages with
- # AUTOTEST_STATUS:tag: so that we can tell
- # which lines were sent by the autotest client
- pre = 'AUTOTEST_STATUS:%s:' % (tag,)
- self.status.write(pre + line + '\n')
- self.status.flush()
+ def test_status(self, status, tag):
+ """A test within this job is completing"""
+ if self.status:
+ for line in status.split('\n'):
+ # prepend status messages with
+ # AUTOTEST_STATUS:tag: so that we can tell
+ # which lines were sent by the autotest client
+ pre = 'AUTOTEST_STATUS:%s:' % (tag,)
+ self.status.write(pre + line + '\n')
+ self.status.flush()
diff --git a/client/bin/harness_standalone.py b/client/bin/harness_standalone.py
index dccdcab..d6a4687 100644
--- a/client/bin/harness_standalone.py
+++ b/client/bin/harness_standalone.py
@@ -9,40 +9,40 @@
import os, harness, shutil
class harness_standalone(harness.harness):
- """The standalone server harness
+ """The standalone server harness
- Properties:
- job
- The job object for this job
- """
+ Properties:
+ job
+ The job object for this job
+ """
- def __init__(self, job):
- """
- job
- The job object for this job
- """
- self.autodir = os.path.abspath(os.environ['AUTODIR'])
- self.setup(job)
+ def __init__(self, job):
+ """
+ job
+ The job object for this job
+ """
+ self.autodir = os.path.abspath(os.environ['AUTODIR'])
+ self.setup(job)
- src = job.control_get()
- dest = os.path.join(self.autodir, 'control')
- if os.path.abspath(src) != os.path.abspath(dest):
- shutil.copyfile(src, dest)
- job.control_set(dest)
+ src = job.control_get()
+ dest = os.path.join(self.autodir, 'control')
+ if os.path.abspath(src) != os.path.abspath(dest):
+ shutil.copyfile(src, dest)
+ job.control_set(dest)
- print 'Symlinking init scripts'
- rc = os.path.join(self.autodir, 'tools/autotest')
- # see if system supports event.d versus inittab
- if os.path.exists('/etc/event.d'):
- # NB: assuming current runlevel is default
- initdefault = utils.system_output('runlevel').split()[1]
- else:
- initdefault = utils.system_output('grep :initdefault: /etc/inittab')
- initdefault = initdefault.split(':')[1]
+ print 'Symlinking init scripts'
+ rc = os.path.join(self.autodir, 'tools/autotest')
+ # see if system supports event.d versus inittab
+ if os.path.exists('/etc/event.d'):
+ # NB: assuming current runlevel is default
+ initdefault = utils.system_output('runlevel').split()[1]
+ else:
+ initdefault = utils.system_output('grep :initdefault: /etc/inittab')
+ initdefault = initdefault.split(':')[1]
- try:
- utils.system('ln -sf %s /etc/init.d/autotest' % rc)
- utils.system('ln -sf %s /etc/rc%s.d/S99autotest' % \
- (rc, initdefault))
- except:
- print "WARNING: linking init scripts failed"
+ try:
+ utils.system('ln -sf %s /etc/init.d/autotest' % rc)
+ utils.system('ln -sf %s /etc/rc%s.d/S99autotest' % \
+ (rc, initdefault))
+ except:
+ print "WARNING: linking init scripts failed"
diff --git a/client/bin/job.py b/client/bin/job.py
index ac2745b..870b63e 100755
--- a/client/bin/job.py
+++ b/client/bin/job.py
@@ -20,995 +20,995 @@
"""
class StepError(error.AutotestError):
- pass
+ pass
class base_job:
- """The actual job against which we do everything.
+ """The actual job against which we do everything.
- Properties:
- autodir
- The top level autotest directory (/usr/local/autotest).
- Comes from os.environ['AUTODIR'].
- bindir
- <autodir>/bin/
- libdir
- <autodir>/lib/
- testdir
- <autodir>/tests/
- site_testdir
- <autodir>/site_tests/
- profdir
- <autodir>/profilers/
- tmpdir
- <autodir>/tmp/
- resultdir
- <autodir>/results/<jobtag>
- stdout
- fd_stack object for stdout
- stderr
- fd_stack object for stderr
- profilers
- the profilers object for this job
- harness
- the server harness object for this job
- config
- the job configuration for this job
- """
+ Properties:
+ autodir
+ The top level autotest directory (/usr/local/autotest).
+ Comes from os.environ['AUTODIR'].
+ bindir
+ <autodir>/bin/
+ libdir
+ <autodir>/lib/
+ testdir
+ <autodir>/tests/
+ site_testdir
+ <autodir>/site_tests/
+ profdir
+ <autodir>/profilers/
+ tmpdir
+ <autodir>/tmp/
+ resultdir
+ <autodir>/results/<jobtag>
+ stdout
+ fd_stack object for stdout
+ stderr
+ fd_stack object for stderr
+ profilers
+ the profilers object for this job
+ harness
+ the server harness object for this job
+ config
+ the job configuration for this job
+ """
- DEFAULT_LOG_FILENAME = "status"
+ DEFAULT_LOG_FILENAME = "status"
- def __init__(self, control, jobtag, cont, harness_type=None,
- use_external_logging = False):
- """
- control
- The control file (pathname of)
- jobtag
- The job tag string (eg "default")
- cont
- If this is the continuation of this job
- harness_type
- An alternative server harness
- """
- self.autodir = os.environ['AUTODIR']
- self.bindir = os.path.join(self.autodir, 'bin')
- self.libdir = os.path.join(self.autodir, 'lib')
- self.testdir = os.path.join(self.autodir, 'tests')
- self.site_testdir = os.path.join(self.autodir, 'site_tests')
- self.profdir = os.path.join(self.autodir, 'profilers')
- self.tmpdir = os.path.join(self.autodir, 'tmp')
- self.resultdir = os.path.join(self.autodir, 'results', jobtag)
- self.sysinfodir = os.path.join(self.resultdir, 'sysinfo')
- self.control = os.path.abspath(control)
- self.state_file = self.control + '.state'
- self.current_step_ancestry = []
- self.next_step_index = 0
- self.__load_state()
+ def __init__(self, control, jobtag, cont, harness_type=None,
+ use_external_logging = False):
+ """
+ control
+ The control file (pathname of)
+ jobtag
+ The job tag string (eg "default")
+ cont
+ If this is the continuation of this job
+ harness_type
+ An alternative server harness
+ """
+ self.autodir = os.environ['AUTODIR']
+ self.bindir = os.path.join(self.autodir, 'bin')
+ self.libdir = os.path.join(self.autodir, 'lib')
+ self.testdir = os.path.join(self.autodir, 'tests')
+ self.site_testdir = os.path.join(self.autodir, 'site_tests')
+ self.profdir = os.path.join(self.autodir, 'profilers')
+ self.tmpdir = os.path.join(self.autodir, 'tmp')
+ self.resultdir = os.path.join(self.autodir, 'results', jobtag)
+ self.sysinfodir = os.path.join(self.resultdir, 'sysinfo')
+ self.control = os.path.abspath(control)
+ self.state_file = self.control + '.state'
+ self.current_step_ancestry = []
+ self.next_step_index = 0
+ self.__load_state()
- if not cont:
- """
- Don't cleanup the tmp dir (which contains the lockfile)
- in the constructor, this would be a problem for multiple
- jobs starting at the same time on the same client. Instead
- do the delete at the server side. We simply create the tmp
- directory here if it does not already exist.
- """
- if not os.path.exists(self.tmpdir):
- os.mkdir(self.tmpdir)
+ if not cont:
+ """
+ Don't cleanup the tmp dir (which contains the lockfile)
+ in the constructor, this would be a problem for multiple
+ jobs starting at the same time on the same client. Instead
+ do the delete at the server side. We simply create the tmp
+ directory here if it does not already exist.
+ """
+ if not os.path.exists(self.tmpdir):
+ os.mkdir(self.tmpdir)
- results = os.path.join(self.autodir, 'results')
- if not os.path.exists(results):
- os.mkdir(results)
-
- download = os.path.join(self.testdir, 'download')
- if not os.path.exists(download):
- os.mkdir(download)
+ results = os.path.join(self.autodir, 'results')
+ if not os.path.exists(results):
+ os.mkdir(results)
- if os.path.exists(self.resultdir):
- utils.system('rm -rf '
- + self.resultdir)
- os.mkdir(self.resultdir)
- os.mkdir(self.sysinfodir)
+ download = os.path.join(self.testdir, 'download')
+ if not os.path.exists(download):
+ os.mkdir(download)
- os.mkdir(os.path.join(self.resultdir, 'debug'))
- os.mkdir(os.path.join(self.resultdir, 'analysis'))
+ if os.path.exists(self.resultdir):
+ utils.system('rm -rf '
+ + self.resultdir)
+ os.mkdir(self.resultdir)
+ os.mkdir(self.sysinfodir)
- shutil.copyfile(self.control,
- os.path.join(self.resultdir, 'control'))
+ os.mkdir(os.path.join(self.resultdir, 'debug'))
+ os.mkdir(os.path.join(self.resultdir, 'analysis'))
+ shutil.copyfile(self.control,
+ os.path.join(self.resultdir, 'control'))
- self.control = control
- self.jobtag = jobtag
- self.log_filename = self.DEFAULT_LOG_FILENAME
- self.container = None
- self.stdout = fd_stack.fd_stack(1, sys.stdout)
- self.stderr = fd_stack.fd_stack(2, sys.stderr)
+ self.control = control
+ self.jobtag = jobtag
+ self.log_filename = self.DEFAULT_LOG_FILENAME
+ self.container = None
- self._init_group_level()
+ self.stdout = fd_stack.fd_stack(1, sys.stdout)
+ self.stderr = fd_stack.fd_stack(2, sys.stderr)
- self.config = config.config(self)
+ self._init_group_level()
- self.harness = harness.select(harness_type, self)
+ self.config = config.config(self)
- self.profilers = profilers.profilers(self)
+ self.harness = harness.select(harness_type, self)
- try:
- tool = self.config_get('boottool.executable')
- self.bootloader = boottool.boottool(tool)
- except:
- pass
+ self.profilers = profilers.profilers(self)
- sysinfo.log_per_reboot_data(self.sysinfodir)
+ try:
+ tool = self.config_get('boottool.executable')
+ self.bootloader = boottool.boottool(tool)
+ except:
+ pass
- if not cont:
- self.record('START', None, None)
- self._increment_group_level()
+ sysinfo.log_per_reboot_data(self.sysinfodir)
- self.harness.run_start()
-
- if use_external_logging:
- self.enable_external_logging()
+ if not cont:
+ self.record('START', None, None)
+ self._increment_group_level()
- # load the max disk usage rate - default to no monitoring
- self.max_disk_usage_rate = self.get_state('__monitor_disk',
- default=0.0)
+ self.harness.run_start()
+ if use_external_logging:
+ self.enable_external_logging()
- def monitor_disk_usage(self, max_rate):
- """\
- Signal that the job should monitor disk space usage on /
- and generate a warning if a test uses up disk space at a
- rate exceeding 'max_rate'.
+ # load the max disk usage rate - default to no monitoring
+ self.max_disk_usage_rate = self.get_state('__monitor_disk',
+ default=0.0)
- Parameters:
- max_rate - the maximium allowed rate of disk consumption
- during a test, in MB/hour, or 0 to indicate
- no limit.
- """
- self.set_state('__monitor_disk', max_rate)
- self.max_disk_usage_rate = max_rate
+ def monitor_disk_usage(self, max_rate):
+ """\
+ Signal that the job should monitor disk space usage on /
+ and generate a warning if a test uses up disk space at a
+ rate exceeding 'max_rate'.
- def relative_path(self, path):
- """\
- Return a patch relative to the job results directory
- """
- head = len(self.resultdir) + 1 # remove the / inbetween
- return path[head:]
+ Parameters:
+ max_rate - the maximium allowed rate of disk consumption
+ during a test, in MB/hour, or 0 to indicate
+ no limit.
+ """
+ self.set_state('__monitor_disk', max_rate)
+ self.max_disk_usage_rate = max_rate
- def control_get(self):
- return self.control
+ def relative_path(self, path):
+ """\
+ Return a patch relative to the job results directory
+ """
+ head = len(self.resultdir) + 1 # remove the / inbetween
+ return path[head:]
- def control_set(self, control):
- self.control = os.path.abspath(control)
+ def control_get(self):
+ return self.control
- def harness_select(self, which):
- self.harness = harness.select(which, self)
+ def control_set(self, control):
+ self.control = os.path.abspath(control)
- def config_set(self, name, value):
- self.config.set(name, value)
+ def harness_select(self, which):
+ self.harness = harness.select(which, self)
- def config_get(self, name):
- return self.config.get(name)
+ def config_set(self, name, value):
+ self.config.set(name, value)
- def setup_dirs(self, results_dir, tmp_dir):
- if not tmp_dir:
- tmp_dir = os.path.join(self.tmpdir, 'build')
- if not os.path.exists(tmp_dir):
- os.mkdir(tmp_dir)
- if not os.path.isdir(tmp_dir):
- e_msg = "Temp dir (%s) is not a dir - args backwards?" % self.tmpdir
- raise ValueError(e_msg)
- # We label the first build "build" and then subsequent ones
- # as "build.2", "build.3", etc. Whilst this is a little bit
- # inconsistent, 99.9% of jobs will only have one build
- # (that's not done as kernbench, sparse, or buildtest),
- # so it works out much cleaner. One of life's comprimises.
- if not results_dir:
- results_dir = os.path.join(self.resultdir, 'build')
- i = 2
- while os.path.exists(results_dir):
- results_dir = os.path.join(self.resultdir, 'build.%d' % i)
- i += 1
- if not os.path.exists(results_dir):
- os.mkdir(results_dir)
+ def config_get(self, name):
+ return self.config.get(name)
- return (results_dir, tmp_dir)
+ def setup_dirs(self, results_dir, tmp_dir):
+ if not tmp_dir:
+ tmp_dir = os.path.join(self.tmpdir, 'build')
+ if not os.path.exists(tmp_dir):
+ os.mkdir(tmp_dir)
+ if not os.path.isdir(tmp_dir):
+ e_msg = "Temp dir (%s) is not a dir - args backwards?" % self.tmpdir
+ raise ValueError(e_msg)
+ # We label the first build "build" and then subsequent ones
+ # as "build.2", "build.3", etc. Whilst this is a little bit
+ # inconsistent, 99.9% of jobs will only have one build
+ # (that's not done as kernbench, sparse, or buildtest),
+ # so it works out much cleaner. One of life's comprimises.
+ if not results_dir:
+ results_dir = os.path.join(self.resultdir, 'build')
+ i = 2
+ while os.path.exists(results_dir):
+ results_dir = os.path.join(self.resultdir, 'build.%d' % i)
+ i += 1
+ if not os.path.exists(results_dir):
+ os.mkdir(results_dir)
- def xen(self, base_tree, results_dir = '', tmp_dir = '', leave = False, \
- kjob = None ):
- """Summon a xen object"""
- (results_dir, tmp_dir) = self.setup_dirs(results_dir, tmp_dir)
- build_dir = 'xen'
- return xen.xen(self, base_tree, results_dir, tmp_dir, build_dir, leave, kjob)
+ return (results_dir, tmp_dir)
- def kernel(self, base_tree, results_dir = '', tmp_dir = '', leave = False):
- """Summon a kernel object"""
- (results_dir, tmp_dir) = self.setup_dirs(results_dir, tmp_dir)
- build_dir = 'linux'
- return kernel.auto_kernel(self, base_tree, results_dir,
- tmp_dir, build_dir, leave)
+ def xen(self, base_tree, results_dir = '', tmp_dir = '', leave = False, \
+ kjob = None ):
+ """Summon a xen object"""
+ (results_dir, tmp_dir) = self.setup_dirs(results_dir, tmp_dir)
+ build_dir = 'xen'
+ return xen.xen(self, base_tree, results_dir, tmp_dir, build_dir, leave, kjob)
- def barrier(self, *args, **kwds):
- """Create a barrier object"""
- return barrier.barrier(*args, **kwds)
+ def kernel(self, base_tree, results_dir = '', tmp_dir = '', leave = False):
+ """Summon a kernel object"""
+ (results_dir, tmp_dir) = self.setup_dirs(results_dir, tmp_dir)
+ build_dir = 'linux'
+ return kernel.auto_kernel(self, base_tree, results_dir,
+ tmp_dir, build_dir, leave)
- def setup_dep(self, deps):
- """Set up the dependencies for this test.
-
- deps is a list of libraries required for this test.
- """
- for dep in deps:
- try:
- os.chdir(os.path.join(self.autodir, 'deps', dep))
- utils.system('./' + dep + '.py')
- except:
- err = "setting up dependency " + dep + "\n"
- raise error.UnhandledError(err)
+ def barrier(self, *args, **kwds):
+ """Create a barrier object"""
+ return barrier.barrier(*args, **kwds)
- def __runtest(self, url, tag, args, dargs):
- try:
- l = lambda : test.runtest(self, url, tag, args, dargs)
- pid = parallel.fork_start(self.resultdir, l)
- parallel.fork_waitfor(self.resultdir, pid)
- except error.AutotestError:
- raise
- except Exception, e:
- msg = "Unhandled %s error occured during test\n"
- msg %= str(e.__class__.__name__)
- raise error.UnhandledError(msg)
+ def setup_dep(self, deps):
+ """Set up the dependencies for this test.
+ deps is a list of libraries required for this test.
+ """
+ for dep in deps:
+ try:
+ os.chdir(os.path.join(self.autodir, 'deps', dep))
+ utils.system('./' + dep + '.py')
+ except:
+ err = "setting up dependency " + dep + "\n"
+ raise error.UnhandledError(err)
- def run_test(self, url, *args, **dargs):
- """Summon a test object and run it.
-
- tag
- tag to add to testname
- url
- url of the test to run
- """
- if not url:
- raise TypeError("Test name is invalid. "
- "Switched arguments?")
- (group, testname) = test.testname(url)
- namelen = len(testname)
- dargs = dargs.copy()
- tntag = dargs.pop('tag', None)
- if tntag: # testname tag is included in reported test name
- testname += '.' + tntag
- subdir = testname
- sdtag = dargs.pop('subdir_tag', None)
- if sdtag: # subdir-only tag is not included in reports
- subdir = subdir + '.' + sdtag
- tag = subdir[namelen+1:] # '' if none
+ def __runtest(self, url, tag, args, dargs):
+ try:
+ l = lambda : test.runtest(self, url, tag, args, dargs)
+ pid = parallel.fork_start(self.resultdir, l)
+ parallel.fork_waitfor(self.resultdir, pid)
+ except error.AutotestError:
+ raise
+ except Exception, e:
+ msg = "Unhandled %s error occured during test\n"
+ msg %= str(e.__class__.__name__)
+ raise error.UnhandledError(msg)
- outputdir = os.path.join(self.resultdir, subdir)
- if os.path.exists(outputdir):
- msg = ("%s already exists, test <%s> may have"
- " already run with tag <%s>"
- % (outputdir, testname, tag) )
- raise error.TestError(msg)
- os.mkdir(outputdir)
-
- container = dargs.pop('container', None)
- if container:
- cname = container.get('name', None)
- if not cname: # get old name
- cname = container.get('container_name', None)
- mbytes = container.get('mbytes', None)
- if not mbytes: # get old name
- mbytes = container.get('mem', None)
- cpus = container.get('cpus', None)
- if not cpus: # get old name
- cpus = container.get('cpu', None)
- root = container.get('root', None)
- self.new_container(mbytes=mbytes, cpus=cpus,
- root=root, name=cname)
- # We are running in a container now...
- def log_warning(reason):
- self.record("WARN", subdir, testname, reason)
- @disk_usage_monitor.watch(log_warning, "/",
- self.max_disk_usage_rate)
- def group_func():
- try:
- self.__runtest(url, tag, args, dargs)
- except error.TestNAError, detail:
- self.record('TEST_NA', subdir, testname,
- str(detail))
- raise
- except Exception, detail:
- self.record('FAIL', subdir, testname,
- str(detail))
- raise
- else:
- self.record('GOOD', subdir, testname,
- 'completed successfully')
+ def run_test(self, url, *args, **dargs):
+ """Summon a test object and run it.
- result, exc_info = self.__rungroup(subdir, testname, group_func)
- if container:
- self.release_container()
- if exc_info and isinstance(exc_info[1], error.TestError):
- return False
- elif exc_info:
- raise exc_info[0], exc_info[1], exc_info[2]
- else:
- return True
+ tag
+ tag to add to testname
+ url
+ url of the test to run
+ """
+ if not url:
+ raise TypeError("Test name is invalid. "
+ "Switched arguments?")
+ (group, testname) = test.testname(url)
+ namelen = len(testname)
+ dargs = dargs.copy()
+ tntag = dargs.pop('tag', None)
+ if tntag: # testname tag is included in reported test name
+ testname += '.' + tntag
+ subdir = testname
+ sdtag = dargs.pop('subdir_tag', None)
+ if sdtag: # subdir-only tag is not included in reports
+ subdir = subdir + '.' + sdtag
+ tag = subdir[namelen+1:] # '' if none
- def __rungroup(self, subdir, testname, function, *args, **dargs):
- """\
- subdir:
- name of the group
- testname:
- name of the test to run, or support step
- function:
- subroutine to run
- *args:
- arguments for the function
+ outputdir = os.path.join(self.resultdir, subdir)
+ if os.path.exists(outputdir):
+ msg = ("%s already exists, test <%s> may have"
+ " already run with tag <%s>"
+ % (outputdir, testname, tag) )
+ raise error.TestError(msg)
+ os.mkdir(outputdir)
- Returns a 2-tuple (result, exc_info) where result
- is the return value of function, and exc_info is
- the sys.exc_info() of the exception thrown by the
- function (which may be None).
- """
+ container = dargs.pop('container', None)
+ if container:
+ cname = container.get('name', None)
+ if not cname: # get old name
+ cname = container.get('container_name', None)
+ mbytes = container.get('mbytes', None)
+ if not mbytes: # get old name
+ mbytes = container.get('mem', None)
+ cpus = container.get('cpus', None)
+ if not cpus: # get old name
+ cpus = container.get('cpu', None)
+ root = container.get('root', None)
+ self.new_container(mbytes=mbytes, cpus=cpus,
+ root=root, name=cname)
+ # We are running in a container now...
- result, exc_info = None, None
- try:
- self.record('START', subdir, testname)
- self._increment_group_level()
- result = function(*args, **dargs)
- self._decrement_group_level()
- self.record('END GOOD', subdir, testname)
- except error.TestNAError, e:
- self._decrement_group_level()
- self.record('END TEST_NA', subdir, testname, str(e))
- except Exception, e:
- exc_info = sys.exc_info()
- self._decrement_group_level()
- err_msg = str(e) + '\n' + traceback.format_exc()
- self.record('END FAIL', subdir, testname, err_msg)
+ def log_warning(reason):
+ self.record("WARN", subdir, testname, reason)
+ @disk_usage_monitor.watch(log_warning, "/",
+ self.max_disk_usage_rate)
+ def group_func():
+ try:
+ self.__runtest(url, tag, args, dargs)
+ except error.TestNAError, detail:
+ self.record('TEST_NA', subdir, testname,
+ str(detail))
+ raise
+ except Exception, detail:
+ self.record('FAIL', subdir, testname,
+ str(detail))
+ raise
+ else:
+ self.record('GOOD', subdir, testname,
+ 'completed successfully')
- return result, exc_info
+ result, exc_info = self.__rungroup(subdir, testname, group_func)
+ if container:
+ self.release_container()
+ if exc_info and isinstance(exc_info[1], error.TestError):
+ return False
+ elif exc_info:
+ raise exc_info[0], exc_info[1], exc_info[2]
+ else:
+ return True
- def run_group(self, function, *args, **dargs):
- """\
- function:
- subroutine to run
- *args:
- arguments for the function
- """
+ def __rungroup(self, subdir, testname, function, *args, **dargs):
+ """\
+ subdir:
+ name of the group
+ testname:
+ name of the test to run, or support step
+ function:
+ subroutine to run
+ *args:
+ arguments for the function
- # Allow the tag for the group to be specified
- name = function.__name__
- tag = dargs.pop('tag', None)
- if tag:
- name = tag
+ Returns a 2-tuple (result, exc_info) where result
+ is the return value of function, and exc_info is
+ the sys.exc_info() of the exception thrown by the
+ function (which may be None).
+ """
- outputdir = os.path.join(self.resultdir, name)
- if os.path.exists(outputdir):
- msg = ("%s already exists, test <%s> may have"
- " already run with tag <%s>"
- % (outputdir, name, name) )
- raise error.TestError(msg)
- os.mkdir(outputdir)
+ result, exc_info = None, None
+ try:
+ self.record('START', subdir, testname)
+ self._increment_group_level()
+ result = function(*args, **dargs)
+ self._decrement_group_level()
+ self.record('END GOOD', subdir, testname)
+ except error.TestNAError, e:
+ self._decrement_group_level()
+ self.record('END TEST_NA', subdir, testname, str(e))
+ except Exception, e:
+ exc_info = sys.exc_info()
+ self._decrement_group_level()
+ err_msg = str(e) + '\n' + traceback.format_exc()
+ self.record('END FAIL', subdir, testname, err_msg)
- result, exc_info = self.__rungroup(name, name, function,
- *args, **dargs)
+ return result, exc_info
- # if there was a non-TestError exception, raise it
- if exc_info and not isinstance(exc_info[1], error.TestError):
- err = ''.join(traceback.format_exception(*exc_info))
- raise error.TestError(name + ' failed\n' + err)
- # pass back the actual return value from the function
- return result
+ def run_group(self, function, *args, **dargs):
+ """\
+ function:
+ subroutine to run
+ *args:
+ arguments for the function
+ """
+ # Allow the tag for the group to be specified
+ name = function.__name__
+ tag = dargs.pop('tag', None)
+ if tag:
+ name = tag
- def new_container(self, mbytes=None, cpus=None, root=None, name=None):
- if not autotest_utils.grep('cpuset', '/proc/filesystems'):
- print "Containers not enabled by latest reboot"
- return # containers weren't enabled in this kernel boot
- pid = os.getpid()
- if not name:
- name = 'test%d' % pid # make arbitrary unique name
- self.container = cpuset.cpuset(name, job_size=mbytes,
- job_pid=pid, cpus=cpus, root=root)
- # This job's python shell is now running in the new container
- # and all forked test processes will inherit that container
+ outputdir = os.path.join(self.resultdir, name)
+ if os.path.exists(outputdir):
+ msg = ("%s already exists, test <%s> may have"
+ " already run with tag <%s>"
+ % (outputdir, name, name) )
+ raise error.TestError(msg)
+ os.mkdir(outputdir)
+
+ result, exc_info = self.__rungroup(name, name, function,
+ *args, **dargs)
+
+ # if there was a non-TestError exception, raise it
+ if exc_info and not isinstance(exc_info[1], error.TestError):
+ err = ''.join(traceback.format_exception(*exc_info))
+ raise error.TestError(name + ' failed\n' + err)
+
+ # pass back the actual return value from the function
+ return result
+
+
+ def new_container(self, mbytes=None, cpus=None, root=None, name=None):
+ if not autotest_utils.grep('cpuset', '/proc/filesystems'):
+ print "Containers not enabled by latest reboot"
+ return # containers weren't enabled in this kernel boot
+ pid = os.getpid()
+ if not name:
+ name = 'test%d' % pid # make arbitrary unique name
+ self.container = cpuset.cpuset(name, job_size=mbytes,
+ job_pid=pid, cpus=cpus, root=root)
+ # This job's python shell is now running in the new container
+ # and all forked test processes will inherit that container
+
+
+ def release_container(self):
+ if self.container:
+ self.container.release()
+ self.container = None
+
+ def cpu_count(self):
+ if self.container:
+ return len(self.container.cpus)
+ return autotest_utils.count_cpus() # use total system count
- def release_container(self):
- if self.container:
- self.container.release()
- self.container = None
+ # Check the passed kernel identifier against the command line
+ # and the running kernel, abort the job on missmatch.
+ def kernel_check_ident(self, expected_when, expected_id, subdir,
+ type = 'src', patches=[]):
+ print (("POST BOOT: checking booted kernel " +
+ "mark=%d identity='%s' type='%s'") %
+ (expected_when, expected_id, type))
- def cpu_count(self):
- if self.container:
- return len(self.container.cpus)
- return autotest_utils.count_cpus() # use total system count
+ running_id = autotest_utils.running_os_ident()
+ cmdline = utils.read_one_line("/proc/cmdline")
- # Check the passed kernel identifier against the command line
- # and the running kernel, abort the job on missmatch.
- def kernel_check_ident(self, expected_when, expected_id, subdir,
- type = 'src', patches=[]):
- print (("POST BOOT: checking booted kernel " +
- "mark=%d identity='%s' type='%s'") %
- (expected_when, expected_id, type))
+ find_sum = re.compile(r'.*IDENT=(\d+)')
+ m = find_sum.match(cmdline)
+ cmdline_when = -1
+ if m:
+ cmdline_when = int(m.groups()[0])
- running_id = autotest_utils.running_os_ident()
+ # We have all the facts, see if they indicate we
+ # booted the requested kernel or not.
+ bad = False
+ if (type == 'src' and expected_id != running_id or
+ type == 'rpm' and
+ not running_id.startswith(expected_id + '::')):
+ print "check_kernel_ident: kernel identifier mismatch"
+ bad = True
+ if expected_when != cmdline_when:
+ print "check_kernel_ident: kernel command line mismatch"
+ bad = True
- cmdline = utils.read_one_line("/proc/cmdline")
+ if bad:
+ print " Expected Ident: " + expected_id
+ print " Running Ident: " + running_id
+ print " Expected Mark: %d" % (expected_when)
+ print "Command Line Mark: %d" % (cmdline_when)
+ print " Command Line: " + cmdline
- find_sum = re.compile(r'.*IDENT=(\d+)')
- m = find_sum.match(cmdline)
- cmdline_when = -1
- if m:
- cmdline_when = int(m.groups()[0])
+ raise error.JobError("boot failure", "reboot.verify")
- # We have all the facts, see if they indicate we
- # booted the requested kernel or not.
- bad = False
- if (type == 'src' and expected_id != running_id or
- type == 'rpm' and
- not running_id.startswith(expected_id + '::')):
- print "check_kernel_ident: kernel identifier mismatch"
- bad = True
- if expected_when != cmdline_when:
- print "check_kernel_ident: kernel command line mismatch"
- bad = True
+ kernel_info = {'kernel': expected_id}
+ for i, patch in enumerate(patches):
+ kernel_info["patch%d" % i] = patch
+ self.record('GOOD', subdir, 'reboot.verify', expected_id)
+ self._decrement_group_level()
+ self.record('END GOOD', subdir, 'reboot',
+ optional_fields=kernel_info)
- if bad:
- print " Expected Ident: " + expected_id
- print " Running Ident: " + running_id
- print " Expected Mark: %d" % (expected_when)
- print "Command Line Mark: %d" % (cmdline_when)
- print " Command Line: " + cmdline
- raise error.JobError("boot failure", "reboot.verify")
+ def filesystem(self, device, mountpoint = None, loop_size = 0):
+ if not mountpoint:
+ mountpoint = self.tmpdir
+ return filesystem.filesystem(self, device, mountpoint,loop_size)
- kernel_info = {'kernel': expected_id}
- for i, patch in enumerate(patches):
- kernel_info["patch%d" % i] = patch
- self.record('GOOD', subdir, 'reboot.verify', expected_id)
- self._decrement_group_level()
- self.record('END GOOD', subdir, 'reboot',
- optional_fields=kernel_info)
+ def enable_external_logging(self):
+ pass
- def filesystem(self, device, mountpoint = None, loop_size = 0):
- if not mountpoint:
- mountpoint = self.tmpdir
- return filesystem.filesystem(self, device, mountpoint,loop_size)
-
- def enable_external_logging(self):
- pass
+ def disable_external_logging(self):
+ pass
- def disable_external_logging(self):
- pass
-
+ def reboot_setup(self):
+ pass
- def reboot_setup(self):
- pass
+ def reboot(self, tag='autotest'):
+ self.reboot_setup()
+ self.record('START', None, 'reboot')
+ self._increment_group_level()
+ self.record('GOOD', None, 'reboot.start')
+ self.harness.run_reboot()
+ default = self.config_get('boot.set_default')
+ if default:
+ self.bootloader.set_default(tag)
+ else:
+ self.bootloader.boot_once(tag)
+ cmd = "(sleep 5; reboot) </dev/null >/dev/null 2>&1 &"
+ utils.system(cmd)
+ self.quit()
- def reboot(self, tag='autotest'):
- self.reboot_setup()
- self.record('START', None, 'reboot')
- self._increment_group_level()
- self.record('GOOD', None, 'reboot.start')
- self.harness.run_reboot()
- default = self.config_get('boot.set_default')
- if default:
- self.bootloader.set_default(tag)
- else:
- self.bootloader.boot_once(tag)
- cmd = "(sleep 5; reboot) </dev/null >/dev/null 2>&1 &"
- utils.system(cmd)
- self.quit()
+ def noop(self, text):
+ print "job: noop: " + text
- def noop(self, text):
- print "job: noop: " + text
+ def parallel(self, *tasklist):
+ """Run tasks in parallel"""
- def parallel(self, *tasklist):
- """Run tasks in parallel"""
+ pids = []
+ old_log_filename = self.log_filename
+ for i, task in enumerate(tasklist):
+ self.log_filename = old_log_filename + (".%d" % i)
+ task_func = lambda: task[0](*task[1:])
+ pids.append(parallel.fork_start(self.resultdir,
+ task_func))
- pids = []
- old_log_filename = self.log_filename
- for i, task in enumerate(tasklist):
- self.log_filename = old_log_filename + (".%d" % i)
- task_func = lambda: task[0](*task[1:])
- pids.append(parallel.fork_start(self.resultdir,
- task_func))
+ old_log_path = os.path.join(self.resultdir, old_log_filename)
+ old_log = open(old_log_path, "a")
+ exceptions = []
+ for i, pid in enumerate(pids):
+ # wait for the task to finish
+ try:
+ parallel.fork_waitfor(self.resultdir, pid)
+ except Exception, e:
+ exceptions.append(e)
+ # copy the logs from the subtask into the main log
+ new_log_path = old_log_path + (".%d" % i)
+ if os.path.exists(new_log_path):
+ new_log = open(new_log_path)
+ old_log.write(new_log.read())
+ new_log.close()
+ old_log.flush()
+ os.remove(new_log_path)
+ old_log.close()
- old_log_path = os.path.join(self.resultdir, old_log_filename)
- old_log = open(old_log_path, "a")
- exceptions = []
- for i, pid in enumerate(pids):
- # wait for the task to finish
- try:
- parallel.fork_waitfor(self.resultdir, pid)
- except Exception, e:
- exceptions.append(e)
- # copy the logs from the subtask into the main log
- new_log_path = old_log_path + (".%d" % i)
- if os.path.exists(new_log_path):
- new_log = open(new_log_path)
- old_log.write(new_log.read())
- new_log.close()
- old_log.flush()
- os.remove(new_log_path)
- old_log.close()
+ self.log_filename = old_log_filename
- self.log_filename = old_log_filename
+ # handle any exceptions raised by the parallel tasks
+ if exceptions:
+ msg = "%d task(s) failed" % len(exceptions)
+ raise error.JobError(msg, str(exceptions), exceptions)
- # handle any exceptions raised by the parallel tasks
- if exceptions:
- msg = "%d task(s) failed" % len(exceptions)
- raise error.JobError(msg, str(exceptions), exceptions)
+ def quit(self):
+ # XXX: should have a better name.
+ self.harness.run_pause()
+ raise error.JobContinue("more to come")
- def quit(self):
- # XXX: should have a better name.
- self.harness.run_pause()
- raise error.JobContinue("more to come")
+ def complete(self, status):
+ """Clean up and exit"""
+ # We are about to exit 'complete' so clean up the control file.
+ try:
+ os.unlink(self.state_file)
+ except:
+ pass
- def complete(self, status):
- """Clean up and exit"""
- # We are about to exit 'complete' so clean up the control file.
- try:
- os.unlink(self.state_file)
- except:
- pass
+ self.harness.run_complete()
+ self.disable_external_logging()
+ sys.exit(status)
- self.harness.run_complete()
- self.disable_external_logging()
- sys.exit(status)
+ def set_state(self, var, val):
+ # Deep copies make sure that the state can't be altered
+ # without it being re-written. Perf wise, deep copies
+ # are overshadowed by pickling/loading.
+ self.state[var] = copy.deepcopy(val)
+ pickle.dump(self.state, open(self.state_file, 'w'))
- def set_state(self, var, val):
- # Deep copies make sure that the state can't be altered
- # without it being re-written. Perf wise, deep copies
- # are overshadowed by pickling/loading.
- self.state[var] = copy.deepcopy(val)
- pickle.dump(self.state, open(self.state_file, 'w'))
+ def __load_state(self):
+ assert not hasattr(self, "state")
+ try:
+ self.state = pickle.load(open(self.state_file, 'r'))
+ self.state_existed = True
+ except Exception:
+ print "Initializing the state engine."
+ self.state = {}
+ self.set_state('__steps', []) # writes pickle file
+ self.state_existed = False
- def __load_state(self):
- assert not hasattr(self, "state")
- try:
- self.state = pickle.load(open(self.state_file, 'r'))
- self.state_existed = True
- except Exception:
- print "Initializing the state engine."
- self.state = {}
- self.set_state('__steps', []) # writes pickle file
- self.state_existed = False
+ def get_state(self, var, default=None):
+ if var in self.state or default == None:
+ val = self.state[var]
+ else:
+ val = default
+ return copy.deepcopy(val)
- def get_state(self, var, default=None):
- if var in self.state or default == None:
- val = self.state[var]
- else:
- val = default
- return copy.deepcopy(val)
+ def __create_step_tuple(self, fn, args, dargs):
+ # Legacy code passes in an array where the first arg is
+ # the function or its name.
+ if isinstance(fn, list):
+ assert(len(args) == 0)
+ assert(len(dargs) == 0)
+ args = fn[1:]
+ fn = fn[0]
+ # Pickling actual functions is harry, thus we have to call
+ # them by name. Unfortunately, this means only functions
+ # defined globally can be used as a next step.
+ if callable(fn):
+ fn = fn.__name__
+ if not isinstance(fn, types.StringTypes):
+ raise StepError("Next steps must be functions or "
+ "strings containing the function name")
+ ancestry = copy.copy(self.current_step_ancestry)
+ return (ancestry, fn, args, dargs)
- def __create_step_tuple(self, fn, args, dargs):
- # Legacy code passes in an array where the first arg is
- # the function or its name.
- if isinstance(fn, list):
- assert(len(args) == 0)
- assert(len(dargs) == 0)
- args = fn[1:]
- fn = fn[0]
- # Pickling actual functions is harry, thus we have to call
- # them by name. Unfortunately, this means only functions
- # defined globally can be used as a next step.
- if callable(fn):
- fn = fn.__name__
- if not isinstance(fn, types.StringTypes):
- raise StepError("Next steps must be functions or "
- "strings containing the function name")
- ancestry = copy.copy(self.current_step_ancestry)
- return (ancestry, fn, args, dargs)
+ def next_step_append(self, fn, *args, **dargs):
+ """Define the next step and place it at the end"""
+ steps = self.get_state('__steps')
+ steps.append(self.__create_step_tuple(fn, args, dargs))
+ self.set_state('__steps', steps)
- def next_step_append(self, fn, *args, **dargs):
- """Define the next step and place it at the end"""
- steps = self.get_state('__steps')
- steps.append(self.__create_step_tuple(fn, args, dargs))
- self.set_state('__steps', steps)
+ def next_step(self, fn, *args, **dargs):
+ """Create a new step and place it after any steps added
+ while running the current step but before any steps added in
+ previous steps"""
+ steps = self.get_state('__steps')
+ steps.insert(self.next_step_index,
+ self.__create_step_tuple(fn, args, dargs))
+ self.next_step_index += 1
+ self.set_state('__steps', steps)
- def next_step(self, fn, *args, **dargs):
- """Create a new step and place it after any steps added
- while running the current step but before any steps added in
- previous steps"""
- steps = self.get_state('__steps')
- steps.insert(self.next_step_index,
- self.__create_step_tuple(fn, args, dargs))
- self.next_step_index += 1
- self.set_state('__steps', steps)
+ def next_step_prepend(self, fn, *args, **dargs):
+ """Insert a new step, executing first"""
+ steps = self.get_state('__steps')
+ steps.insert(0, self.__create_step_tuple(fn, args, dargs))
+ self.next_step_index += 1
+ self.set_state('__steps', steps)
- def next_step_prepend(self, fn, *args, **dargs):
- """Insert a new step, executing first"""
- steps = self.get_state('__steps')
- steps.insert(0, self.__create_step_tuple(fn, args, dargs))
- self.next_step_index += 1
- self.set_state('__steps', steps)
+ def _run_step_fn(self, local_vars, fn, args, dargs):
+ """Run a (step) function within the given context"""
- def _run_step_fn(self, local_vars, fn, args, dargs):
- """Run a (step) function within the given context"""
+ local_vars['__args'] = args
+ local_vars['__dargs'] = dargs
+ exec('__ret = %s(*__args, **__dargs)' % fn,
+ local_vars, local_vars)
+ return local_vars['__ret']
- local_vars['__args'] = args
- local_vars['__dargs'] = dargs
- exec('__ret = %s(*__args, **__dargs)' % fn,
- local_vars, local_vars)
- return local_vars['__ret']
+ def _create_frame(self, global_vars, ancestry, fn_name):
+ """Set up the environment like it would have been when this
+ function was first defined.
- def _create_frame(self, global_vars, ancestry, fn_name):
- """Set up the environment like it would have been when this
- function was first defined.
+ Child step engine 'implementations' must have 'return locals()'
+ at end end of their steps. Because of this, we can call the
+ parent function and get back all child functions (i.e. those
+ defined within it).
- Child step engine 'implementations' must have 'return locals()'
- at end end of their steps. Because of this, we can call the
- parent function and get back all child functions (i.e. those
- defined within it).
+ Unfortunately, the call stack of the function calling
+ job.next_step might have been deeper than the function it
+ added. In order to make sure that the environment is what it
+ should be, we need to then pop off the frames we built until
+ we find the frame where the function was first defined."""
- Unfortunately, the call stack of the function calling
- job.next_step might have been deeper than the function it
- added. In order to make sure that the environment is what it
- should be, we need to then pop off the frames we built until
- we find the frame where the function was first defined."""
+ # The copies ensure that the parent frames are not modified
+ # while building child frames. This matters if we then
+ # pop some frames in the next part of this function.
+ current_frame = copy.copy(global_vars)
+ frames = [current_frame]
+ for steps_fn_name in ancestry:
+ ret = self._run_step_fn(current_frame,
+ steps_fn_name, [], {})
+ current_frame = copy.copy(ret)
+ frames.append(current_frame)
- # The copies ensure that the parent frames are not modified
- # while building child frames. This matters if we then
- # pop some frames in the next part of this function.
- current_frame = copy.copy(global_vars)
- frames = [current_frame]
- for steps_fn_name in ancestry:
- ret = self._run_step_fn(current_frame,
- steps_fn_name, [], {})
- current_frame = copy.copy(ret)
- frames.append(current_frame)
+ while len(frames) > 2:
+ if fn_name not in frames[-2]:
+ break
+ if frames[-2][fn_name] != frames[-1][fn_name]:
+ break
+ frames.pop()
+ ancestry.pop()
- while len(frames) > 2:
- if fn_name not in frames[-2]:
- break
- if frames[-2][fn_name] != frames[-1][fn_name]:
- break
- frames.pop()
- ancestry.pop()
+ return (frames[-1], ancestry)
- return (frames[-1], ancestry)
+ def _add_step_init(self, local_vars, current_function):
+ """If the function returned a dictionary that includes a
+ function named 'step_init', prepend it to our list of steps.
+ This will only get run the first time a function with a nested
+ use of the step engine is run."""
- def _add_step_init(self, local_vars, current_function):
- """If the function returned a dictionary that includes a
- function named 'step_init', prepend it to our list of steps.
- This will only get run the first time a function with a nested
- use of the step engine is run."""
+ if (isinstance(local_vars, dict) and
+ 'step_init' in local_vars and
+ callable(local_vars['step_init'])):
+ # The init step is a child of the function
+ # we were just running.
+ self.current_step_ancestry.append(current_function)
+ self.next_step_prepend('step_init')
- if (isinstance(local_vars, dict) and
- 'step_init' in local_vars and
- callable(local_vars['step_init'])):
- # The init step is a child of the function
- # we were just running.
- self.current_step_ancestry.append(current_function)
- self.next_step_prepend('step_init')
+ def step_engine(self):
+ """the stepping engine -- if the control file defines
+ step_init we will be using this engine to drive multiple runs.
+ """
+ """Do the next step"""
- def step_engine(self):
- """the stepping engine -- if the control file defines
- step_init we will be using this engine to drive multiple runs.
- """
- """Do the next step"""
+ # Set up the environment and then interpret the control file.
+ # Some control files will have code outside of functions,
+ # which means we need to have our state engine initialized
+ # before reading in the file.
+ global_control_vars = {'job': self}
+ exec(JOB_PREAMBLE, global_control_vars, global_control_vars)
+ execfile(self.control, global_control_vars, global_control_vars)
- # Set up the environment and then interpret the control file.
- # Some control files will have code outside of functions,
- # which means we need to have our state engine initialized
- # before reading in the file.
- global_control_vars = {'job': self}
- exec(JOB_PREAMBLE, global_control_vars, global_control_vars)
- execfile(self.control, global_control_vars, global_control_vars)
+ # If we loaded in a mid-job state file, then we presumably
+ # know what steps we have yet to run.
+ if not self.state_existed:
+ if global_control_vars.has_key('step_init'):
+ self.next_step(global_control_vars['step_init'])
- # If we loaded in a mid-job state file, then we presumably
- # know what steps we have yet to run.
- if not self.state_existed:
- if global_control_vars.has_key('step_init'):
- self.next_step(global_control_vars['step_init'])
+ # Iterate through the steps. If we reboot, we'll simply
+ # continue iterating on the next step.
+ while len(self.get_state('__steps')) > 0:
+ steps = self.get_state('__steps')
+ (ancestry, fn_name, args, dargs) = steps.pop(0)
+ self.set_state('__steps', steps)
- # Iterate through the steps. If we reboot, we'll simply
- # continue iterating on the next step.
- while len(self.get_state('__steps')) > 0:
- steps = self.get_state('__steps')
- (ancestry, fn_name, args, dargs) = steps.pop(0)
- self.set_state('__steps', steps)
+ self.next_step_index = 0
+ ret = self._create_frame(global_control_vars, ancestry,
+ fn_name)
+ local_vars, self.current_step_ancestry = ret
+ local_vars = self._run_step_fn(local_vars, fn_name,
+ args, dargs)
+ self._add_step_init(local_vars, fn_name)
- self.next_step_index = 0
- ret = self._create_frame(global_control_vars, ancestry,
- fn_name)
- local_vars, self.current_step_ancestry = ret
- local_vars = self._run_step_fn(local_vars, fn_name,
- args, dargs)
- self._add_step_init(local_vars, fn_name)
+ def _init_group_level(self):
+ self.group_level = self.get_state("__group_level", default=0)
- def _init_group_level(self):
- self.group_level = self.get_state("__group_level", default=0)
+ def _increment_group_level(self):
+ self.group_level += 1
+ self.set_state("__group_level", self.group_level)
- def _increment_group_level(self):
- self.group_level += 1
- self.set_state("__group_level", self.group_level)
+ def _decrement_group_level(self):
+ self.group_level -= 1
+ self.set_state("__group_level", self.group_level)
- def _decrement_group_level(self):
- self.group_level -= 1
- self.set_state("__group_level", self.group_level)
+ def record(self, status_code, subdir, operation, status = '',
+ optional_fields=None):
+ """
+ Record job-level status
- def record(self, status_code, subdir, operation, status = '',
- optional_fields=None):
- """
- Record job-level status
+ The intent is to make this file both machine parseable and
+ human readable. That involves a little more complexity, but
+ really isn't all that bad ;-)
- The intent is to make this file both machine parseable and
- human readable. That involves a little more complexity, but
- really isn't all that bad ;-)
+ Format is <status code>\t<subdir>\t<operation>\t<status>
- Format is <status code>\t<subdir>\t<operation>\t<status>
+ status code: (GOOD|WARN|FAIL|ABORT)
+ or START
+ or END (GOOD|WARN|FAIL|ABORT)
- status code: (GOOD|WARN|FAIL|ABORT)
- or START
- or END (GOOD|WARN|FAIL|ABORT)
+ subdir: MUST be a relevant subdirectory in the results,
+ or None, which will be represented as '----'
- subdir: MUST be a relevant subdirectory in the results,
- or None, which will be represented as '----'
+ operation: description of what you ran (e.g. "dbench", or
+ "mkfs -t foobar /dev/sda9")
- operation: description of what you ran (e.g. "dbench", or
- "mkfs -t foobar /dev/sda9")
+ status: error message or "completed sucessfully"
- status: error message or "completed sucessfully"
+ ------------------------------------------------------------
- ------------------------------------------------------------
+ Initial tabs indicate indent levels for grouping, and is
+ governed by self.group_level
- Initial tabs indicate indent levels for grouping, and is
- governed by self.group_level
+ multiline messages have secondary lines prefaced by a double
+ space (' ')
+ """
- multiline messages have secondary lines prefaced by a double
- space (' ')
- """
+ if subdir:
+ if re.match(r'[\n\t]', subdir):
+ raise ValueError("Invalid character in "
+ "subdir string")
+ substr = subdir
+ else:
+ substr = '----'
- if subdir:
- if re.match(r'[\n\t]', subdir):
- raise ValueError("Invalid character in "
- "subdir string")
- substr = subdir
- else:
- substr = '----'
-
- if not logging.is_valid_status(status_code):
- raise ValueError("Invalid status code supplied: %s" %
- status_code)
- if not operation:
- operation = '----'
+ if not logging.is_valid_status(status_code):
+ raise ValueError("Invalid status code supplied: %s" %
+ status_code)
+ if not operation:
+ operation = '----'
- if re.match(r'[\n\t]', operation):
- raise ValueError("Invalid character in "
- "operation string")
- operation = operation.rstrip()
+ if re.match(r'[\n\t]', operation):
+ raise ValueError("Invalid character in "
+ "operation string")
+ operation = operation.rstrip()
- if not optional_fields:
- optional_fields = {}
+ if not optional_fields:
+ optional_fields = {}
- status = status.rstrip()
- status = re.sub(r"\t", " ", status)
- # Ensure any continuation lines are marked so we can
- # detect them in the status file to ensure it is parsable.
- status = re.sub(r"\n", "\n" + "\t" * self.group_level + " ",
- status)
+ status = status.rstrip()
+ status = re.sub(r"\t", " ", status)
+ # Ensure any continuation lines are marked so we can
+ # detect them in the status file to ensure it is parsable.
+ status = re.sub(r"\n", "\n" + "\t" * self.group_level + " ",
+ status)
- # Generate timestamps for inclusion in the logs
- epoch_time = int(time.time()) # seconds since epoch, in UTC
- local_time = time.localtime(epoch_time)
- optional_fields["timestamp"] = str(epoch_time)
- optional_fields["localtime"] = time.strftime("%b %d %H:%M:%S",
- local_time)
+ # Generate timestamps for inclusion in the logs
+ epoch_time = int(time.time()) # seconds since epoch, in UTC
+ local_time = time.localtime(epoch_time)
+ optional_fields["timestamp"] = str(epoch_time)
+ optional_fields["localtime"] = time.strftime("%b %d %H:%M:%S",
+ local_time)
- fields = [status_code, substr, operation]
- fields += ["%s=%s" % x for x in optional_fields.iteritems()]
- fields.append(status)
+ fields = [status_code, substr, operation]
+ fields += ["%s=%s" % x for x in optional_fields.iteritems()]
+ fields.append(status)
- msg = '\t'.join(str(x) for x in fields)
- msg = '\t' * self.group_level + msg
+ msg = '\t'.join(str(x) for x in fields)
+ msg = '\t' * self.group_level + msg
- msg_tag = ""
- if "." in self.log_filename:
- msg_tag = self.log_filename.split(".", 1)[1]
+ msg_tag = ""
+ if "." in self.log_filename:
+ msg_tag = self.log_filename.split(".", 1)[1]
- self.harness.test_status_detail(status_code, substr,
- operation, status, msg_tag)
- self.harness.test_status(msg, msg_tag)
+ self.harness.test_status_detail(status_code, substr,
+ operation, status, msg_tag)
+ self.harness.test_status(msg, msg_tag)
- # log to stdout (if enabled)
- #if self.log_filename == self.DEFAULT_LOG_FILENAME:
- print msg
+ # log to stdout (if enabled)
+ #if self.log_filename == self.DEFAULT_LOG_FILENAME:
+ print msg
- # log to the "root" status log
- status_file = os.path.join(self.resultdir, self.log_filename)
- open(status_file, "a").write(msg + "\n")
+ # log to the "root" status log
+ status_file = os.path.join(self.resultdir, self.log_filename)
+ open(status_file, "a").write(msg + "\n")
- # log to the subdir status log (if subdir is set)
- if subdir:
- dir = os.path.join(self.resultdir, subdir)
- status_file = os.path.join(dir,
- self.DEFAULT_LOG_FILENAME)
- open(status_file, "a").write(msg + "\n")
+ # log to the subdir status log (if subdir is set)
+ if subdir:
+ dir = os.path.join(self.resultdir, subdir)
+ status_file = os.path.join(dir,
+ self.DEFAULT_LOG_FILENAME)
+ open(status_file, "a").write(msg + "\n")
class disk_usage_monitor:
- def __init__(self, logging_func, device, max_mb_per_hour):
- self.func = logging_func
- self.device = device
- self.max_mb_per_hour = max_mb_per_hour
+ def __init__(self, logging_func, device, max_mb_per_hour):
+ self.func = logging_func
+ self.device = device
+ self.max_mb_per_hour = max_mb_per_hour
- def start(self):
- self.initial_space = autotest_utils.freespace(self.device)
- self.start_time = time.time()
+ def start(self):
+ self.initial_space = autotest_utils.freespace(self.device)
+ self.start_time = time.time()
- def stop(self):
- # if no maximum usage rate was set, we don't need to
- # generate any warnings
- if not self.max_mb_per_hour:
- return
+ def stop(self):
+ # if no maximum usage rate was set, we don't need to
+ # generate any warnings
+ if not self.max_mb_per_hour:
+ return
- final_space = autotest_utils.freespace(self.device)
- used_space = self.initial_space - final_space
- stop_time = time.time()
- total_time = stop_time - self.start_time
- # round up the time to one minute, to keep extremely short
- # tests from generating false positives due to short, badly
- # timed bursts of activity
- total_time = max(total_time, 60.0)
+ final_space = autotest_utils.freespace(self.device)
+ used_space = self.initial_space - final_space
+ stop_time = time.time()
+ total_time = stop_time - self.start_time
+ # round up the time to one minute, to keep extremely short
+ # tests from generating false positives due to short, badly
+ # timed bursts of activity
+ total_time = max(total_time, 60.0)
- # determine the usage rate
- bytes_per_sec = used_space / total_time
- mb_per_sec = bytes_per_sec / 1024**2
- mb_per_hour = mb_per_sec * 60 * 60
+ # determine the usage rate
+ bytes_per_sec = used_space / total_time
+ mb_per_sec = bytes_per_sec / 1024**2
+ mb_per_hour = mb_per_sec * 60 * 60
- if mb_per_hour > self.max_mb_per_hour:
- msg = ("disk space on %s was consumed at a rate of "
- "%.2f MB/hour")
- msg %= (self.device, mb_per_hour)
- self.func(msg)
+ if mb_per_hour > self.max_mb_per_hour:
+ msg = ("disk space on %s was consumed at a rate of "
+ "%.2f MB/hour")
+ msg %= (self.device, mb_per_hour)
+ self.func(msg)
- @classmethod
- def watch(cls, *monitor_args, **monitor_dargs):
- """ Generic decorator to wrap a function call with the
- standard create-monitor -> start -> call -> stop idiom."""
- def decorator(func):
- def watched_func(*args, **dargs):
- monitor = cls(*monitor_args, **monitor_dargs)
- monitor.start()
- try:
- func(*args, **dargs)
- finally:
- monitor.stop()
- return watched_func
- return decorator
+ @classmethod
+ def watch(cls, *monitor_args, **monitor_dargs):
+ """ Generic decorator to wrap a function call with the
+ standard create-monitor -> start -> call -> stop idiom."""
+ def decorator(func):
+ def watched_func(*args, **dargs):
+ monitor = cls(*monitor_args, **monitor_dargs)
+ monitor.start()
+ try:
+ func(*args, **dargs)
+ finally:
+ monitor.stop()
+ return watched_func
+ return decorator
def runjob(control, cont = False, tag = "default", harness_type = '',
- use_external_logging = False):
- """The main interface to this module
+ use_external_logging = False):
+ """The main interface to this module
- control
- The control file to use for this job.
- cont
- Whether this is the continuation of a previously started job
- """
- control = os.path.abspath(control)
- state = control + '.state'
+ control
+ The control file to use for this job.
+ cont
+ Whether this is the continuation of a previously started job
+ """
+ control = os.path.abspath(control)
+ state = control + '.state'
- # instantiate the job object ready for the control file.
- myjob = None
- try:
- # Check that the control file is valid
- if not os.path.exists(control):
- raise error.JobError(control +
- ": control file not found")
+ # instantiate the job object ready for the control file.
+ myjob = None
+ try:
+ # Check that the control file is valid
+ if not os.path.exists(control):
+ raise error.JobError(control +
+ ": control file not found")
- # When continuing, the job is complete when there is no
- # state file, ensure we don't try and continue.
- if cont and not os.path.exists(state):
- raise error.JobComplete("all done")
- if cont == False and os.path.exists(state):
- os.unlink(state)
+ # When continuing, the job is complete when there is no
+ # state file, ensure we don't try and continue.
+ if cont and not os.path.exists(state):
+ raise error.JobComplete("all done")
+ if cont == False and os.path.exists(state):
+ os.unlink(state)
- myjob = job(control, tag, cont, harness_type,
- use_external_logging)
+ myjob = job(control, tag, cont, harness_type,
+ use_external_logging)
- # Load in the users control file, may do any one of:
- # 1) execute in toto
- # 2) define steps, and select the first via next_step()
- myjob.step_engine()
+ # Load in the users control file, may do any one of:
+ # 1) execute in toto
+ # 2) define steps, and select the first via next_step()
+ myjob.step_engine()
- except error.JobContinue:
- sys.exit(5)
+ except error.JobContinue:
+ sys.exit(5)
- except error.JobComplete:
- sys.exit(1)
+ except error.JobComplete:
+ sys.exit(1)
- except error.JobError, instance:
- print "JOB ERROR: " + instance.args[0]
- if myjob:
- command = None
- if len(instance.args) > 1:
- command = instance.args[1]
- myjob.record('ABORT', None, command, instance.args[0])
- myjob._decrement_group_level()
- myjob.record('END ABORT', None, None)
- assert(myjob.group_level == 0)
- myjob.complete(1)
- else:
- sys.exit(1)
+ except error.JobError, instance:
+ print "JOB ERROR: " + instance.args[0]
+ if myjob:
+ command = None
+ if len(instance.args) > 1:
+ command = instance.args[1]
+ myjob.record('ABORT', None, command, instance.args[0])
+ myjob._decrement_group_level()
+ myjob.record('END ABORT', None, None)
+ assert(myjob.group_level == 0)
+ myjob.complete(1)
+ else:
+ sys.exit(1)
- except Exception, e:
- msg = str(e) + '\n' + traceback.format_exc()
- print "JOB ERROR: " + msg
- if myjob:
- myjob.record('ABORT', None, None, msg)
- myjob._decrement_group_level()
- myjob.record('END ABORT', None, None)
- assert(myjob.group_level == 0)
- myjob.complete(1)
- else:
- sys.exit(1)
+ except Exception, e:
+ msg = str(e) + '\n' + traceback.format_exc()
+ print "JOB ERROR: " + msg
+ if myjob:
+ myjob.record('ABORT', None, None, msg)
+ myjob._decrement_group_level()
+ myjob.record('END ABORT', None, None)
+ assert(myjob.group_level == 0)
+ myjob.complete(1)
+ else:
+ sys.exit(1)
- # If we get here, then we assume the job is complete and good.
- myjob._decrement_group_level()
- myjob.record('END GOOD', None, None)
- assert(myjob.group_level == 0)
+ # If we get here, then we assume the job is complete and good.
+ myjob._decrement_group_level()
+ myjob.record('END GOOD', None, None)
+ assert(myjob.group_level == 0)
- myjob.complete(0)
+ myjob.complete(0)
# site_job.py may be non-existant or empty, make sure that an appropriate
# site_job class is created nevertheless
try:
- from site_job import site_job
+ from site_job import site_job
except ImportError:
- class site_job(base_job):
- pass
+ class site_job(base_job):
+ pass
class job(site_job):
- pass
+ pass
diff --git a/client/bin/kernel.py b/client/bin/kernel.py
index fca8f7e..ad65ae9 100755
--- a/client/bin/kernel.py
+++ b/client/bin/kernel.py
@@ -8,727 +8,727 @@
class kernel:
- """ Class for compiling kernels.
+ """ Class for compiling kernels.
- Data for the object includes the src files
- used to create the kernel, patches applied, config (base + changes),
- the build directory itself, and logged output
+ Data for the object includes the src files
+ used to create the kernel, patches applied, config (base + changes),
+ the build directory itself, and logged output
- Properties:
- job
- Backpointer to the job object we're part of
- autodir
- Path to the top level autotest dir (/usr/local/autotest)
- src_dir
- <tmp_dir>/src/
- build_dir
- <tmp_dir>/linux/
- config_dir
- <results_dir>/config/
- log_dir
- <results_dir>/debug/
- results_dir
- <results_dir>/results/
- """
+ Properties:
+ job
+ Backpointer to the job object we're part of
+ autodir
+ Path to the top level autotest dir (/usr/local/autotest)
+ src_dir
+ <tmp_dir>/src/
+ build_dir
+ <tmp_dir>/linux/
+ config_dir
+ <results_dir>/config/
+ log_dir
+ <results_dir>/debug/
+ results_dir
+ <results_dir>/results/
+ """
- autodir = ''
+ autodir = ''
- def __init__(self, job, base_tree, subdir, tmp_dir, build_dir, leave = False):
- """Initialize the kernel build environment
+ def __init__(self, job, base_tree, subdir, tmp_dir, build_dir, leave = False):
+ """Initialize the kernel build environment
- job
- which job this build is part of
- base_tree
- base kernel tree. Can be one of the following:
- 1. A local tarball
- 2. A URL to a tarball
- 3. A local directory (will symlink it)
- 4. A shorthand expandable (eg '2.6.11-git3')
- subdir
- subdir in the results directory (eg "build")
- (holds config/, debug/, results/)
- tmp_dir
+ job
+ which job this build is part of
+ base_tree
+ base kernel tree. Can be one of the following:
+ 1. A local tarball
+ 2. A URL to a tarball
+ 3. A local directory (will symlink it)
+ 4. A shorthand expandable (eg '2.6.11-git3')
+ subdir
+ subdir in the results directory (eg "build")
+ (holds config/, debug/, results/)
+ tmp_dir
- leave
- Boolean, whether to leave existing tmpdir or not
- """
- self.job = job
- self.autodir = job.autodir
+ leave
+ Boolean, whether to leave existing tmpdir or not
+ """
+ self.job = job
+ self.autodir = job.autodir
- self.src_dir = os.path.join(tmp_dir, 'src')
- self.build_dir = os.path.join(tmp_dir, build_dir)
- # created by get_kernel_tree
- self.config_dir = os.path.join(subdir, 'config')
- self.log_dir = os.path.join(subdir, 'debug')
- self.results_dir = os.path.join(subdir, 'results')
- self.subdir = os.path.basename(subdir)
+ self.src_dir = os.path.join(tmp_dir, 'src')
+ self.build_dir = os.path.join(tmp_dir, build_dir)
+ # created by get_kernel_tree
+ self.config_dir = os.path.join(subdir, 'config')
+ self.log_dir = os.path.join(subdir, 'debug')
+ self.results_dir = os.path.join(subdir, 'results')
+ self.subdir = os.path.basename(subdir)
- self.installed_as = None
+ self.installed_as = None
- if not leave:
- if os.path.isdir(self.src_dir):
- utils.system('rm -rf ' + self.src_dir)
- if os.path.isdir(self.build_dir):
- utils.system('rm -rf ' + self.build_dir)
+ if not leave:
+ if os.path.isdir(self.src_dir):
+ utils.system('rm -rf ' + self.src_dir)
+ if os.path.isdir(self.build_dir):
+ utils.system('rm -rf ' + self.build_dir)
- if not os.path.exists(self.src_dir):
- os.mkdir(self.src_dir)
- for path in [self.config_dir, self.log_dir, self.results_dir]:
- if os.path.exists(path):
- utils.system('rm -rf ' + path)
- os.mkdir(path)
+ if not os.path.exists(self.src_dir):
+ os.mkdir(self.src_dir)
+ for path in [self.config_dir, self.log_dir, self.results_dir]:
+ if os.path.exists(path):
+ utils.system('rm -rf ' + path)
+ os.mkdir(path)
- logpath = os.path.join(self.log_dir, 'build_log')
- self.logfile = open(logpath, 'w+')
- self.applied_patches = []
+ logpath = os.path.join(self.log_dir, 'build_log')
+ self.logfile = open(logpath, 'w+')
+ self.applied_patches = []
- self.target_arch = None
- self.build_target = 'bzImage'
- self.build_image = None
+ self.target_arch = None
+ self.build_target = 'bzImage'
+ self.build_image = None
- arch = autotest_utils.get_current_kernel_arch()
- if arch == 's390' or arch == 's390x':
- self.build_target = 'image'
- elif arch == 'ia64':
- self.build_target = 'all'
- self.build_image = 'vmlinux.gz'
+ arch = autotest_utils.get_current_kernel_arch()
+ if arch == 's390' or arch == 's390x':
+ self.build_target = 'image'
+ elif arch == 'ia64':
+ self.build_target = 'all'
+ self.build_image = 'vmlinux.gz'
- if leave:
- return
+ if leave:
+ return
- self.logfile.write('BASE: %s\n' % base_tree)
+ self.logfile.write('BASE: %s\n' % base_tree)
- # Where we have direct version hint record that
- # for later configuration selection.
- shorthand = re.compile(r'^\d+\.\d+\.\d+')
- if shorthand.match(base_tree):
- self.base_tree_version = base_tree
- else:
- self.base_tree_version = None
-
- # Actually extract the tree. Make sure we know it occured
- self.extract(base_tree)
+ # Where we have direct version hint record that
+ # for later configuration selection.
+ shorthand = re.compile(r'^\d+\.\d+\.\d+')
+ if shorthand.match(base_tree):
+ self.base_tree_version = base_tree
+ else:
+ self.base_tree_version = None
+ # Actually extract the tree. Make sure we know it occured
+ self.extract(base_tree)
- def kernelexpand(self, kernel):
- # If we have something like a path, just use it as it is
- if '/' in kernel:
- return [kernel]
- # Find the configured mirror list.
- mirrors = self.job.config_get('mirror.mirrors')
- if not mirrors:
- # LEGACY: convert the kernel.org mirror
- mirror = self.job.config_get('mirror.ftp_kernel_org')
- if mirror:
- korg = 'http://www.kernel.org/pub/linux/kernel'
- mirrors = [
- [ korg + '/v2.6', mirror + '/v2.6' ],
- [ korg + '/people/akpm/patches/2.6',
- mirror + '/akpm' ],
- [ korg + '/people/mbligh',
- mirror + '/mbligh' ],
- ]
+ def kernelexpand(self, kernel):
+ # If we have something like a path, just use it as it is
+ if '/' in kernel:
+ return [kernel]
- patches = kernelexpand.expand_classic(kernel, mirrors)
- print patches
+ # Find the configured mirror list.
+ mirrors = self.job.config_get('mirror.mirrors')
+ if not mirrors:
+ # LEGACY: convert the kernel.org mirror
+ mirror = self.job.config_get('mirror.ftp_kernel_org')
+ if mirror:
+ korg = 'http://www.kernel.org/pub/linux/kernel'
+ mirrors = [
+ [ korg + '/v2.6', mirror + '/v2.6' ],
+ [ korg + '/people/akpm/patches/2.6',
+ mirror + '/akpm' ],
+ [ korg + '/people/mbligh',
+ mirror + '/mbligh' ],
+ ]
- return patches
+ patches = kernelexpand.expand_classic(kernel, mirrors)
+ print patches
+ return patches
- @logging.record
- @tee_output_logdir_mark
- def extract(self, base_tree):
- if os.path.exists(base_tree):
- self.get_kernel_tree(base_tree)
- else:
- base_components = self.kernelexpand(base_tree)
- print 'kernelexpand: '
- print base_components
- self.get_kernel_tree(base_components.pop(0))
- if base_components: # apply remaining patches
- self.patch(*base_components)
+ @logging.record
+ @tee_output_logdir_mark
+ def extract(self, base_tree):
+ if os.path.exists(base_tree):
+ self.get_kernel_tree(base_tree)
+ else:
+ base_components = self.kernelexpand(base_tree)
+ print 'kernelexpand: '
+ print base_components
+ self.get_kernel_tree(base_components.pop(0))
+ if base_components: # apply remaining patches
+ self.patch(*base_components)
- @logging.record
- @tee_output_logdir_mark
- def patch(self, *patches):
- """Apply a list of patches (in order)"""
- if not patches:
- return
- print 'Applying patches: ', patches
- self.apply_patches(self.get_patches(patches))
+ @logging.record
+ @tee_output_logdir_mark
+ def patch(self, *patches):
+ """Apply a list of patches (in order)"""
+ if not patches:
+ return
+ print 'Applying patches: ', patches
+ self.apply_patches(self.get_patches(patches))
- @logging.record
- @tee_output_logdir_mark
- def config(self, config_file = '', config_list = None, defconfig = False):
- self.set_cross_cc()
- config = kernel_config.kernel_config(self.job, self.build_dir,
- self.config_dir, config_file, config_list,
- defconfig, self.base_tree_version)
+ @logging.record
+ @tee_output_logdir_mark
+ def config(self, config_file = '', config_list = None, defconfig = False):
+ self.set_cross_cc()
+ config = kernel_config.kernel_config(self.job, self.build_dir,
+ self.config_dir, config_file, config_list,
+ defconfig, self.base_tree_version)
- def get_patches(self, patches):
- """fetch the patches to the local src_dir"""
- local_patches = []
- for patch in patches:
- dest = os.path.join(self.src_dir, basename(patch))
- # FIXME: this isn't unique. Append something to it
- # like wget does if it's not there?
- print "get_file %s %s %s %s" % (patch, dest, self.src_dir, basename(patch))
- utils.get_file(patch, dest)
- # probably safer to use the command, not python library
- md5sum = utils.system_output('md5sum ' + dest).split()[0]
- local_patches.append((patch, dest, md5sum))
- return local_patches
+ def get_patches(self, patches):
+ """fetch the patches to the local src_dir"""
+ local_patches = []
+ for patch in patches:
+ dest = os.path.join(self.src_dir, basename(patch))
+ # FIXME: this isn't unique. Append something to it
+ # like wget does if it's not there?
+ print "get_file %s %s %s %s" % (patch, dest, self.src_dir, basename(patch))
+ utils.get_file(patch, dest)
+ # probably safer to use the command, not python library
+ md5sum = utils.system_output('md5sum ' + dest).split()[0]
+ local_patches.append((patch, dest, md5sum))
+ return local_patches
- def apply_patches(self, local_patches):
- """apply the list of patches, in order"""
- builddir = self.build_dir
- os.chdir(builddir)
- if not local_patches:
- return None
- for (spec, local, md5sum) in local_patches:
- if local.endswith('.bz2') or local.endswith('.gz'):
- ref = spec
- else:
- ref = force_copy(local, self.results_dir)
- ref = self.job.relative_path(ref)
- patch_id = "%s %s %s" % (spec, ref, md5sum)
- log = "PATCH: " + patch_id + "\n"
- print log
- cat_file_to_cmd(local, 'patch -p1 > /dev/null')
- self.logfile.write(log)
- self.applied_patches.append(patch_id)
+ def apply_patches(self, local_patches):
+ """apply the list of patches, in order"""
+ builddir = self.build_dir
+ os.chdir(builddir)
+ if not local_patches:
+ return None
+ for (spec, local, md5sum) in local_patches:
+ if local.endswith('.bz2') or local.endswith('.gz'):
+ ref = spec
+ else:
+ ref = force_copy(local, self.results_dir)
+ ref = self.job.relative_path(ref)
+ patch_id = "%s %s %s" % (spec, ref, md5sum)
+ log = "PATCH: " + patch_id + "\n"
+ print log
+ cat_file_to_cmd(local, 'patch -p1 > /dev/null')
+ self.logfile.write(log)
+ self.applied_patches.append(patch_id)
- def get_kernel_tree(self, base_tree):
- """Extract/link base_tree to self.build_dir"""
-
- # if base_tree is a dir, assume uncompressed kernel
- if os.path.isdir(base_tree):
- print 'Symlinking existing kernel source'
- os.symlink(base_tree, self.build_dir)
- # otherwise, extract tarball
- else:
- os.chdir(os.path.dirname(self.src_dir))
- # Figure out local destination for tarball
- tarball = os.path.join(self.src_dir, os.path.basename(base_tree))
- utils.get_file(base_tree, tarball)
- print 'Extracting kernel tarball:', tarball, '...'
- autotest_utils.extract_tarball_to_dir(tarball,
- self.build_dir)
+ def get_kernel_tree(self, base_tree):
+ """Extract/link base_tree to self.build_dir"""
+ # if base_tree is a dir, assume uncompressed kernel
+ if os.path.isdir(base_tree):
+ print 'Symlinking existing kernel source'
+ os.symlink(base_tree, self.build_dir)
- def extraversion(self, tag, append=1):
- os.chdir(self.build_dir)
- extraversion_sub = r's/^EXTRAVERSION =\s*\(.*\)/EXTRAVERSION = '
- if append:
- p = extraversion_sub + '\\1-%s/' % tag
- else:
- p = extraversion_sub + '-%s/' % tag
- utils.system('mv Makefile Makefile.old')
- utils.system('sed "%s" < Makefile.old > Makefile' % p)
+ # otherwise, extract tarball
+ else:
+ os.chdir(os.path.dirname(self.src_dir))
+ # Figure out local destination for tarball
+ tarball = os.path.join(self.src_dir, os.path.basename(base_tree))
+ utils.get_file(base_tree, tarball)
+ print 'Extracting kernel tarball:', tarball, '...'
+ autotest_utils.extract_tarball_to_dir(tarball,
+ self.build_dir)
- @logging.record
- @tee_output_logdir_mark
- def build(self, make_opts = '', logfile = '', extraversion='autotest'):
- """build the kernel
+ def extraversion(self, tag, append=1):
+ os.chdir(self.build_dir)
+ extraversion_sub = r's/^EXTRAVERSION =\s*\(.*\)/EXTRAVERSION = '
+ if append:
+ p = extraversion_sub + '\\1-%s/' % tag
+ else:
+ p = extraversion_sub + '-%s/' % tag
+ utils.system('mv Makefile Makefile.old')
+ utils.system('sed "%s" < Makefile.old > Makefile' % p)
- make_opts
- additional options to make, if any
- """
- os_dep.commands('gcc', 'make')
- if logfile == '':
- logfile = os.path.join(self.log_dir, 'kernel_build')
- os.chdir(self.build_dir)
- if extraversion:
- self.extraversion(extraversion)
- self.set_cross_cc()
- # setup_config_file(config_file, config_overrides)
- # Not needed on 2.6, but hard to tell -- handle failure
- utils.system('make dep', ignore_status=True)
- threads = 2 * autotest_utils.count_cpus()
- build_string = 'make -j %d %s %s' % (threads, make_opts,
- self.build_target)
- # eg make bzImage, or make zImage
- print build_string
- system(build_string)
- if kernel_config.modules_needed('.config'):
- utils.system('make -j %d modules' % (threads))
+ @logging.record
+ @tee_output_logdir_mark
+ def build(self, make_opts = '', logfile = '', extraversion='autotest'):
+ """build the kernel
- kernel_version = self.get_kernel_build_ver()
- kernel_version = re.sub('-autotest', '', kernel_version)
- self.logfile.write('BUILD VERSION: %s\n' % kernel_version)
+ make_opts
+ additional options to make, if any
+ """
+ os_dep.commands('gcc', 'make')
+ if logfile == '':
+ logfile = os.path.join(self.log_dir, 'kernel_build')
+ os.chdir(self.build_dir)
+ if extraversion:
+ self.extraversion(extraversion)
+ self.set_cross_cc()
+ # setup_config_file(config_file, config_overrides)
- force_copy(self.build_dir+'/System.map', self.results_dir)
+ # Not needed on 2.6, but hard to tell -- handle failure
+ utils.system('make dep', ignore_status=True)
+ threads = 2 * autotest_utils.count_cpus()
+ build_string = 'make -j %d %s %s' % (threads, make_opts,
+ self.build_target)
+ # eg make bzImage, or make zImage
+ print build_string
+ system(build_string)
+ if kernel_config.modules_needed('.config'):
+ utils.system('make -j %d modules' % (threads))
+ kernel_version = self.get_kernel_build_ver()
+ kernel_version = re.sub('-autotest', '', kernel_version)
+ self.logfile.write('BUILD VERSION: %s\n' % kernel_version)
- def build_timed(self, threads, timefile = '/dev/null', make_opts = '',
- output = '/dev/null'):
- """time the bulding of the kernel"""
- os.chdir(self.build_dir)
- self.set_cross_cc()
+ force_copy(self.build_dir+'/System.map', self.results_dir)
- self.clean(logged=False)
- build_string = "/usr/bin/time -o %s make %s -j %s vmlinux" \
- % (timefile, make_opts, threads)
- build_string += ' > %s 2>&1' % output
- print build_string
- utils.system(build_string)
- if (not os.path.isfile('vmlinux')):
- errmsg = "no vmlinux found, kernel build failed"
- raise error.TestError(errmsg)
+ def build_timed(self, threads, timefile = '/dev/null', make_opts = '',
+ output = '/dev/null'):
+ """time the bulding of the kernel"""
+ os.chdir(self.build_dir)
+ self.set_cross_cc()
+
+ self.clean(logged=False)
+ build_string = "/usr/bin/time -o %s make %s -j %s vmlinux" \
+ % (timefile, make_opts, threads)
+ build_string += ' > %s 2>&1' % output
+ print build_string
+ utils.system(build_string)
+
+ if (not os.path.isfile('vmlinux')):
+ errmsg = "no vmlinux found, kernel build failed"
+ raise error.TestError(errmsg)
+
+
+ @logging.record
+ @tee_output_logdir_mark
+ def clean(self):
+ """make clean in the kernel tree"""
+ os.chdir(self.build_dir)
+ print "make clean"
+ utils.system('make clean > /dev/null 2> /dev/null')
+
+
+ @logging.record
+ @tee_output_logdir_mark
+ def mkinitrd(self, version, image, system_map, initrd):
+ """Build kernel initrd image.
+ Try to use distro specific way to build initrd image.
+ Parameters:
+ version
+ new kernel version
+ image
+ new kernel image file
+ system_map
+ System.map file
+ initrd
+ initrd image file to build
+ """
+ vendor = autotest_utils.get_os_vendor()
+ if os.path.isfile(initrd):
+ print "Existing %s file, will remove it." % initrd
+ os.remove(initrd)
- @logging.record
- @tee_output_logdir_mark
- def clean(self):
- """make clean in the kernel tree"""
- os.chdir(self.build_dir)
- print "make clean"
- utils.system('make clean > /dev/null 2> /dev/null')
+ args = self.job.config_get('kernel.mkinitrd_extra_args')
+ # don't leak 'None' into mkinitrd command
+ if not args:
+ args = ''
- @logging.record
- @tee_output_logdir_mark
- def mkinitrd(self, version, image, system_map, initrd):
- """Build kernel initrd image.
- Try to use distro specific way to build initrd image.
- Parameters:
- version
- new kernel version
- image
- new kernel image file
- system_map
- System.map file
- initrd
- initrd image file to build
- """
- vendor = autotest_utils.get_os_vendor()
-
- if os.path.isfile(initrd):
- print "Existing %s file, will remove it." % initrd
- os.remove(initrd)
+ if vendor in ['Red Hat', 'Fedora Core']:
+ utils.system('mkinitrd %s %s %s' % (args, initrd, version))
+ elif vendor in ['SUSE']:
+ utils.system('mkinitrd %s -k %s -i %s -M %s' % (args, image, initrd, system_map))
+ elif vendor in ['Debian', 'Ubuntu']:
+ if os.path.isfile('/usr/sbin/mkinitrd'):
+ cmd = '/usr/sbin/mkinitrd'
+ elif os.path.isfile('/usr/sbin/mkinitramfs'):
+ cmd = '/usr/sbin/mkinitramfs'
+ else:
+ raise error.TestError('No Debian initrd builder')
+ utils.system('%s %s -o %s %s' % (cmd, args, initrd, version))
+ else:
+ raise error.TestError('Unsupported vendor %s' % vendor)
- args = self.job.config_get('kernel.mkinitrd_extra_args')
- # don't leak 'None' into mkinitrd command
- if not args:
- args = ''
+ def set_build_image(self, image):
+ self.build_image = image
- if vendor in ['Red Hat', 'Fedora Core']:
- utils.system('mkinitrd %s %s %s' % (args, initrd, version))
- elif vendor in ['SUSE']:
- utils.system('mkinitrd %s -k %s -i %s -M %s' % (args, image, initrd, system_map))
- elif vendor in ['Debian', 'Ubuntu']:
- if os.path.isfile('/usr/sbin/mkinitrd'):
- cmd = '/usr/sbin/mkinitrd'
- elif os.path.isfile('/usr/sbin/mkinitramfs'):
- cmd = '/usr/sbin/mkinitramfs'
- else:
- raise error.TestError('No Debian initrd builder')
- utils.system('%s %s -o %s %s' % (cmd, args, initrd, version))
- else:
- raise error.TestError('Unsupported vendor %s' % vendor)
+ @logging.record
+ @tee_output_logdir_mark
+ def install(self, tag='autotest', prefix = '/'):
+ """make install in the kernel tree"""
- def set_build_image(self, image):
- self.build_image = image
+ # Record that we have installed the kernel, and
+ # the tag under which we installed it.
+ self.installed_as = tag
+ os.chdir(self.build_dir)
- @logging.record
- @tee_output_logdir_mark
- def install(self, tag='autotest', prefix = '/'):
- """make install in the kernel tree"""
+ if not os.path.isdir(prefix):
+ os.mkdir(prefix)
+ self.boot_dir = os.path.join(prefix, 'boot')
+ if not os.path.isdir(self.boot_dir):
+ os.mkdir(self.boot_dir)
- # Record that we have installed the kernel, and
- # the tag under which we installed it.
- self.installed_as = tag
+ if not self.build_image:
+ images = glob.glob('arch/*/boot/' + self.build_target)
+ if len(images):
+ self.build_image = images[0]
+ else:
+ self.build_image = self.build_target
- os.chdir(self.build_dir)
+ # remember installed files
+ self.vmlinux = self.boot_dir + '/vmlinux-' + tag
+ if (self.build_image != 'vmlinux'):
+ self.image = self.boot_dir + '/vmlinuz-' + tag
+ else:
+ self.image = self.vmlinux
+ self.system_map = self.boot_dir + '/System.map-' + tag
+ self.config = self.boot_dir + '/config-' + tag
+ self.initrd = ''
- if not os.path.isdir(prefix):
- os.mkdir(prefix)
- self.boot_dir = os.path.join(prefix, 'boot')
- if not os.path.isdir(self.boot_dir):
- os.mkdir(self.boot_dir)
+ # copy to boot dir
+ autotest_utils.force_copy('vmlinux', self.vmlinux)
+ if (self.build_image != 'vmlinux'):
+ force_copy(self.build_image, self.image)
+ autotest_utils.force_copy('System.map', self.system_map)
+ autotest_utils.force_copy('.config', self.config)
- if not self.build_image:
- images = glob.glob('arch/*/boot/' + self.build_target)
- if len(images):
- self.build_image = images[0]
- else:
- self.build_image = self.build_target
+ if not kernel_config.modules_needed('.config'):
+ return
- # remember installed files
- self.vmlinux = self.boot_dir + '/vmlinux-' + tag
- if (self.build_image != 'vmlinux'):
- self.image = self.boot_dir + '/vmlinuz-' + tag
- else:
- self.image = self.vmlinux
- self.system_map = self.boot_dir + '/System.map-' + tag
- self.config = self.boot_dir + '/config-' + tag
- self.initrd = ''
+ utils.system('make modules_install INSTALL_MOD_PATH=%s' % prefix)
+ if prefix == '/':
+ self.initrd = self.boot_dir + '/initrd-' + tag
+ self.mkinitrd(self.get_kernel_build_ver(), self.image,
+ self.system_map, self.initrd)
- # copy to boot dir
- autotest_utils.force_copy('vmlinux', self.vmlinux)
- if (self.build_image != 'vmlinux'):
- force_copy(self.build_image, self.image)
- autotest_utils.force_copy('System.map', self.system_map)
- autotest_utils.force_copy('.config', self.config)
- if not kernel_config.modules_needed('.config'):
- return
+ def add_to_bootloader(self, tag='autotest', args=''):
+ """ add this kernel to bootloader, taking an
+ optional parameter of space separated parameters
+ e.g.: kernel.add_to_bootloader('mykernel', 'ro acpi=off')
+ """
- utils.system('make modules_install INSTALL_MOD_PATH=%s' % prefix)
- if prefix == '/':
- self.initrd = self.boot_dir + '/initrd-' + tag
- self.mkinitrd(self.get_kernel_build_ver(), self.image,
- self.system_map, self.initrd)
+ # remove existing entry if present
+ self.job.bootloader.remove_kernel(tag)
+ # pull the base argument set from the job config,
+ baseargs = self.job.config_get('boot.default_args')
+ if baseargs:
+ args = baseargs + " " + args
- def add_to_bootloader(self, tag='autotest', args=''):
- """ add this kernel to bootloader, taking an
- optional parameter of space separated parameters
- e.g.: kernel.add_to_bootloader('mykernel', 'ro acpi=off')
- """
+ # otherwise populate from /proc/cmdline
+ # if not baseargs:
+ # baseargs = open('/proc/cmdline', 'r').readline().strip()
+ # NOTE: This is unnecessary, because boottool does it.
- # remove existing entry if present
- self.job.bootloader.remove_kernel(tag)
+ root = None
+ roots = [x for x in args.split() if x.startswith('root=')]
+ if roots:
+ root = re.sub('^root=', '', roots[0])
+ arglist = [x for x in args.split() if not x.startswith('root=')]
+ args = ' '.join(arglist)
- # pull the base argument set from the job config,
- baseargs = self.job.config_get('boot.default_args')
- if baseargs:
- args = baseargs + " " + args
-
- # otherwise populate from /proc/cmdline
- # if not baseargs:
- # baseargs = open('/proc/cmdline', 'r').readline().strip()
- # NOTE: This is unnecessary, because boottool does it.
+ # add the kernel entry
+ # add_kernel(image, title='autotest', initrd='')
+ self.job.bootloader.add_kernel(self.image, tag, self.initrd, \
+ args = args, root = root)
- root = None
- roots = [x for x in args.split() if x.startswith('root=')]
- if roots:
- root = re.sub('^root=', '', roots[0])
- arglist = [x for x in args.split() if not x.startswith('root=')]
- args = ' '.join(arglist)
- # add the kernel entry
- # add_kernel(image, title='autotest', initrd='')
- self.job.bootloader.add_kernel(self.image, tag, self.initrd, \
- args = args, root = root)
+ def get_kernel_build_arch(self, arch=None):
+ """
+ Work out the current kernel architecture (as a kernel arch)
+ """
+ if not arch:
+ arch = autotest_utils.get_current_kernel_arch()
+ if re.match('i.86', arch):
+ return 'i386'
+ elif re.match('sun4u', arch):
+ return 'sparc64'
+ elif re.match('arm.*', arch):
+ return 'arm'
+ elif re.match('sa110', arch):
+ return 'arm'
+ elif re.match('s390x', arch):
+ return 's390'
+ elif re.match('parisc64', arch):
+ return 'parisc'
+ elif re.match('ppc.*', arch):
+ return 'powerpc'
+ elif re.match('mips.*', arch):
+ return 'mips'
+ else:
+ return arch
- def get_kernel_build_arch(self, arch=None):
- """
- Work out the current kernel architecture (as a kernel arch)
- """
- if not arch:
- arch = autotest_utils.get_current_kernel_arch()
- if re.match('i.86', arch):
- return 'i386'
- elif re.match('sun4u', arch):
- return 'sparc64'
- elif re.match('arm.*', arch):
- return 'arm'
- elif re.match('sa110', arch):
- return 'arm'
- elif re.match('s390x', arch):
- return 's390'
- elif re.match('parisc64', arch):
- return 'parisc'
- elif re.match('ppc.*', arch):
- return 'powerpc'
- elif re.match('mips.*', arch):
- return 'mips'
- else:
- return arch
+ def get_kernel_build_release(self):
+ releasem = re.compile(r'.*UTS_RELEASE\s+"([^"]+)".*');
+ versionm = re.compile(r'.*UTS_VERSION\s+"([^"]+)".*');
+ release = None
+ version = None
- def get_kernel_build_release(self):
- releasem = re.compile(r'.*UTS_RELEASE\s+"([^"]+)".*');
- versionm = re.compile(r'.*UTS_VERSION\s+"([^"]+)".*');
+ for file in [ self.build_dir + "/include/linux/version.h",
+ self.build_dir + "/include/linux/utsrelease.h",
+ self.build_dir + "/include/linux/compile.h" ]:
+ if os.path.exists(file):
+ fd = open(file, 'r')
+ for line in fd.readlines():
+ m = releasem.match(line)
+ if m:
+ release = m.groups()[0]
+ m = versionm.match(line)
+ if m:
+ version = m.groups()[0]
+ fd.close()
- release = None
- version = None
+ return (release, version)
- for file in [ self.build_dir + "/include/linux/version.h",
- self.build_dir + "/include/linux/utsrelease.h",
- self.build_dir + "/include/linux/compile.h" ]:
- if os.path.exists(file):
- fd = open(file, 'r')
- for line in fd.readlines():
- m = releasem.match(line)
- if m:
- release = m.groups()[0]
- m = versionm.match(line)
- if m:
- version = m.groups()[0]
- fd.close()
- return (release, version)
+ def get_kernel_build_ident(self):
+ (release, version) = self.get_kernel_build_release()
-
- def get_kernel_build_ident(self):
- (release, version) = self.get_kernel_build_release()
+ if not release or not version:
+ raise error.JobError('kernel has no identity')
- if not release or not version:
- raise error.JobError('kernel has no identity')
+ return release + '::' + version
- return release + '::' + version
+ def boot(self, args='', ident=1):
+ """ install and boot this kernel, do not care how
+ just make it happen.
+ """
- def boot(self, args='', ident=1):
- """ install and boot this kernel, do not care how
- just make it happen.
- """
+ # If we can check the kernel identity do so.
+ if ident:
+ when = int(time.time())
+ ident = self.get_kernel_build_ident()
+ args += " IDENT=%d" % (when)
- # If we can check the kernel identity do so.
- if ident:
- when = int(time.time())
- ident = self.get_kernel_build_ident()
- args += " IDENT=%d" % (when)
+ self.job.next_step_prepend(["job.kernel_check_ident",
+ when, ident, self.subdir,
+ self.applied_patches])
- self.job.next_step_prepend(["job.kernel_check_ident",
- when, ident, self.subdir,
- self.applied_patches])
+ # Check if the kernel has been installed, if not install
+ # as the default tag and boot that.
+ if not self.installed_as:
+ self.install()
- # Check if the kernel has been installed, if not install
- # as the default tag and boot that.
- if not self.installed_as:
- self.install()
+ # Boot the selected tag.
+ self.add_to_bootloader(args=args, tag=self.installed_as)
- # Boot the selected tag.
- self.add_to_bootloader(args=args, tag=self.installed_as)
+ # Boot it.
+ self.job.reboot(tag=self.installed_as)
- # Boot it.
- self.job.reboot(tag=self.installed_as)
+ def get_kernel_build_ver(self):
+ """Check Makefile and .config to return kernel version"""
+ version = patchlevel = sublevel = extraversion = localversion = ''
- def get_kernel_build_ver(self):
- """Check Makefile and .config to return kernel version"""
- version = patchlevel = sublevel = extraversion = localversion = ''
+ for line in open(self.build_dir + '/Makefile', 'r').readlines():
+ if line.startswith('VERSION'):
+ version = line[line.index('=') + 1:].strip()
+ if line.startswith('PATCHLEVEL'):
+ patchlevel = line[line.index('=') + 1:].strip()
+ if line.startswith('SUBLEVEL'):
+ sublevel = line[line.index('=') + 1:].strip()
+ if line.startswith('EXTRAVERSION'):
+ extraversion = line[line.index('=') + 1:].strip()
- for line in open(self.build_dir + '/Makefile', 'r').readlines():
- if line.startswith('VERSION'):
- version = line[line.index('=') + 1:].strip()
- if line.startswith('PATCHLEVEL'):
- patchlevel = line[line.index('=') + 1:].strip()
- if line.startswith('SUBLEVEL'):
- sublevel = line[line.index('=') + 1:].strip()
- if line.startswith('EXTRAVERSION'):
- extraversion = line[line.index('=') + 1:].strip()
+ for line in open(self.build_dir + '/.config', 'r').readlines():
+ if line.startswith('CONFIG_LOCALVERSION='):
+ localversion = line.rstrip().split('"')[1]
- for line in open(self.build_dir + '/.config', 'r').readlines():
- if line.startswith('CONFIG_LOCALVERSION='):
- localversion = line.rstrip().split('"')[1]
+ return "%s.%s.%s%s%s" %(version, patchlevel, sublevel, extraversion, localversion)
- return "%s.%s.%s%s%s" %(version, patchlevel, sublevel, extraversion, localversion)
+ def set_build_target(self, build_target):
+ if build_target:
+ self.build_target = build_target
+ print 'BUILD TARGET: %s' % self.build_target
- def set_build_target(self, build_target):
- if build_target:
- self.build_target = build_target
- print 'BUILD TARGET: %s' % self.build_target
+ def set_cross_cc(self, target_arch=None, cross_compile=None,
+ build_target='bzImage'):
+ """Set up to cross-compile.
+ This is broken. We need to work out what the default
+ compile produces, and if not, THEN set the cross
+ compiler.
+ """
- def set_cross_cc(self, target_arch=None, cross_compile=None,
- build_target='bzImage'):
- """Set up to cross-compile.
- This is broken. We need to work out what the default
- compile produces, and if not, THEN set the cross
- compiler.
- """
+ if self.target_arch:
+ return
- if self.target_arch:
- return
+ # if someone has set build_target, don't clobber in set_cross_cc
+ # run set_build_target before calling set_cross_cc
+ if not self.build_target:
+ self.set_build_target(build_target)
- # if someone has set build_target, don't clobber in set_cross_cc
- # run set_build_target before calling set_cross_cc
- if not self.build_target:
- self.set_build_target(build_target)
+ # If no 'target_arch' given assume native compilation
+ if target_arch == None:
+ target_arch = autotest_utils.get_current_kernel_arch()
+ if target_arch == 'ppc64':
+ if self.build_target == 'bzImage':
+ self.build_target = 'vmlinux'
- # If no 'target_arch' given assume native compilation
- if target_arch == None:
- target_arch = autotest_utils.get_current_kernel_arch()
- if target_arch == 'ppc64':
- if self.build_target == 'bzImage':
- self.build_target = 'vmlinux'
+ if not cross_compile:
+ cross_compile = self.job.config_get('kernel.cross_cc')
- if not cross_compile:
- cross_compile = self.job.config_get('kernel.cross_cc')
+ if cross_compile:
+ os.environ['CROSS_COMPILE'] = cross_compile
+ else:
+ if os.environ.has_key('CROSS_COMPILE'):
+ del os.environ['CROSS_COMPILE']
- if cross_compile:
- os.environ['CROSS_COMPILE'] = cross_compile
- else:
- if os.environ.has_key('CROSS_COMPILE'):
- del os.environ['CROSS_COMPILE']
-
- return # HACK. Crap out for now.
+ return # HACK. Crap out for now.
- # At this point I know what arch I *want* to build for
- # but have no way of working out what arch the default
- # compiler DOES build for.
+ # At this point I know what arch I *want* to build for
+ # but have no way of working out what arch the default
+ # compiler DOES build for.
- # Oh, and BTW, install_package() doesn't exist yet.
+ # Oh, and BTW, install_package() doesn't exist yet.
- if target_arch == 'ppc64':
- install_package('ppc64-cross')
- cross_compile = os.path.join(self.autodir, 'sources/ppc64-cross/bin')
+ if target_arch == 'ppc64':
+ install_package('ppc64-cross')
+ cross_compile = os.path.join(self.autodir, 'sources/ppc64-cross/bin')
- elif target_arch == 'x86_64':
- install_package('x86_64-cross')
- cross_compile = os.path.join(self.autodir, 'sources/x86_64-cross/bin')
+ elif target_arch == 'x86_64':
+ install_package('x86_64-cross')
+ cross_compile = os.path.join(self.autodir, 'sources/x86_64-cross/bin')
- os.environ['ARCH'] = self.target_arch = target_arch
+ os.environ['ARCH'] = self.target_arch = target_arch
- self.cross_compile = cross_compile
- if self.cross_compile:
- os.environ['CROSS_COMPILE'] = self.cross_compile
+ self.cross_compile = cross_compile
+ if self.cross_compile:
+ os.environ['CROSS_COMPILE'] = self.cross_compile
- def pickle_dump(self, filename):
- """dump a pickle of ourself out to the specified filename
+ def pickle_dump(self, filename):
+ """dump a pickle of ourself out to the specified filename
- we can't pickle the backreference to job (it contains fd's),
- nor would we want to. Same for logfile (fd's).
- """
- temp = copy.copy(self)
- temp.job = None
- temp.logfile = None
- pickle.dump(temp, open(filename, 'w'))
+ we can't pickle the backreference to job (it contains fd's),
+ nor would we want to. Same for logfile (fd's).
+ """
+ temp = copy.copy(self)
+ temp.job = None
+ temp.logfile = None
+ pickle.dump(temp, open(filename, 'w'))
class rpm_kernel:
- """ Class for installing rpm kernel package
- """
+ """ Class for installing rpm kernel package
+ """
- def __init__(self, job, rpm_package, subdir):
- self.job = job
- self.rpm_package = rpm_package
- self.log_dir = os.path.join(subdir, 'debug')
- self.subdir = os.path.basename(subdir)
- if os.path.exists(self.log_dir):
- utils.system('rm -rf ' + self.log_dir)
- os.mkdir(self.log_dir)
- self.installed_as = None
+ def __init__(self, job, rpm_package, subdir):
+ self.job = job
+ self.rpm_package = rpm_package
+ self.log_dir = os.path.join(subdir, 'debug')
+ self.subdir = os.path.basename(subdir)
+ if os.path.exists(self.log_dir):
+ utils.system('rm -rf ' + self.log_dir)
+ os.mkdir(self.log_dir)
+ self.installed_as = None
- @logging.record
- @tee_output_logdir_mark
- def install(self, tag='autotest'):
- self.installed_as = tag
+ @logging.record
+ @tee_output_logdir_mark
+ def install(self, tag='autotest'):
+ self.installed_as = tag
- self.rpm_name = utils.system_output('rpm -qp ' + self.rpm_package)
+ self.rpm_name = utils.system_output('rpm -qp ' + self.rpm_package)
- # install
- utils.system('rpm -i --force ' + self.rpm_package)
+ # install
+ utils.system('rpm -i --force ' + self.rpm_package)
- # get file list
- files = utils.system_output('rpm -ql ' + self.rpm_name).splitlines()
+ # get file list
+ files = utils.system_output('rpm -ql ' + self.rpm_name).splitlines()
- # search for vmlinuz
- for file in files:
- if file.startswith('/boot/vmlinuz'):
- self.image = file
- break
- else:
- errmsg = "%s doesn't contain /boot/vmlinuz"
- errmsg %= self.rpm_package
- raise error.TestError(errmsg)
+ # search for vmlinuz
+ for file in files:
+ if file.startswith('/boot/vmlinuz'):
+ self.image = file
+ break
+ else:
+ errmsg = "%s doesn't contain /boot/vmlinuz"
+ errmsg %= self.rpm_package
+ raise error.TestError(errmsg)
- # search for initrd
- self.initrd = ''
- for file in files:
- if file.startswith('/boot/initrd'):
- self.initrd = file
- break
+ # search for initrd
+ self.initrd = ''
+ for file in files:
+ if file.startswith('/boot/initrd'):
+ self.initrd = file
+ break
- # get version and release number
- self.version, self.release = utils.system_output(
- 'rpm --queryformat="%{VERSION}\\n%{RELEASE}\\n" -q ' + self.rpm_name).splitlines()[0:2]
+ # get version and release number
+ self.version, self.release = utils.system_output(
+ 'rpm --queryformat="%{VERSION}\\n%{RELEASE}\\n" -q ' + self.rpm_name).splitlines()[0:2]
- def add_to_bootloader(self, tag='autotest', args=''):
- """ Add this kernel to bootloader
- """
+ def add_to_bootloader(self, tag='autotest', args=''):
+ """ Add this kernel to bootloader
+ """
- # remove existing entry if present
- self.job.bootloader.remove_kernel(tag)
+ # remove existing entry if present
+ self.job.bootloader.remove_kernel(tag)
- # pull the base argument set from the job config
- baseargs = self.job.config_get('boot.default_args')
- if baseargs:
- args = baseargs + ' ' + args
+ # pull the base argument set from the job config
+ baseargs = self.job.config_get('boot.default_args')
+ if baseargs:
+ args = baseargs + ' ' + args
- # otherwise populate from /proc/cmdline
- # if not baseargs:
- # baseargs = open('/proc/cmdline', 'r').readline().strip()
- # NOTE: This is unnecessary, because boottool does it.
+ # otherwise populate from /proc/cmdline
+ # if not baseargs:
+ # baseargs = open('/proc/cmdline', 'r').readline().strip()
+ # NOTE: This is unnecessary, because boottool does it.
- root = None
- roots = [x for x in args.split() if x.startswith('root=')]
- if roots:
- root = re.sub('^root=', '', roots[0])
- arglist = [x for x in args.split() if not x.startswith('root=')]
- args = ' '.join(arglist)
+ root = None
+ roots = [x for x in args.split() if x.startswith('root=')]
+ if roots:
+ root = re.sub('^root=', '', roots[0])
+ arglist = [x for x in args.split() if not x.startswith('root=')]
+ args = ' '.join(arglist)
- # add the kernel entry
- self.job.bootloader.add_kernel(self.image, tag, self.initrd, args = args, root = root)
+ # add the kernel entry
+ self.job.bootloader.add_kernel(self.image, tag, self.initrd, args = args, root = root)
- def boot(self, args='', ident=1):
- """ install and boot this kernel
- """
+ def boot(self, args='', ident=1):
+ """ install and boot this kernel
+ """
- # Check if the kernel has been installed, if not install
- # as the default tag and boot that.
- if not self.installed_as:
- self.install()
+ # Check if the kernel has been installed, if not install
+ # as the default tag and boot that.
+ if not self.installed_as:
+ self.install()
- # If we can check the kernel identity do so.
- if ident:
- when = int(time.time())
- ident = '-'.join([self.version,
- self.rpm_name.split('-')[1],
- self.release])
- args += " IDENT=%d" % (when)
+ # If we can check the kernel identity do so.
+ if ident:
+ when = int(time.time())
+ ident = '-'.join([self.version,
+ self.rpm_name.split('-')[1],
+ self.release])
+ args += " IDENT=%d" % (when)
- self.job.next_step_prepend(["job.kernel_check_ident",
- when, ident, self.subdir, 'rpm'])
+ self.job.next_step_prepend(["job.kernel_check_ident",
+ when, ident, self.subdir, 'rpm'])
- # Boot the selected tag.
- self.add_to_bootloader(args=args, tag=self.installed_as)
+ # Boot the selected tag.
+ self.add_to_bootloader(args=args, tag=self.installed_as)
- # Boot it.
- self.job.reboot(tag=self.installed_as)
+ # Boot it.
+ self.job.reboot(tag=self.installed_as)
# pull in some optional site-specific path pre-processing
try:
- import site_kernel
- preprocess_path = site_kernel.preprocess_path
- del site_kernel
+ import site_kernel
+ preprocess_path = site_kernel.preprocess_path
+ del site_kernel
except ImportError:
- # just make the preprocessor a nop
- def preprocess_path(path):
- return path
+ # just make the preprocessor a nop
+ def preprocess_path(path):
+ return path
def auto_kernel(job, path, subdir, tmp_dir, build_dir, leave=False):
- """\
- Create a kernel object, dynamically selecting the appropriate class to use
- based on the path provided.
- """
- path = preprocess_path(path)
- if path.endswith('.rpm'):
- return rpm_kernel(job, path, subdir)
- else:
- return kernel(job, path, subdir, tmp_dir, build_dir, leave)
+ """\
+ Create a kernel object, dynamically selecting the appropriate class to use
+ based on the path provided.
+ """
+ path = preprocess_path(path)
+ if path.endswith('.rpm'):
+ return rpm_kernel(job, path, subdir)
+ else:
+ return kernel(job, path, subdir, tmp_dir, build_dir, leave)
diff --git a/client/bin/kernel_config.py b/client/bin/kernel_config.py
index ed6321a..9b471b5 100755
--- a/client/bin/kernel_config.py
+++ b/client/bin/kernel_config.py
@@ -5,122 +5,122 @@
from autotest_lib.client.common_lib import error, utils
def apply_overrides(orig_file, changes_file, output_file):
- override = dict()
+ override = dict()
- # First suck all the changes into a dictionary.
- input = file(changes_file, 'r')
- for line in input.readlines():
- if line.startswith('CONFIG_'):
- key = line.split('=')[0]
- override[key] = line;
- elif line.startswith('# CONFIG_'):
- key = line.split(' ')[1]
- override[key] = line;
- input.close()
+ # First suck all the changes into a dictionary.
+ input = file(changes_file, 'r')
+ for line in input.readlines():
+ if line.startswith('CONFIG_'):
+ key = line.split('=')[0]
+ override[key] = line;
+ elif line.startswith('# CONFIG_'):
+ key = line.split(' ')[1]
+ override[key] = line;
+ input.close()
- # Now go through the input file, overriding lines where need be
- input = file(orig_file, 'r')
- output = file(output_file, 'w')
- for line in input.readlines():
- if line.startswith('CONFIG_'):
- key = line.split('=')[0]
- elif line.startswith('# CONFIG_'):
- key = line.split(' ')[1]
- else:
- key = None
- if key and key in override:
- output.write(override[key])
- else:
- output.write(line)
- input.close()
- output.close()
+ # Now go through the input file, overriding lines where need be
+ input = file(orig_file, 'r')
+ output = file(output_file, 'w')
+ for line in input.readlines():
+ if line.startswith('CONFIG_'):
+ key = line.split('=')[0]
+ elif line.startswith('# CONFIG_'):
+ key = line.split(' ')[1]
+ else:
+ key = None
+ if key and key in override:
+ output.write(override[key])
+ else:
+ output.write(line)
+ input.close()
+ output.close()
def diff_configs(old, new):
- utils.system('diff -u %s %s > %s' % (old, new, new + '.diff'),
- ignore_status=True)
+ utils.system('diff -u %s %s > %s' % (old, new, new + '.diff'),
+ ignore_status=True)
def modules_needed(config):
- return (autotest_utils.grep('CONFIG_MODULES=y', config)
- and autotest_utils.grep('=m', config))
+ return (autotest_utils.grep('CONFIG_MODULES=y', config)
+ and autotest_utils.grep('=m', config))
def config_by_name(name, set):
- version = kernel_versions.version_choose_config(name, set[1:])
- if version:
- return set[0] + version
- return None
+ version = kernel_versions.version_choose_config(name, set[1:])
+ if version:
+ return set[0] + version
+ return None
class kernel_config:
- # Build directory must be ready before init'ing config.
- #
- # Stages:
- # 1. Get original config file
- # 2. Apply overrides
- # 3. Do 'make oldconfig' to update it to current source code
- # (gets done implicitly during the process)
- #
- # You may specifiy the a defconfig within the tree to build,
- # or a custom config file you want, or None, to get machine's
- # default config file from the repo.
+ # Build directory must be ready before init'ing config.
+ #
+ # Stages:
+ # 1. Get original config file
+ # 2. Apply overrides
+ # 3. Do 'make oldconfig' to update it to current source code
+ # (gets done implicitly during the process)
+ #
+ # You may specifiy the a defconfig within the tree to build,
+ # or a custom config file you want, or None, to get machine's
+ # default config file from the repo.
- build_dir = '' # the directory we're building in
- config_dir = '' # local repository for config_file data
+ build_dir = '' # the directory we're building in
+ config_dir = '' # local repository for config_file data
- build_config = '' # the config file in the build directory
- orig_config = '' # the original config file
- over_config = '' # config file + overrides
+ build_config = '' # the config file in the build directory
+ orig_config = '' # the original config file
+ over_config = '' # config file + overrides
- def __init__(self, job, build_dir, config_dir, orig_file,
- overrides, defconfig = False, name = None):
- self.build_dir = build_dir
- self.config_dir = config_dir
+ def __init__(self, job, build_dir, config_dir, orig_file,
+ overrides, defconfig = False, name = None):
+ self.build_dir = build_dir
+ self.config_dir = config_dir
- # 1. Get original config file
- self.build_config = build_dir + '/.config'
- if (orig_file == '' and not defconfig): # use user default
- set = job.config_get("kernel.default_config_set")
- defconf = None
- if set and name:
- defconf = config_by_name(name, set)
- if not defconf:
- defconf = job.config_get("kernel.default_config")
- if defconf:
- orig_file = defconf
- if (orig_file == '' or defconfig): # use defconfig
- print "kernel_config: using defconfig to configure kernel"
- os.chdir(build_dir)
- utils.system('make defconfig')
- else:
- print "kernel_config: using " + orig_file + \
- " to configure kernel"
- self.orig_config = config_dir + '/config.orig'
- utils.get_file(orig_file, self.orig_config)
- self.update_config(self.orig_config, self.orig_config+'.new')
- diff_configs(self.orig_config, self.orig_config+'.new')
+ # 1. Get original config file
+ self.build_config = build_dir + '/.config'
+ if (orig_file == '' and not defconfig): # use user default
+ set = job.config_get("kernel.default_config_set")
+ defconf = None
+ if set and name:
+ defconf = config_by_name(name, set)
+ if not defconf:
+ defconf = job.config_get("kernel.default_config")
+ if defconf:
+ orig_file = defconf
+ if (orig_file == '' or defconfig): # use defconfig
+ print "kernel_config: using defconfig to configure kernel"
+ os.chdir(build_dir)
+ utils.system('make defconfig')
+ else:
+ print "kernel_config: using " + orig_file + \
+ " to configure kernel"
+ self.orig_config = config_dir + '/config.orig'
+ utils.get_file(orig_file, self.orig_config)
+ self.update_config(self.orig_config, self.orig_config+'.new')
+ diff_configs(self.orig_config, self.orig_config+'.new')
- # 2. Apply overrides
- if overrides:
- print "kernel_config: using " + overrides + \
- " to re-configure kernel"
- self.over_config = config_dir + '/config.over'
- overrides_local = self.over_config + '.changes'
- get_file(overrides, overrides_local)
- apply_overrides(self.build_config, overrides_local, self.over_config)
- self.update_config(self.over_config, self.over_config+'.new')
- diff_configs(self.over_config, self.over_config+'.new')
- else:
- self.over_config = self.orig_config
+ # 2. Apply overrides
+ if overrides:
+ print "kernel_config: using " + overrides + \
+ " to re-configure kernel"
+ self.over_config = config_dir + '/config.over'
+ overrides_local = self.over_config + '.changes'
+ get_file(overrides, overrides_local)
+ apply_overrides(self.build_config, overrides_local, self.over_config)
+ self.update_config(self.over_config, self.over_config+'.new')
+ diff_configs(self.over_config, self.over_config+'.new')
+ else:
+ self.over_config = self.orig_config
- def update_config(self, old_config, new_config = 'None'):
- os.chdir(self.build_dir)
- shutil.copyfile(old_config, self.build_config)
- utils.system('yes "" | make oldconfig > /dev/null')
- if new_config:
- shutil.copyfile(self.build_config, new_config)
+ def update_config(self, old_config, new_config = 'None'):
+ os.chdir(self.build_dir)
+ shutil.copyfile(old_config, self.build_config)
+ utils.system('yes "" | make oldconfig > /dev/null')
+ if new_config:
+ shutil.copyfile(self.build_config, new_config)
diff --git a/client/bin/kernel_versions.py b/client/bin/kernel_versions.py
index 3af08fe..9b04beb 100644
--- a/client/bin/kernel_versions.py
+++ b/client/bin/kernel_versions.py
@@ -5,111 +5,109 @@
import sys,re
-#
+#
# Sort key for ordering versions chronologically. The key ordering
# problem is between that introduced by -rcN. These come _before_
# their accompanying version.
-#
+#
# 2.6.0 -> 2.6.1-rc1 -> 2.6.1
-#
+#
# In order to sort them we convert all non-rc releases to a pseudo
# -rc99 release. We also convert all numbers to two digits. The
# result is then sortable textually.
-#
+#
# 02.06.00-rc99 -> 02.06.01-rc01 -> 02.06.01-rc99
-#
+#
encode_sep = re.compile(r'(\D+)')
def version_encode(version):
- bits = encode_sep.split(version)
- n = 9
- if len(bits[0]) == 0:
- n += 2
- if len(bits) == n or (len(bits) > n and bits[n] != '_rc'):
- # Insert missing _rc99 after 2 . 6 . 18 -smp- 220 . 0
- bits.insert(n, '_rc')
- bits.insert(n+1, '99')
- n = 5
- if len(bits[0]) == 0:
- n += 2
- if len(bits) <= n or bits[n] != '-rc':
- bits.insert(n, '-rc')
- bits.insert(n+1, '99')
- for n in range(0, len(bits), 2):
- if len(bits[n]) == 1:
- bits[n] = '0' + bits[n]
+ bits = encode_sep.split(version)
+ n = 9
+ if len(bits[0]) == 0:
+ n += 2
+ if len(bits) == n or (len(bits) > n and bits[n] != '_rc'):
+ # Insert missing _rc99 after 2 . 6 . 18 -smp- 220 . 0
+ bits.insert(n, '_rc')
+ bits.insert(n+1, '99')
+ n = 5
+ if len(bits[0]) == 0:
+ n += 2
+ if len(bits) <= n or bits[n] != '-rc':
+ bits.insert(n, '-rc')
+ bits.insert(n+1, '99')
+ for n in range(0, len(bits), 2):
+ if len(bits[n]) == 1:
+ bits[n] = '0' + bits[n]
- return ''.join(bits)
+ return ''.join(bits)
def version_limit(version, n):
- bits = encode_sep.split(version)
- return ''.join(bits[0:n])
+ bits = encode_sep.split(version)
+ return ''.join(bits[0:n])
def version_len(version):
- return len(encode_sep.split(version))
+ return len(encode_sep.split(version))
#
# Given a list of versions find the nearest version which is deemed
# less than or equal to the target. Versions are in linux order
# as follows:
-#
+#
# 2.6.0 -> 2.6.1 -> 2.6.2-rc1 -> 2.6.2-rc2 -> 2.6.2 -> 2.6.3-rc1
# | |\
# | | 2.6.2-rc1-mm1 -> 2.6.2-rc1-mm2
# | \
# | 2.6.2-rc1-ac1 -> 2.6.2-rc1-ac2
-# \
+# \
# 2.6.1-mm1 -> 2.6.1-mm2
-#
+#
# Note that a 2.6.1-mm1 is not a predecessor of 2.6.2-rc1-mm1.
#
def version_choose_config(version, candidates):
- # Check if we have an exact match ... if so magic
- if version in candidates:
- return version
+ # Check if we have an exact match ... if so magic
+ if version in candidates:
+ return version
- # Sort the search key into the list ordered by 'age'
- deco = [ (version_encode(v), i, v) for i, v in
- enumerate(candidates + [ version ]) ]
- deco.sort()
- versions = [ v for _, _, v in deco ]
+ # Sort the search key into the list ordered by 'age'
+ deco = [ (version_encode(v), i, v) for i, v in
+ enumerate(candidates + [ version ]) ]
+ deco.sort()
+ versions = [ v for _, _, v in deco ]
- # Everything sorted below us is of interst.
- for n in range(len(versions) - 1, -1, -1):
- if versions[n] == version:
- break
- n -= 1
+ # Everything sorted below us is of interst.
+ for n in range(len(versions) - 1, -1, -1):
+ if versions[n] == version:
+ break
+ n -= 1
- # Try ever shorter 'prefixes' 2.6.20-rc3-mm, 2.6.20-rc, 2.6. etc
- # to match against the ordered list newest to oldest.
- length = version_len(version) - 1
- version = version_limit(version, length)
- while length > 1:
- for o in range(n, -1, -1):
- if version_len(versions[o]) == (length + 1) and \
- version_limit(versions[o], length) == version:
- return versions[o]
- length -= 2
- version = version_limit(version, length)
+ # Try ever shorter 'prefixes' 2.6.20-rc3-mm, 2.6.20-rc, 2.6. etc
+ # to match against the ordered list newest to oldest.
+ length = version_len(version) - 1
+ version = version_limit(version, length)
+ while length > 1:
+ for o in range(n, -1, -1):
+ if version_len(versions[o]) == (length + 1) and \
+ version_limit(versions[o], length) == version:
+ return versions[o]
+ length -= 2
+ version = version_limit(version, length)
- return None
+ return None
def is_released_kernel(version):
- # True if version name suggests a released kernel,
- # not some release candidate or experimental kernel name
- # e.g. 2.6.18-smp-200.0 includes no other text, underscores, etc
- version = version.strip('01234567890.-')
- return version in ['', 'smp', 'smpx', 'pae']
+ # True if version name suggests a released kernel,
+ # not some release candidate or experimental kernel name
+ # e.g. 2.6.18-smp-200.0 includes no other text, underscores, etc
+ version = version.strip('01234567890.-')
+ return version in ['', 'smp', 'smpx', 'pae']
def is_release_candidate(version):
- # True if version names a released kernel or release candidate,
- # not some experimental name containing arbitrary text
- # e.g. 2.6.18-smp-220.0_rc3 but not 2.6.18_patched
- version = re.sub(r'[_-]rc\d+', '', version)
- return is_released_kernel(version)
-
-
+ # True if version names a released kernel or release candidate,
+ # not some experimental name containing arbitrary text
+ # e.g. 2.6.18-smp-220.0_rc3 but not 2.6.18_patched
+ version = re.sub(r'[_-]rc\d+', '', version)
+ return is_released_kernel(version)
diff --git a/client/bin/kernel_versions_unittest.py b/client/bin/kernel_versions_unittest.py
index fc21a65..b63ecc8 100755
--- a/client/bin/kernel_versions_unittest.py
+++ b/client/bin/kernel_versions_unittest.py
@@ -5,83 +5,83 @@
class kernel_versions_test(unittest.TestCase):
- def increases(self, kernels):
- for i in xrange(len(kernels)-1):
- k1 = kernels[i]
- k2 = kernels[i+1]
- ek1 = version_encode(k1)
- ek2 = version_encode(k2)
- self.assert_(ek1 < ek2,
- '%s (-> %s) should sort < %s (-> %s)'
- % (k1, ek1, k2, ek2) )
+ def increases(self, kernels):
+ for i in xrange(len(kernels)-1):
+ k1 = kernels[i]
+ k2 = kernels[i+1]
+ ek1 = version_encode(k1)
+ ek2 = version_encode(k2)
+ self.assert_(ek1 < ek2,
+ '%s (-> %s) should sort < %s (-> %s)'
+ % (k1, ek1, k2, ek2) )
- def test_version_encode(self):
- series1 = [
- '2.6',
- '2.6.0',
- '2.6.1-rc1',
- '2.6.1-rc1_fix',
- '2.6.1-rc1_patch',
- '2.6.1-rc9',
- '2.6.1-rc9-mm1',
- '2.6.1-rc9-mm2',
- '2.6.1-rc10',
- '2.6.1-rc98',
- '2.6.1',
- '2.6.1_patch',
- '2.6.9',
- '2.6.10',
- '2.6.99',
- '2.7',
- '2.9.99',
- '2.10.0',
- '99.99.99',
- 'UNKNOWN',
- ]
- self.increases(series1)
- self.increases(['pathX'+k for k in series1])
- series2 = [
- '2.6.18-smp-220',
- '2.6.18-smp-220.0',
- '2.6.18-smp-220.1_rc1',
- '2.6.18-smp-220.1_rc1_fix',
- '2.6.18-smp-220.1_rc1_patch',
- '2.6.18-smp-220.1_rc9',
- '2.6.18-smp-220.1_rc9_mm1',
- '2.6.18-smp-220.1_rc9_mm2',
- '2.6.18-smp-220.1_rc10',
- '2.6.18-smp-220.1_rc98',
- '2.6.18-smp-220.1',
- '2.6.18-smp-220.1_patch',
- '2.6.18-smp-220.9',
- '2.6.18-smp-220.10',
- '2.6.18-smp-220.99',
- '2.6.18-smp-221',
- 'UNKNOWN',
- ]
- self.increases(series2)
- self.increases(['pathX'+k for k in series2])
+ def test_version_encode(self):
+ series1 = [
+ '2.6',
+ '2.6.0',
+ '2.6.1-rc1',
+ '2.6.1-rc1_fix',
+ '2.6.1-rc1_patch',
+ '2.6.1-rc9',
+ '2.6.1-rc9-mm1',
+ '2.6.1-rc9-mm2',
+ '2.6.1-rc10',
+ '2.6.1-rc98',
+ '2.6.1',
+ '2.6.1_patch',
+ '2.6.9',
+ '2.6.10',
+ '2.6.99',
+ '2.7',
+ '2.9.99',
+ '2.10.0',
+ '99.99.99',
+ 'UNKNOWN',
+ ]
+ self.increases(series1)
+ self.increases(['pathX'+k for k in series1])
+ series2 = [
+ '2.6.18-smp-220',
+ '2.6.18-smp-220.0',
+ '2.6.18-smp-220.1_rc1',
+ '2.6.18-smp-220.1_rc1_fix',
+ '2.6.18-smp-220.1_rc1_patch',
+ '2.6.18-smp-220.1_rc9',
+ '2.6.18-smp-220.1_rc9_mm1',
+ '2.6.18-smp-220.1_rc9_mm2',
+ '2.6.18-smp-220.1_rc10',
+ '2.6.18-smp-220.1_rc98',
+ '2.6.18-smp-220.1',
+ '2.6.18-smp-220.1_patch',
+ '2.6.18-smp-220.9',
+ '2.6.18-smp-220.10',
+ '2.6.18-smp-220.99',
+ '2.6.18-smp-221',
+ 'UNKNOWN',
+ ]
+ self.increases(series2)
+ self.increases(['pathX'+k for k in series2])
- releases = ['2.6.1' , '2.6.18-smp-220.0' ]
- candidates = ['2.6.1-rc1' , '2.6.18-smp-220.0_rc1']
- experiments = ['2.6.1-patch', '2.6.1-rc1_patch',
- '2.6.18-smp-220.0_patch', 'UNKNOWN']
+ releases = ['2.6.1' , '2.6.18-smp-220.0' ]
+ candidates = ['2.6.1-rc1' , '2.6.18-smp-220.0_rc1']
+ experiments = ['2.6.1-patch', '2.6.1-rc1_patch',
+ '2.6.18-smp-220.0_patch', 'UNKNOWN']
- def test_is_released_kernel(self):
- for v in self.releases:
- self.assert_( is_released_kernel(v))
- for v in self.candidates + self.experiments:
- self.assert_(not is_released_kernel(v))
+ def test_is_released_kernel(self):
+ for v in self.releases:
+ self.assert_( is_released_kernel(v))
+ for v in self.candidates + self.experiments:
+ self.assert_(not is_released_kernel(v))
- def test_is_release_candidate(self):
- for v in self.releases + self.candidates:
- self.assert_( is_release_candidate(v))
- for v in self.experiments:
- self.assert_(not is_release_candidate(v))
+ def test_is_release_candidate(self):
+ for v in self.releases + self.candidates:
+ self.assert_( is_release_candidate(v))
+ for v in self.experiments:
+ self.assert_(not is_release_candidate(v))
if __name__ == "__main__":
- unittest.main()
+ unittest.main()
diff --git a/client/bin/kernelexpand-test.py b/client/bin/kernelexpand-test.py
index 3c34010..24b4ce0 100755
--- a/client/bin/kernelexpand-test.py
+++ b/client/bin/kernelexpand-test.py
@@ -11,136 +11,136 @@
akpml = 'http://www.example.com/mirror/akpm/'
mirrorA = [
- [ akpm, akpml ],
- [ km, kml ],
+ [ akpm, akpml ],
+ [ km, kml ],
]
class kernelexpandTest(unittest.TestCase):
- def test_decompose_simple(self):
- correct = [
- [ km + 'v2.6/linux-2.6.23.tar.bz2' ]
- ]
- sample = decompose_kernel('2.6.23')
- self.assertEqual(sample, correct)
+ def test_decompose_simple(self):
+ correct = [
+ [ km + 'v2.6/linux-2.6.23.tar.bz2' ]
+ ]
+ sample = decompose_kernel('2.6.23')
+ self.assertEqual(sample, correct)
- def test_decompose_fail(self):
- success = False
- try:
- sample = decompose_kernel('1.0.0.0.0')
- success = True
- except NameError:
- pass
- except Exception, e:
- self.fail('expected NameError, got something else')
+ def test_decompose_fail(self):
+ success = False
+ try:
+ sample = decompose_kernel('1.0.0.0.0')
+ success = True
+ except NameError:
+ pass
+ except Exception, e:
+ self.fail('expected NameError, got something else')
- if success:
- self.fail('expected NameError, was successful')
+ if success:
+ self.fail('expected NameError, was successful')
- def test_decompose_rcN(self):
- correct = [
- [ km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
- km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2']
- ]
- sample = decompose_kernel('2.6.23-rc1')
- self.assertEqual(sample, correct)
-
-
- def test_decompose_mmN(self):
- correct = [
- [ km + 'v2.6/linux-2.6.23.tar.bz2' ],
- [ akpm + '2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2' ]
- ]
- sample = decompose_kernel('2.6.23-mm1')
- self.assertEqual(sample, correct)
+ def test_decompose_rcN(self):
+ correct = [
+ [ km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
+ km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2']
+ ]
+ sample = decompose_kernel('2.6.23-rc1')
+ self.assertEqual(sample, correct)
- def test_decompose_gitN(self):
- correct = [
- [ km + 'v2.6/linux-2.6.23.tar.bz2' ],
- [ km + 'v2.6/snapshots/old/patch-2.6.23-git1.bz2',
- km + 'v2.6/snapshots/patch-2.6.23-git1.bz2']
- ]
- sample = decompose_kernel('2.6.23-git1')
- self.assertEqual(sample, correct)
+ def test_decompose_mmN(self):
+ correct = [
+ [ km + 'v2.6/linux-2.6.23.tar.bz2' ],
+ [ akpm + '2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2' ]
+ ]
+ sample = decompose_kernel('2.6.23-mm1')
+ self.assertEqual(sample, correct)
- def test_decompose_rcN_mmN(self):
- correct = [
- [ km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
- km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2' ],
- [ akpm + '2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2']
- ]
- sample = decompose_kernel('2.6.23-rc1-mm1')
- self.assertEqual(sample, correct)
+ def test_decompose_gitN(self):
+ correct = [
+ [ km + 'v2.6/linux-2.6.23.tar.bz2' ],
+ [ km + 'v2.6/snapshots/old/patch-2.6.23-git1.bz2',
+ km + 'v2.6/snapshots/patch-2.6.23-git1.bz2']
+ ]
+ sample = decompose_kernel('2.6.23-git1')
+ self.assertEqual(sample, correct)
- def test_mirrorA_simple(self):
- correct = [
- [ kml + 'v2.6/linux-2.6.23.tar.bz2',
- km + 'v2.6/linux-2.6.23.tar.bz2' ]
- ]
- sample = decompose_kernel('2.6.23')
- sample = mirror_kernel_components(mirrorA, sample)
-
- self.assertEqual(sample, correct)
+ def test_decompose_rcN_mmN(self):
+ correct = [
+ [ km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
+ km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2' ],
+ [ akpm + '2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2']
+ ]
+ sample = decompose_kernel('2.6.23-rc1-mm1')
+ self.assertEqual(sample, correct)
- def test_mirrorA_rcN(self):
- correct = [
- [ kml + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
- kml + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2',
- km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
- km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2' ]
- ]
- sample = decompose_kernel('2.6.23-rc1')
- sample = mirror_kernel_components(mirrorA, sample)
- self.assertEqual(sample, correct)
+ def test_mirrorA_simple(self):
+ correct = [
+ [ kml + 'v2.6/linux-2.6.23.tar.bz2',
+ km + 'v2.6/linux-2.6.23.tar.bz2' ]
+ ]
+ sample = decompose_kernel('2.6.23')
+ sample = mirror_kernel_components(mirrorA, sample)
-
- def test_mirrorA_mmN(self):
- correct = [
- [ kml + 'v2.6/linux-2.6.23.tar.bz2',
- km + 'v2.6/linux-2.6.23.tar.bz2'],
- [ akpml + '2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2',
- kml + 'people/akpm/patches/2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2',
- akpm + '2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2' ]
- ]
-
- sample = decompose_kernel('2.6.23-mm1')
- sample = mirror_kernel_components(mirrorA, sample)
- self.assertEqual(sample, correct)
+ self.assertEqual(sample, correct)
- def test_mirrorA_gitN(self):
- correct = [
- [ kml + 'v2.6/linux-2.6.23.tar.bz2',
- km + 'v2.6/linux-2.6.23.tar.bz2'],
- [ kml + 'v2.6/snapshots/old/patch-2.6.23-git1.bz2',
- kml + 'v2.6/snapshots/patch-2.6.23-git1.bz2',
- km + 'v2.6/snapshots/old/patch-2.6.23-git1.bz2',
- km + 'v2.6/snapshots/patch-2.6.23-git1.bz2' ]
- ]
- sample = decompose_kernel('2.6.23-git1')
- sample = mirror_kernel_components(mirrorA, sample)
- self.assertEqual(sample, correct)
+ def test_mirrorA_rcN(self):
+ correct = [
+ [ kml + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
+ kml + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2',
+ km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
+ km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2' ]
+ ]
+ sample = decompose_kernel('2.6.23-rc1')
+ sample = mirror_kernel_components(mirrorA, sample)
+ self.assertEqual(sample, correct)
- def test_mirrorA_rcN_mmN(self):
- correct = [
- [ kml + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
- kml + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2',
- km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
- km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2'],
- [ akpml + '2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2',
- kml + 'people/akpm/patches/2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2',
- akpm + '2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2' ]
- ]
- sample = decompose_kernel('2.6.23-rc1-mm1')
- sample = mirror_kernel_components(mirrorA, sample)
- self.assertEqual(sample, correct)
+ def test_mirrorA_mmN(self):
+ correct = [
+ [ kml + 'v2.6/linux-2.6.23.tar.bz2',
+ km + 'v2.6/linux-2.6.23.tar.bz2'],
+ [ akpml + '2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2',
+ kml + 'people/akpm/patches/2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2',
+ akpm + '2.6/2.6.23/2.6.23-mm1/2.6.23-mm1.bz2' ]
+ ]
+
+ sample = decompose_kernel('2.6.23-mm1')
+ sample = mirror_kernel_components(mirrorA, sample)
+ self.assertEqual(sample, correct)
+
+
+ def test_mirrorA_gitN(self):
+ correct = [
+ [ kml + 'v2.6/linux-2.6.23.tar.bz2',
+ km + 'v2.6/linux-2.6.23.tar.bz2'],
+ [ kml + 'v2.6/snapshots/old/patch-2.6.23-git1.bz2',
+ kml + 'v2.6/snapshots/patch-2.6.23-git1.bz2',
+ km + 'v2.6/snapshots/old/patch-2.6.23-git1.bz2',
+ km + 'v2.6/snapshots/patch-2.6.23-git1.bz2' ]
+ ]
+ sample = decompose_kernel('2.6.23-git1')
+ sample = mirror_kernel_components(mirrorA, sample)
+ self.assertEqual(sample, correct)
+
+
+ def test_mirrorA_rcN_mmN(self):
+ correct = [
+ [ kml + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
+ kml + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2',
+ km + 'v2.6/testing/v2.6.23/linux-2.6.23-rc1.tar.bz2',
+ km + 'v2.6/testing/linux-2.6.23-rc1.tar.bz2'],
+ [ akpml + '2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2',
+ kml + 'people/akpm/patches/2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2',
+ akpm + '2.6/2.6.23-rc1/2.6.23-rc1-mm1/2.6.23-rc1-mm1.bz2' ]
+ ]
+ sample = decompose_kernel('2.6.23-rc1-mm1')
+ sample = mirror_kernel_components(mirrorA, sample)
+ self.assertEqual(sample, correct)
if __name__ == '__main__':
- unittest.main()
+ unittest.main()
diff --git a/client/bin/kernelexpand.py b/client/bin/kernelexpand.py
index 73028fa..e23b865 100755
--- a/client/bin/kernelexpand.py
+++ b/client/bin/kernelexpand.py
@@ -12,180 +12,180 @@
kernel = 'http://www.kernel.org/pub/linux/kernel/'
mappings = [
- [ r'^\d+\.\d+\.\d+$', '', True, [
- kernel + 'v%(major)s/linux-%(full)s.tar.bz2'
- ]],
- [ r'^\d+\.\d+\.\d+\.\d+$', '', True, [
- kernel + 'v%(major)s/linux-%(full)s.tar.bz2'
- ]],
- [ r'-rc\d+$', '%(minor-prev)s', True, [
- kernel + 'v%(major)s/testing/v%(minor)s/linux-%(full)s.tar.bz2',
- kernel + 'v%(major)s/testing/linux-%(full)s.tar.bz2',
- ]],
- [ r'-(git|bk)\d+$', '%(base)s', False, [
- kernel + 'v%(major)s/snapshots/old/patch-%(full)s.bz2',
- kernel + 'v%(major)s/snapshots/patch-%(full)s.bz2',
- ]],
- [ r'-mm\d+$', '%(base)s', False, [
- kernel + 'people/akpm/patches/' +
- '%(major)s/%(base)s/%(full)s/%(full)s.bz2'
- ]],
- [ r'-mjb\d+$', '%(base)s', False, [
- kernel + 'people/mbligh/%(base)s/patch-%(full)s.bz2'
- ]]
+ [ r'^\d+\.\d+\.\d+$', '', True, [
+ kernel + 'v%(major)s/linux-%(full)s.tar.bz2'
+ ]],
+ [ r'^\d+\.\d+\.\d+\.\d+$', '', True, [
+ kernel + 'v%(major)s/linux-%(full)s.tar.bz2'
+ ]],
+ [ r'-rc\d+$', '%(minor-prev)s', True, [
+ kernel + 'v%(major)s/testing/v%(minor)s/linux-%(full)s.tar.bz2',
+ kernel + 'v%(major)s/testing/linux-%(full)s.tar.bz2',
+ ]],
+ [ r'-(git|bk)\d+$', '%(base)s', False, [
+ kernel + 'v%(major)s/snapshots/old/patch-%(full)s.bz2',
+ kernel + 'v%(major)s/snapshots/patch-%(full)s.bz2',
+ ]],
+ [ r'-mm\d+$', '%(base)s', False, [
+ kernel + 'people/akpm/patches/' +
+ '%(major)s/%(base)s/%(full)s/%(full)s.bz2'
+ ]],
+ [ r'-mjb\d+$', '%(base)s', False, [
+ kernel + 'people/mbligh/%(base)s/patch-%(full)s.bz2'
+ ]]
];
def decompose_kernel_once(kernel):
- ##print "S<" + kernel + ">"
- for mapping in mappings:
- (suffix, becomes, is_full, patch_templates) = mapping
+ ##print "S<" + kernel + ">"
+ for mapping in mappings:
+ (suffix, becomes, is_full, patch_templates) = mapping
- params = {}
+ params = {}
- match = re.search(r'^(.*)' + suffix, kernel)
- if not match:
- continue
+ match = re.search(r'^(.*)' + suffix, kernel)
+ if not match:
+ continue
- # Generate the parameters for the patches:
- # full => full kernel name
- # base => all but the matches suffix
- # minor => 2.n.m
- # major => 2.n
- # minor-prev => 2.n.m-1
- params['full'] = kernel
- params['base'] = match.group(1)
+ # Generate the parameters for the patches:
+ # full => full kernel name
+ # base => all but the matches suffix
+ # minor => 2.n.m
+ # major => 2.n
+ # minor-prev => 2.n.m-1
+ params['full'] = kernel
+ params['base'] = match.group(1)
- match = re.search(r'^((\d+\.\d+)\.(\d+))', kernel)
- if not match:
- raise "unable to determine major/minor version"
- params['minor'] = match.group(1)
- params['major'] = match.group(2)
- params['minor-prev'] = match.group(2) + \
- '.%d' % (int(match.group(3)) - 1)
+ match = re.search(r'^((\d+\.\d+)\.(\d+))', kernel)
+ if not match:
+ raise "unable to determine major/minor version"
+ params['minor'] = match.group(1)
+ params['major'] = match.group(2)
+ params['minor-prev'] = match.group(2) + \
+ '.%d' % (int(match.group(3)) - 1)
- # Build the new kernel and patch list.
- new_kernel = becomes % params
- patch_list = []
- for template in patch_templates:
- patch_list.append(template % params)
-
- return (is_full, new_kernel, patch_list)
+ # Build the new kernel and patch list.
+ new_kernel = becomes % params
+ patch_list = []
+ for template in patch_templates:
+ patch_list.append(template % params)
- return (True, kernel, None)
+ return (is_full, new_kernel, patch_list)
+
+ return (True, kernel, None)
def decompose_kernel(kernel):
- kernel_patches = []
+ kernel_patches = []
- done = False
- while not done:
- (done, kernel, patch_list) = decompose_kernel_once(kernel)
- if patch_list:
- kernel_patches.insert(0, patch_list)
- if not len(kernel_patches):
- raise NameError('kernelexpand: %s: unknown kernel' % (kernel))
+ done = False
+ while not done:
+ (done, kernel, patch_list) = decompose_kernel_once(kernel)
+ if patch_list:
+ kernel_patches.insert(0, patch_list)
+ if not len(kernel_patches):
+ raise NameError('kernelexpand: %s: unknown kernel' % (kernel))
- return kernel_patches
+ return kernel_patches
# Look for and add potential mirrors.
def mirror_kernel_components(mirrors, components):
- new_components = []
- for component in components:
- new_patches = []
- for mirror in mirrors:
- (prefix, local) = mirror
- for patch in component:
- if patch.startswith(prefix):
- new_patch = local + \
- patch[len(prefix):]
- new_patches.append(new_patch)
- for patch in component:
- new_patches.append(patch)
- new_components.append(new_patches)
-
- return new_components
+ new_components = []
+ for component in components:
+ new_patches = []
+ for mirror in mirrors:
+ (prefix, local) = mirror
+ for patch in component:
+ if patch.startswith(prefix):
+ new_patch = local + \
+ patch[len(prefix):]
+ new_patches.append(new_patch)
+ for patch in component:
+ new_patches.append(patch)
+ new_components.append(new_patches)
+
+ return new_components
def url_accessible(url):
- status = os.system("wget --spider -q '%s'" % (url))
- #print url + ": status=%d" % (status)
-
- return status == 0
+ status = os.system("wget --spider -q '%s'" % (url))
+ #print url + ": status=%d" % (status)
+
+ return status == 0
def select_kernel_components(components):
- new_components = []
- for component in components:
- new_patches = []
- for patch in component:
- if url_accessible(patch):
- new_patches.append(patch)
- break
- if not len(new_patches):
- new_patches.append(component[-1])
- new_components.append(new_patches)
- return new_components
+ new_components = []
+ for component in components:
+ new_patches = []
+ for patch in component:
+ if url_accessible(patch):
+ new_patches.append(patch)
+ break
+ if not len(new_patches):
+ new_patches.append(component[-1])
+ new_components.append(new_patches)
+ return new_components
def expand_classic(kernel, mirrors):
- components = decompose_kernel(kernel)
- if mirrors:
- components = mirror_kernel_components(mirrors, components)
- components = select_kernel_components(components)
+ components = decompose_kernel(kernel)
+ if mirrors:
+ components = mirror_kernel_components(mirrors, components)
+ components = select_kernel_components(components)
- patches = []
- for component in components:
- patches.append(component[0])
+ patches = []
+ for component in components:
+ patches.append(component[0])
- return patches
+ return patches
if __name__ == '__main__':
- from optparse import OptionParser
+ from optparse import OptionParser
- parser = OptionParser()
+ parser = OptionParser()
- parser.add_option("-m", "--mirror",
- type="string", dest="mirror", action="append", nargs=2,
- help="mirror prefix")
- parser.add_option("-v", "--no-validate", dest="validate",
- action="store_false", default=True,
- help="prune invalid entries")
+ parser.add_option("-m", "--mirror",
+ type="string", dest="mirror", action="append", nargs=2,
+ help="mirror prefix")
+ parser.add_option("-v", "--no-validate", dest="validate",
+ action="store_false", default=True,
+ help="prune invalid entries")
- def usage():
- parser.print_help()
- sys.exit(1)
+ def usage():
+ parser.print_help()
+ sys.exit(1)
- options, args = parser.parse_args()
+ options, args = parser.parse_args()
- # Check for a kernel version
- if len(args) != 1:
- usage()
- kernel = args[0]
+ # Check for a kernel version
+ if len(args) != 1:
+ usage()
+ kernel = args[0]
- #mirrors = [
- # [ 'http://www.kernel.org/pub/linux/kernel/v2.4',
- # 'http://kernel.beaverton.ibm.com/mirror/v2.4' ],
- # [ 'http://www.kernel.org/pub/linux/kernel/v2.6',
- # 'http://kernel.beaverton.ibm.com/mirror/v2.6' ],
- # [ 'http://www.kernel.org/pub/linux/kernel/people/akpm/patches',
- # 'http://kernel.beaverton.ibm.com/mirror/akpm' ],
- #]
- mirrors = options.mirror
+ #mirrors = [
+ # [ 'http://www.kernel.org/pub/linux/kernel/v2.4',
+ # 'http://kernel.beaverton.ibm.com/mirror/v2.4' ],
+ # [ 'http://www.kernel.org/pub/linux/kernel/v2.6',
+ # 'http://kernel.beaverton.ibm.com/mirror/v2.6' ],
+ # [ 'http://www.kernel.org/pub/linux/kernel/people/akpm/patches',
+ # 'http://kernel.beaverton.ibm.com/mirror/akpm' ],
+ #]
+ mirrors = options.mirror
- try:
- components = decompose_kernel(kernel)
- except NameError, e:
- sys.stderr.write(e.args[0] + "\n")
- sys.exit(1)
+ try:
+ components = decompose_kernel(kernel)
+ except NameError, e:
+ sys.stderr.write(e.args[0] + "\n")
+ sys.exit(1)
- if mirrors:
- components = mirror_kernel_components(mirrors, components)
+ if mirrors:
+ components = mirror_kernel_components(mirrors, components)
- if options.validate:
- components = select_kernel_components(components)
+ if options.validate:
+ components = select_kernel_components(components)
- # Dump them out.
- for component in components:
- print " ".join(component)
+ # Dump them out.
+ for component in components:
+ print " ".join(component)
diff --git a/client/bin/os_dep.py b/client/bin/os_dep.py
index f61d46d..9022913 100644
--- a/client/bin/os_dep.py
+++ b/client/bin/os_dep.py
@@ -8,30 +8,30 @@
"""
def command(cmd):
- # this could use '/usr/bin/which', I suppose. But this seems simpler
- for dir in os.environ['PATH'].split(':'):
- file = os.path.join(dir, cmd)
- if os.path.exists(file):
- return file
- raise ValueError('Missing command: %s' % cmd)
+ # this could use '/usr/bin/which', I suppose. But this seems simpler
+ for dir in os.environ['PATH'].split(':'):
+ file = os.path.join(dir, cmd)
+ if os.path.exists(file):
+ return file
+ raise ValueError('Missing command: %s' % cmd)
def commands(*cmds):
- results = []
- for cmd in cmds:
- results.append(command(cmd))
+ results = []
+ for cmd in cmds:
+ results.append(command(cmd))
def library(lib):
- lddirs = [x.rstrip() for x in open('/etc/ld.so.conf', 'r').readlines()]
- for dir in ['/lib', '/usr/lib'] + lddirs:
- file = os.path.join(dir, lib)
- if os.path.exists(file):
- return file
- raise ValueError('Missing library: %s' % lib)
+ lddirs = [x.rstrip() for x in open('/etc/ld.so.conf', 'r').readlines()]
+ for dir in ['/lib', '/usr/lib'] + lddirs:
+ file = os.path.join(dir, lib)
+ if os.path.exists(file):
+ return file
+ raise ValueError('Missing library: %s' % lib)
def libraries(*libs):
- results = []
- for lib in libs:
- results.append(library(lib))
+ results = []
+ for lib in libs:
+ results.append(library(lib))
diff --git a/client/bin/package.py b/client/bin/package.py
index c889a9c..42a8604 100644
--- a/client/bin/package.py
+++ b/client/bin/package.py
@@ -1,5 +1,5 @@
"""
-Functions to handle software packages. The functions covered here aim to be
+Functions to handle software packages. The functions covered here aim to be
generic, with implementations that deal with different package managers, such
as dpkg and rpm.
"""
@@ -15,277 +15,277 @@
def __rpm_info(rpm_package):
- """\
- Private function that returns a dictionary with information about an
- RPM package file
- - type: Package management program that handles the file
- - system_support: If the package management program is installed on the
- system or not
- - source: If it is a source (True) our binary (False) package
- - version: The package version (or name), that is used to check against the
- package manager if the package is installed
- - arch: The architecture for which a binary package was built
- - installed: Whether the package is installed (True) on the system or not
- (False)
- """
- # We will make good use of what the file command has to tell us about the
- # package :)
- file_result = utils.system_output('file ' + rpm_package)
- package_info = {}
- package_info['type'] = 'rpm'
- try:
- os_dep.command('rpm')
- # Build the command strings that will be used to get package info
- # s_cmd - Command to determine if package is a source package
- # a_cmd - Command to determine package architecture
- # v_cmd - Command to determine package version
- # i_cmd - Command to determiine if package is installed
- s_cmd = 'rpm -qp --qf %{SOURCE} ' + rpm_package + ' 2>/dev/null'
- a_cmd = 'rpm -qp --qf %{ARCH} ' + rpm_package + ' 2>/dev/null'
- v_cmd = 'rpm -qp ' + rpm_package + ' 2>/dev/null'
- i_cmd = 'rpm -q ' + utils.system_output(v_cmd) + ' 2>&1 >/dev/null'
+ """\
+ Private function that returns a dictionary with information about an
+ RPM package file
+ - type: Package management program that handles the file
+ - system_support: If the package management program is installed on the
+ system or not
+ - source: If it is a source (True) our binary (False) package
+ - version: The package version (or name), that is used to check against the
+ package manager if the package is installed
+ - arch: The architecture for which a binary package was built
+ - installed: Whether the package is installed (True) on the system or not
+ (False)
+ """
+ # We will make good use of what the file command has to tell us about the
+ # package :)
+ file_result = utils.system_output('file ' + rpm_package)
+ package_info = {}
+ package_info['type'] = 'rpm'
+ try:
+ os_dep.command('rpm')
+ # Build the command strings that will be used to get package info
+ # s_cmd - Command to determine if package is a source package
+ # a_cmd - Command to determine package architecture
+ # v_cmd - Command to determine package version
+ # i_cmd - Command to determiine if package is installed
+ s_cmd = 'rpm -qp --qf %{SOURCE} ' + rpm_package + ' 2>/dev/null'
+ a_cmd = 'rpm -qp --qf %{ARCH} ' + rpm_package + ' 2>/dev/null'
+ v_cmd = 'rpm -qp ' + rpm_package + ' 2>/dev/null'
+ i_cmd = 'rpm -q ' + utils.system_output(v_cmd) + ' 2>&1 >/dev/null'
- package_info['system_support'] = True
- # Checking whether this is a source or src package
- source = utils.system_output(s_cmd)
- if source == '(none)':
- package_info['source'] = False
- else:
- package_info['source'] = True
- package_info['version'] = utils.system_output(v_cmd)
- package_info['arch'] = utils.system_output(a_cmd)
- # Checking if package is installed
- try:
- utils.system(i_cmd)
- package_info['installed'] = True
- except:
- package_info['installed'] = False
+ package_info['system_support'] = True
+ # Checking whether this is a source or src package
+ source = utils.system_output(s_cmd)
+ if source == '(none)':
+ package_info['source'] = False
+ else:
+ package_info['source'] = True
+ package_info['version'] = utils.system_output(v_cmd)
+ package_info['arch'] = utils.system_output(a_cmd)
+ # Checking if package is installed
+ try:
+ utils.system(i_cmd)
+ package_info['installed'] = True
+ except:
+ package_info['installed'] = False
- except:
- package_info['system_support'] = False
- package_info['installed'] = False
- # File gives a wealth of information about rpm packages.
- # However, we can't trust all this info, as incorrectly
- # packaged rpms can report some wrong values.
- # It's better than nothing though :)
- if len(file_result.split(' ')) == 6:
- # Figure if package is a source package
- if file_result.split(' ')[3] == 'src':
- package_info['source'] = True
- elif file_result.split(' ')[3] == 'bin':
- package_info['source'] = False
- else:
- package_info['source'] = False
- # Get architecture
- package_info['arch'] = file_result.split(' ')[4]
- # Get version
- package_info['version'] = file_result.split(' ')[5]
- elif len(file_result.split(' ')) == 5:
- # Figure if package is a source package
- if file_result.split(' ')[3] == 'src':
- package_info['source'] = True
- elif file_result.split(' ')[3] == 'bin':
- package_info['source'] = False
- else:
- package_info['source'] = False
- # When the arch param is missing on file, we assume noarch
- package_info['arch'] = 'noarch'
- # Get version
- package_info['version'] = file_result.split(' ')[4]
- else:
- # If everything else fails...
- package_info['source'] = False
- package_info['arch'] = 'Not Available'
- package_info['version'] = 'Not Available'
- return package_info
+ except:
+ package_info['system_support'] = False
+ package_info['installed'] = False
+ # File gives a wealth of information about rpm packages.
+ # However, we can't trust all this info, as incorrectly
+ # packaged rpms can report some wrong values.
+ # It's better than nothing though :)
+ if len(file_result.split(' ')) == 6:
+ # Figure if package is a source package
+ if file_result.split(' ')[3] == 'src':
+ package_info['source'] = True
+ elif file_result.split(' ')[3] == 'bin':
+ package_info['source'] = False
+ else:
+ package_info['source'] = False
+ # Get architecture
+ package_info['arch'] = file_result.split(' ')[4]
+ # Get version
+ package_info['version'] = file_result.split(' ')[5]
+ elif len(file_result.split(' ')) == 5:
+ # Figure if package is a source package
+ if file_result.split(' ')[3] == 'src':
+ package_info['source'] = True
+ elif file_result.split(' ')[3] == 'bin':
+ package_info['source'] = False
+ else:
+ package_info['source'] = False
+ # When the arch param is missing on file, we assume noarch
+ package_info['arch'] = 'noarch'
+ # Get version
+ package_info['version'] = file_result.split(' ')[4]
+ else:
+ # If everything else fails...
+ package_info['source'] = False
+ package_info['arch'] = 'Not Available'
+ package_info['version'] = 'Not Available'
+ return package_info
def __dpkg_info(dpkg_package):
- """\
- Private function that returns a dictionary with information about a
- dpkg package file
- - type: Package management program that handles the file
- - system_support: If the package management program is installed on the
- system or not
- - source: If it is a source (True) our binary (False) package
- - version: The package version (or name), that is used to check against the
- package manager if the package is installed
- - arch: The architecture for which a binary package was built
- - installed: Whether the package is installed (True) on the system or not
- (False)
- """
- # We will make good use of what the file command has to tell us about the
- # package :)
- file_result = utils.system_output('file ' + dpkg_package)
- package_info = {}
- package_info['type'] = 'dpkg'
- # There's no single debian source package as is the case
- # with RPM
- package_info['source'] = False
- try:
- os_dep.command('dpkg')
- # Build the command strings that will be used to get package info
- # a_cmd - Command to determine package architecture
- # v_cmd - Command to determine package version
- # i_cmd - Command to determiine if package is installed
- a_cmd = 'dpkg -f ' + dpkg_package + ' Architecture 2>/dev/null'
- v_cmd = 'dpkg -f ' + dpkg_package + ' Package 2>/dev/null'
- i_cmd = 'dpkg -s ' + utils.system_output(v_cmd) + ' 2>/dev/null'
+ """\
+ Private function that returns a dictionary with information about a
+ dpkg package file
+ - type: Package management program that handles the file
+ - system_support: If the package management program is installed on the
+ system or not
+ - source: If it is a source (True) our binary (False) package
+ - version: The package version (or name), that is used to check against the
+ package manager if the package is installed
+ - arch: The architecture for which a binary package was built
+ - installed: Whether the package is installed (True) on the system or not
+ (False)
+ """
+ # We will make good use of what the file command has to tell us about the
+ # package :)
+ file_result = utils.system_output('file ' + dpkg_package)
+ package_info = {}
+ package_info['type'] = 'dpkg'
+ # There's no single debian source package as is the case
+ # with RPM
+ package_info['source'] = False
+ try:
+ os_dep.command('dpkg')
+ # Build the command strings that will be used to get package info
+ # a_cmd - Command to determine package architecture
+ # v_cmd - Command to determine package version
+ # i_cmd - Command to determiine if package is installed
+ a_cmd = 'dpkg -f ' + dpkg_package + ' Architecture 2>/dev/null'
+ v_cmd = 'dpkg -f ' + dpkg_package + ' Package 2>/dev/null'
+ i_cmd = 'dpkg -s ' + utils.system_output(v_cmd) + ' 2>/dev/null'
- package_info['system_support'] = True
- package_info['version'] = utils.system_output(v_cmd)
- package_info['arch'] = utils.system_output(a_cmd)
- # Checking if package is installed
- package_status = utils.system_output(i_cmd, ignore_status=True)
- not_inst_pattern = re.compile('not-installed', re.IGNORECASE)
- dpkg_not_installed = re.search(not_inst_pattern, package_status)
- if dpkg_not_installed:
- package_info['installed'] = False
- else:
- package_info['installed'] = True
+ package_info['system_support'] = True
+ package_info['version'] = utils.system_output(v_cmd)
+ package_info['arch'] = utils.system_output(a_cmd)
+ # Checking if package is installed
+ package_status = utils.system_output(i_cmd, ignore_status=True)
+ not_inst_pattern = re.compile('not-installed', re.IGNORECASE)
+ dpkg_not_installed = re.search(not_inst_pattern, package_status)
+ if dpkg_not_installed:
+ package_info['installed'] = False
+ else:
+ package_info['installed'] = True
- except:
- package_info['system_support'] = False
- package_info['installed'] = False
- # The output of file is not as generous for dpkg files as
- # it is with rpm files
- package_info['arch'] = 'Not Available'
- package_info['version'] = 'Not Available'
+ except:
+ package_info['system_support'] = False
+ package_info['installed'] = False
+ # The output of file is not as generous for dpkg files as
+ # it is with rpm files
+ package_info['arch'] = 'Not Available'
+ package_info['version'] = 'Not Available'
- return package_info
+ return package_info
def info(package):
- """\
- Returns a dictionary with package information about a given package file:
- - type: Package management program that handles the file
- - system_support: If the package management program is installed on the
- system or not
- - source: If it is a source (True) our binary (False) package
- - version: The package version (or name), that is used to check against the
- package manager if the package is installed
- - arch: The architecture for which a binary package was built
- - installed: Whether the package is installed (True) on the system or not
- (False)
+ """\
+ Returns a dictionary with package information about a given package file:
+ - type: Package management program that handles the file
+ - system_support: If the package management program is installed on the
+ system or not
+ - source: If it is a source (True) our binary (False) package
+ - version: The package version (or name), that is used to check against the
+ package manager if the package is installed
+ - arch: The architecture for which a binary package was built
+ - installed: Whether the package is installed (True) on the system or not
+ (False)
- Implemented package types:
- - 'dpkg' - dpkg (debian, ubuntu) package files
- - 'rpm' - rpm (red hat, suse) package files
- Raises an exception if the package type is not one of the implemented
- package types.
- """
- if not os.path.isfile(package):
- raise ValueError('invalid file %s to verify' % package)
- # Use file and libmagic to determine the actual package file type.
- file_result = utils.system_output('file ' + package)
- for package_manager in KNOWN_PACKAGE_MANAGERS:
- if package_manager == 'rpm':
- package_pattern = re.compile('RPM', re.IGNORECASE)
- elif package_manager == 'dpkg':
- package_pattern = re.compile('Debian', re.IGNORECASE)
+ Implemented package types:
+ - 'dpkg' - dpkg (debian, ubuntu) package files
+ - 'rpm' - rpm (red hat, suse) package files
+ Raises an exception if the package type is not one of the implemented
+ package types.
+ """
+ if not os.path.isfile(package):
+ raise ValueError('invalid file %s to verify' % package)
+ # Use file and libmagic to determine the actual package file type.
+ file_result = utils.system_output('file ' + package)
+ for package_manager in KNOWN_PACKAGE_MANAGERS:
+ if package_manager == 'rpm':
+ package_pattern = re.compile('RPM', re.IGNORECASE)
+ elif package_manager == 'dpkg':
+ package_pattern = re.compile('Debian', re.IGNORECASE)
- result = re.search(package_pattern, file_result)
+ result = re.search(package_pattern, file_result)
- if result and package_manager == 'rpm':
- return __rpm_info(package)
- elif result and package_manager == 'dpkg':
- return __dpkg_info(package)
+ if result and package_manager == 'rpm':
+ return __rpm_info(package)
+ elif result and package_manager == 'dpkg':
+ return __dpkg_info(package)
- # If it's not one of the implemented package manager methods, there's
- # not much that can be done, hence we throw an exception.
- raise error.PackageError('Unknown package type %s' % file_result)
+ # If it's not one of the implemented package manager methods, there's
+ # not much that can be done, hence we throw an exception.
+ raise error.PackageError('Unknown package type %s' % file_result)
def install(package, nodeps = False):
- """\
- Tries to install a package file. If the package is already installed,
- it prints a message to the user and ends gracefully. If nodeps is set to
- true, it will ignore package dependencies.
- """
- my_package_info = info(package)
- type = my_package_info['type']
- system_support = my_package_info['system_support']
- source = my_package_info['source']
- installed = my_package_info['installed']
+ """\
+ Tries to install a package file. If the package is already installed,
+ it prints a message to the user and ends gracefully. If nodeps is set to
+ true, it will ignore package dependencies.
+ """
+ my_package_info = info(package)
+ type = my_package_info['type']
+ system_support = my_package_info['system_support']
+ source = my_package_info['source']
+ installed = my_package_info['installed']
- if not system_support:
- e_msg = 'Client does not have package manager %s to handle %s install' \
- % (type, package)
- raise error.PackageError(e_msg)
+ if not system_support:
+ e_msg = 'Client does not have package manager %s to handle %s install' \
+ % (type, package)
+ raise error.PackageError(e_msg)
- opt_args = ''
- if type == 'rpm':
- if nodeps:
- opt_args = opt_args + '--nodeps'
- install_command = 'rpm %s -U %s' % (opt_args, package)
- if type == 'dpkg':
- if nodeps:
- opt_args = opt_args + '--force-depends'
- install_command = 'dpkg %s -i %s' % (opt_args, package)
+ opt_args = ''
+ if type == 'rpm':
+ if nodeps:
+ opt_args = opt_args + '--nodeps'
+ install_command = 'rpm %s -U %s' % (opt_args, package)
+ if type == 'dpkg':
+ if nodeps:
+ opt_args = opt_args + '--force-depends'
+ install_command = 'dpkg %s -i %s' % (opt_args, package)
- # RPM source packages can be installed along with the binary versions
- # with this check
- if installed and not source:
- return 'Package %s is already installed' % package
+ # RPM source packages can be installed along with the binary versions
+ # with this check
+ if installed and not source:
+ return 'Package %s is already installed' % package
- # At this point, the most likely thing to go wrong is that there are
- # unmet dependencies for the package. We won't cover this case, at
- # least for now.
- utils.system(install_command)
- return 'Package %s was installed successfuly' % package
+ # At this point, the most likely thing to go wrong is that there are
+ # unmet dependencies for the package. We won't cover this case, at
+ # least for now.
+ utils.system(install_command)
+ return 'Package %s was installed successfuly' % package
def convert(package, destination_format):
- """\
- Convert packages with the 'alien' utility. If alien is not installed, it
- throws a NotImplementedError exception.
- returns: filename of the package generated.
- """
- try:
- os_dep.command('alien')
- except:
- e_msg = 'Cannot convert to %s, alien not installed' % destination_format
- raise error.TestError(e_msg)
+ """\
+ Convert packages with the 'alien' utility. If alien is not installed, it
+ throws a NotImplementedError exception.
+ returns: filename of the package generated.
+ """
+ try:
+ os_dep.command('alien')
+ except:
+ e_msg = 'Cannot convert to %s, alien not installed' % destination_format
+ raise error.TestError(e_msg)
- # alien supports converting to many formats, but its interesting to map
- # convertions only for the implemented package types.
- if destination_format == 'dpkg':
- deb_pattern = re.compile('[A-Za-z0-9_.-]*[.][d][e][b]')
- conv_output = utils.system_output('alien --to-deb %s 2>/dev/null' % package)
- converted_package = re.findall(deb_pattern, conv_output)[0]
- elif destination_format == 'rpm':
- rpm_pattern = re.compile('[A-Za-z0-9_.-]*[.][r][p][m]')
- conv_output = utils.system_output('alien --to-rpm %s 2>/dev/null' % package)
- converted_package = re.findall(rpm_pattern, conv_output)[0]
- else:
- e_msg = 'Convertion to format %s not implemented' % destination_format
- raise NotImplementedError(e_msg)
+ # alien supports converting to many formats, but its interesting to map
+ # convertions only for the implemented package types.
+ if destination_format == 'dpkg':
+ deb_pattern = re.compile('[A-Za-z0-9_.-]*[.][d][e][b]')
+ conv_output = utils.system_output('alien --to-deb %s 2>/dev/null' % package)
+ converted_package = re.findall(deb_pattern, conv_output)[0]
+ elif destination_format == 'rpm':
+ rpm_pattern = re.compile('[A-Za-z0-9_.-]*[.][r][p][m]')
+ conv_output = utils.system_output('alien --to-rpm %s 2>/dev/null' % package)
+ converted_package = re.findall(rpm_pattern, conv_output)[0]
+ else:
+ e_msg = 'Convertion to format %s not implemented' % destination_format
+ raise NotImplementedError(e_msg)
- print 'Package %s successfuly converted to %s' % \
- (os.path.basename(package), os.path.basename(converted_package))
- return os.path.abspath(converted_package)
+ print 'Package %s successfuly converted to %s' % \
+ (os.path.basename(package), os.path.basename(converted_package))
+ return os.path.abspath(converted_package)
def os_support():
- """\
- Returns a dictionary with host os package support info:
- - rpm: True if system supports rpm packages, False otherwise
- - dpkg: True if system supports dpkg packages, False otherwise
- - conversion: True if the system can convert packages (alien installed),
- or False otherwise
- """
- support_info = {}
- for package_manager in KNOWN_PACKAGE_MANAGERS:
- try:
- os_dep.command(package_manager)
- support_info[package_manager] = True
- except:
- support_info[package_manager] = False
+ """\
+ Returns a dictionary with host os package support info:
+ - rpm: True if system supports rpm packages, False otherwise
+ - dpkg: True if system supports dpkg packages, False otherwise
+ - conversion: True if the system can convert packages (alien installed),
+ or False otherwise
+ """
+ support_info = {}
+ for package_manager in KNOWN_PACKAGE_MANAGERS:
+ try:
+ os_dep.command(package_manager)
+ support_info[package_manager] = True
+ except:
+ support_info[package_manager] = False
- try:
- os_dep.command('alien')
- support_info['conversion'] = True
- except:
- support_info['conversion'] = False
+ try:
+ os_dep.command('alien')
+ support_info['conversion'] = True
+ except:
+ support_info['conversion'] = False
- return support_info
+ return support_info
diff --git a/client/bin/parallel.py b/client/bin/parallel.py
index a95b643..13a8b51 100644
--- a/client/bin/parallel.py
+++ b/client/bin/parallel.py
@@ -6,42 +6,42 @@
from autotest_lib.client.common_lib import error
def fork_start(tmp, l):
- sys.stdout.flush()
- sys.stderr.flush()
- pid = os.fork()
- if pid:
- # Parent
- return pid
+ sys.stdout.flush()
+ sys.stderr.flush()
+ pid = os.fork()
+ if pid:
+ # Parent
+ return pid
- try:
- try:
- l()
+ try:
+ try:
+ l()
- except error.AutotestError:
- raise
+ except error.AutotestError:
+ raise
- except:
- raise error.UnhandledError("test failed and threw:\n")
+ except:
+ raise error.UnhandledError("test failed and threw:\n")
- except Exception, detail:
- ename = tmp + "/debug/error-%d" % (os.getpid())
- pickle.dump(detail, open(ename, "w"))
+ except Exception, detail:
+ ename = tmp + "/debug/error-%d" % (os.getpid())
+ pickle.dump(detail, open(ename, "w"))
- sys.stdout.flush()
- sys.stderr.flush()
- os._exit(1)
+ sys.stdout.flush()
+ sys.stderr.flush()
+ os._exit(1)
- sys.stdout.flush()
- sys.stderr.flush()
- os._exit(0)
+ sys.stdout.flush()
+ sys.stderr.flush()
+ os._exit(0)
def fork_waitfor(tmp, pid):
- (pid, status) = os.waitpid(pid, 0)
+ (pid, status) = os.waitpid(pid, 0)
- ename = tmp + "/debug/error-%d" % pid
- if (os.path.exists(ename)):
- raise pickle.load(file(ename, 'r'))
+ ename = tmp + "/debug/error-%d" % pid
+ if (os.path.exists(ename)):
+ raise pickle.load(file(ename, 'r'))
- if (status != 0):
- raise error.TestError("test failed rc=%d" % (status))
+ if (status != 0):
+ raise error.TestError("test failed rc=%d" % (status))
diff --git a/client/bin/profiler.py b/client/bin/profiler.py
index b919542..ff821f9 100755
--- a/client/bin/profiler.py
+++ b/client/bin/profiler.py
@@ -1,25 +1,24 @@
class profiler:
- preserve_srcdir = False
+ preserve_srcdir = False
- def __init__(self, job):
- self.job = job
+ def __init__(self, job):
+ self.job = job
- def setup(self, *args):
- return
+ def setup(self, *args):
+ return
- def initialize(self, *args):
- return
+ def initialize(self, *args):
+ return
- def start(self, test):
- return
+ def start(self, test):
+ return
- def stop(self, test):
- return
+ def stop(self, test):
+ return
- def report(self, test):
- return
-
+ def report(self, test):
+ return
diff --git a/client/bin/profilers.py b/client/bin/profilers.py
index c080021..298cba9 100755
--- a/client/bin/profilers.py
+++ b/client/bin/profilers.py
@@ -4,71 +4,71 @@
class profilers:
- def __init__(self, job):
- self.job = job
- self.list = []
- self.profdir = job.autodir + '/profilers'
- self.tmpdir = job.tmpdir
- self.profile_run_only = False
+ def __init__(self, job):
+ self.job = job
+ self.list = []
+ self.profdir = job.autodir + '/profilers'
+ self.tmpdir = job.tmpdir
+ self.profile_run_only = False
- # add a profiler
- def add(self, profiler, *args, **dargs):
- try:
- sys.path.insert(0, self.job.profdir + '/' + profiler)
- exec 'import ' + profiler
- exec 'newprofiler = %s.%s(self)' % (profiler, profiler)
- finally:
- sys.path.pop(0)
- newprofiler.name = profiler
- newprofiler.bindir = self.profdir + '/' + profiler
- newprofiler.srcdir = newprofiler.bindir + '/src'
- newprofiler.tmpdir = self.tmpdir + '/' + profiler
- utils.update_version(newprofiler.srcdir, newprofiler.preserve_srcdir,
- newprofiler.version, newprofiler.setup,
- *args, **dargs)
- newprofiler.initialize(*args, **dargs)
- self.list.append(newprofiler)
+ # add a profiler
+ def add(self, profiler, *args, **dargs):
+ try:
+ sys.path.insert(0, self.job.profdir + '/' + profiler)
+ exec 'import ' + profiler
+ exec 'newprofiler = %s.%s(self)' % (profiler, profiler)
+ finally:
+ sys.path.pop(0)
+ newprofiler.name = profiler
+ newprofiler.bindir = self.profdir + '/' + profiler
+ newprofiler.srcdir = newprofiler.bindir + '/src'
+ newprofiler.tmpdir = self.tmpdir + '/' + profiler
+ utils.update_version(newprofiler.srcdir, newprofiler.preserve_srcdir,
+ newprofiler.version, newprofiler.setup,
+ *args, **dargs)
+ newprofiler.initialize(*args, **dargs)
+ self.list.append(newprofiler)
- # remove a profiler
- def delete(self, profiler):
- nukeme = None
- for p in self.list:
- if (p.name == profiler):
- nukeme = p
- self.list.remove(p)
+ # remove a profiler
+ def delete(self, profiler):
+ nukeme = None
+ for p in self.list:
+ if (p.name == profiler):
+ nukeme = p
+ self.list.remove(p)
- # are any profilers enabled ?
- def present(self):
- if self.list:
- return 1
- else:
- return 0
+ # are any profilers enabled ?
+ def present(self):
+ if self.list:
+ return 1
+ else:
+ return 0
- # Returns True if job is supposed to be run only with profiling turned
- # on, False otherwise
- def only(self):
- return self.profile_run_only
+ # Returns True if job is supposed to be run only with profiling turned
+ # on, False otherwise
+ def only(self):
+ return self.profile_run_only
- # Changes the flag which determines whether or not the job is to be
- # run without profilers at all
- def set_only(self, value):
- self.profile_run_only = value
+ # Changes the flag which determines whether or not the job is to be
+ # run without profilers at all
+ def set_only(self, value):
+ self.profile_run_only = value
- # Start all enabled profilers
- def start(self, test):
- for p in self.list:
- p.start(test)
+ # Start all enabled profilers
+ def start(self, test):
+ for p in self.list:
+ p.start(test)
- # Stop all enabled profilers
- def stop(self, test):
- for p in self.list:
- p.stop(test)
+ # Stop all enabled profilers
+ def stop(self, test):
+ for p in self.list:
+ p.stop(test)
- # Report on all enabled profilers
- def report(self, test):
- for p in self.list:
- p.report(test)
+ # Report on all enabled profilers
+ def report(self, test):
+ for p in self.list:
+ p.report(test)
diff --git a/client/bin/sysinfo.py b/client/bin/sysinfo.py
index 2f605ea..107229c 100755
--- a/client/bin/sysinfo.py
+++ b/client/bin/sysinfo.py
@@ -6,14 +6,14 @@
from autotest_lib.client.common_lib import utils
try:
- from autotest_lib.client.bin import site_sysinfo
- local = True
+ from autotest_lib.client.bin import site_sysinfo
+ local = True
except ImportError:
- local = False
+ local = False
# stuff to log per reboot
-files = ['/proc/pci', '/proc/meminfo', '/proc/slabinfo', '/proc/version',
- '/proc/cpuinfo', '/proc/cmdline', '/proc/modules']
+files = ['/proc/pci', '/proc/meminfo', '/proc/slabinfo', '/proc/version',
+ '/proc/cpuinfo', '/proc/cmdline', '/proc/modules']
# commands = ['lshw'] # this causes problems triggering CDROM drives
commands = ['uname -a', 'lspci -vvn', 'gcc --version', 'ld --version',
'mount', 'hostname']
@@ -21,84 +21,84 @@
def run_command(command, output):
- parts = command.split(None, 1)
- cmd = parts[0]
- if len(parts) > 1:
- args = parts[1]
- else:
- args = ''
- for dir in path:
- pathname = dir + '/' + cmd
- if not os.path.exists(pathname):
- continue
- tmp_cmd = "%s %s > %s 2> /dev/null" % (pathname, args, output)
- utils.system(tmp_cmd)
+ parts = command.split(None, 1)
+ cmd = parts[0]
+ if len(parts) > 1:
+ args = parts[1]
+ else:
+ args = ''
+ for dir in path:
+ pathname = dir + '/' + cmd
+ if not os.path.exists(pathname):
+ continue
+ tmp_cmd = "%s %s > %s 2> /dev/null" % (pathname, args, output)
+ utils.system(tmp_cmd)
def reboot_count():
- if not glob.glob('*'):
- return -1 # No reboots, initial data not logged
- else:
- return len(glob.glob('reboot*'))
-
-
+ if not glob.glob('*'):
+ return -1 # No reboots, initial data not logged
+ else:
+ return len(glob.glob('reboot*'))
+
+
def boot_subdir(reboot_count):
- """subdir of job sysinfo"""
- if reboot_count == 0:
- return '.'
- else:
- return 'reboot%d' % reboot_count
+ """subdir of job sysinfo"""
+ if reboot_count == 0:
+ return '.'
+ else:
+ return 'reboot%d' % reboot_count
def log_per_reboot_data(sysinfo_dir):
- """we log this data when the job starts, and again after any reboot"""
- pwd = os.getcwd()
- try:
- os.chdir(sysinfo_dir)
- subdir = boot_subdir(reboot_count() + 1)
- if not os.path.exists(subdir):
- os.mkdir(subdir)
- os.chdir(os.path.join(sysinfo_dir, subdir))
- _log_per_reboot_data()
- finally:
- os.chdir(pwd)
+ """we log this data when the job starts, and again after any reboot"""
+ pwd = os.getcwd()
+ try:
+ os.chdir(sysinfo_dir)
+ subdir = boot_subdir(reboot_count() + 1)
+ if not os.path.exists(subdir):
+ os.mkdir(subdir)
+ os.chdir(os.path.join(sysinfo_dir, subdir))
+ _log_per_reboot_data()
+ finally:
+ os.chdir(pwd)
def _log_per_reboot_data():
- """system info to log before each step of the job"""
- for command in commands:
- run_command(command, re.sub(r'\s', '_', command))
+ """system info to log before each step of the job"""
+ for command in commands:
+ run_command(command, re.sub(r'\s', '_', command))
- for file in files:
- if (os.path.exists(file)):
- shutil.copyfile(file, os.path.basename(file))
+ for file in files:
+ if (os.path.exists(file)):
+ shutil.copyfile(file, os.path.basename(file))
- utils.system('dmesg -c > dmesg', ignore_status=True)
- utils.system('df -mP > df', ignore_status=True)
- if local:
- site_sysinfo.log_per_reboot_data()
+ utils.system('dmesg -c > dmesg', ignore_status=True)
+ utils.system('df -mP > df', ignore_status=True)
+ if local:
+ site_sysinfo.log_per_reboot_data()
def log_after_each_test(test_sysinfo_dir, job_sysinfo_dir):
- """log things that change after each test (called from test.py)"""
- pwd = os.getcwd()
- try:
- os.chdir(job_sysinfo_dir)
- reboot_subdir = boot_subdir(reboot_count())
- reboot_dir = os.path.join(job_sysinfo_dir, reboot_subdir)
- assert os.path.exists(reboot_dir)
+ """log things that change after each test (called from test.py)"""
+ pwd = os.getcwd()
+ try:
+ os.chdir(job_sysinfo_dir)
+ reboot_subdir = boot_subdir(reboot_count())
+ reboot_dir = os.path.join(job_sysinfo_dir, reboot_subdir)
+ assert os.path.exists(reboot_dir)
- os.makedirs(test_sysinfo_dir)
- os.chdir(test_sysinfo_dir)
- utils.system('ln -s %s reboot_current' % reboot_dir)
+ os.makedirs(test_sysinfo_dir)
+ os.chdir(test_sysinfo_dir)
+ utils.system('ln -s %s reboot_current' % reboot_dir)
- utils.system('dmesg -c > dmesg', ignore_status=True)
- utils.system('df -mP > df', ignore_status=True)
- if local:
- site_sysinfo.log_after_each_test()
- finally:
- os.chdir(pwd)
-
-
+ utils.system('dmesg -c > dmesg', ignore_status=True)
+ utils.system('df -mP > df', ignore_status=True)
+ if local:
+ site_sysinfo.log_after_each_test()
+ finally:
+ os.chdir(pwd)
+
+
if __name__ == '__main__':
- log_per_reboot_data()
+ log_per_reboot_data()
diff --git a/client/bin/test.py b/client/bin/test.py
index 78dbdd1..5d5d4f9 100755
--- a/client/bin/test.py
+++ b/client/bin/test.py
@@ -3,20 +3,20 @@
# Shell class for a test, inherited by all individual tests
#
# Methods:
-# __init__ initialise
-# initialize run once for each job
-# setup run once for each new version of the test installed
-# run run the test (wrapped by job.run_test())
+# __init__ initialise
+# initialize run once for each job
+# setup run once for each new version of the test installed
+# run run the test (wrapped by job.run_test())
#
# Data:
-# job backreference to the job this test instance is part of
-# outputdir eg. results/<job>/<testname.tag>
-# resultsdir eg. results/<job>/<testname.tag>/results
-# profdir eg. results/<job>/<testname.tag>/profiling
-# debugdir eg. results/<job>/<testname.tag>/debug
-# bindir eg. tests/<test>
-# src eg. tests/<test>/src
-# tmpdir eg. tmp/<testname.tag>
+# job backreference to the job this test instance is part of
+# outputdir eg. results/<job>/<testname.tag>
+# resultsdir eg. results/<job>/<testname.tag>/results
+# profdir eg. results/<job>/<testname.tag>/profiling
+# debugdir eg. results/<job>/<testname.tag>/debug
+# bindir eg. tests/<test>
+# src eg. tests/<test>/src
+# tmpdir eg. tmp/<testname.tag>
import os, traceback
@@ -26,23 +26,23 @@
class test(common_test.base_test):
- pass
+ pass
testname = common_test.testname
def _grab_sysinfo(mytest):
- try:
- sysinfo_dir = os.path.join(mytest.outputdir, 'sysinfo')
- sysinfo.log_after_each_test(sysinfo_dir, mytest.job.sysinfodir)
- if os.path.exists(mytest.tmpdir):
- utils.system('rm -rf ' + mytest.tmpdir)
- except:
- print 'after-test error:'
- traceback.print_exc(file=sys.stdout)
+ try:
+ sysinfo_dir = os.path.join(mytest.outputdir, 'sysinfo')
+ sysinfo.log_after_each_test(sysinfo_dir, mytest.job.sysinfodir)
+ if os.path.exists(mytest.tmpdir):
+ utils.system('rm -rf ' + mytest.tmpdir)
+ except:
+ print 'after-test error:'
+ traceback.print_exc(file=sys.stdout)
def runtest(job, url, tag, args, dargs):
- common_test.runtest(job, url, tag, args, dargs,
- locals(), globals(), _grab_sysinfo)
+ common_test.runtest(job, url, tag, args, dargs,
+ locals(), globals(), _grab_sysinfo)
diff --git a/client/bin/test_config.py b/client/bin/test_config.py
index e926813..d8a5337 100644
--- a/client/bin/test_config.py
+++ b/client/bin/test_config.py
@@ -13,79 +13,79 @@
__all__ = ['config_loader']
class config_loader:
- """Base class of the configuration parser"""
- def __init__(self, cfg, tmpdir = '/tmp'):
- """\
- Instantiate ConfigParser and provide the file like object that we'll
- use to read configuration data from.
- Args:
- * cfg: Where we'll get configuration data. It can be either:
- * A URL containing the file
- * A valid file path inside the filesystem
- * A string containing configuration data
- * tmpdir: Where we'll dump the temporary conf files. The default
- is the /tmp directory.
- """
- # Base Parser
- self.parser = ConfigParser()
- # File is already a file like object
- if hasattr(cfg, 'read'):
- self.cfg = cfg
- self.parser.readfp(self.cfg)
- elif isinstance(cfg, types.StringTypes):
- # Config file is a URL. Download it to a temp dir
- if cfg.startswith('http') or cfg.startswith('ftp'):
- self.cfg = path.join(tmpdir, path.basename(cfg))
- utils.urlretrieve(cfg, self.cfg)
- self.parser.read(self.cfg)
- # Config is a valid filesystem path to a file.
- elif path.exists(path.abspath(cfg)):
- if path.isfile(cfg):
- self.cfg = path.abspath(cfg)
- self.parser.read(self.cfg)
- else:
- e_msg = 'Invalid config file path: %s' % cfg
- raise IOError(e_msg)
- # Config file is just a string, convert it to a python file like
- # object using StringIO
- else:
- self.cfg = StringIO(cfg)
- self.parser.readfp(self.cfg)
+ """Base class of the configuration parser"""
+ def __init__(self, cfg, tmpdir = '/tmp'):
+ """\
+ Instantiate ConfigParser and provide the file like object that we'll
+ use to read configuration data from.
+ Args:
+ * cfg: Where we'll get configuration data. It can be either:
+ * A URL containing the file
+ * A valid file path inside the filesystem
+ * A string containing configuration data
+ * tmpdir: Where we'll dump the temporary conf files. The default
+ is the /tmp directory.
+ """
+ # Base Parser
+ self.parser = ConfigParser()
+ # File is already a file like object
+ if hasattr(cfg, 'read'):
+ self.cfg = cfg
+ self.parser.readfp(self.cfg)
+ elif isinstance(cfg, types.StringTypes):
+ # Config file is a URL. Download it to a temp dir
+ if cfg.startswith('http') or cfg.startswith('ftp'):
+ self.cfg = path.join(tmpdir, path.basename(cfg))
+ utils.urlretrieve(cfg, self.cfg)
+ self.parser.read(self.cfg)
+ # Config is a valid filesystem path to a file.
+ elif path.exists(path.abspath(cfg)):
+ if path.isfile(cfg):
+ self.cfg = path.abspath(cfg)
+ self.parser.read(self.cfg)
+ else:
+ e_msg = 'Invalid config file path: %s' % cfg
+ raise IOError(e_msg)
+ # Config file is just a string, convert it to a python file like
+ # object using StringIO
+ else:
+ self.cfg = StringIO(cfg)
+ self.parser.readfp(self.cfg)
- def get(self, section, name, default=None):
- """Get the value of a option.
+ def get(self, section, name, default=None):
+ """Get the value of a option.
- Section of the config file and the option name.
- You can pass a default value if the option doesn't exist.
- """
- if not self.parser.has_option(section, name):
- return default
- return self.parser.get(section, name)
+ Section of the config file and the option name.
+ You can pass a default value if the option doesn't exist.
+ """
+ if not self.parser.has_option(section, name):
+ return default
+ return self.parser.get(section, name)
- def set(self, section, option, value):
- """Set an option.
+ def set(self, section, option, value):
+ """Set an option.
- This change is not persistent unless saved with 'save()'.
- """
- if not self.parser.has_section(section):
- self.parser.add_section(section)
- return self.parser.set(section, name, value)
+ This change is not persistent unless saved with 'save()'.
+ """
+ if not self.parser.has_section(section):
+ self.parser.add_section(section)
+ return self.parser.set(section, name, value)
- def remove(self, section, name):
- """Remove an option."""
- if self.parser.has_section(section):
- self.parser.remove_option(section, name)
+ def remove(self, section, name):
+ """Remove an option."""
+ if self.parser.has_section(section):
+ self.parser.remove_option(section, name)
- def save(self):
- """Save the configuration file with all modifications"""
- if not self.filename:
- return
- fileobj = file(self.filename, 'w')
- try:
- self.parser.write(fileobj)
- finally:
- fileobj.close()
+ def save(self):
+ """Save the configuration file with all modifications"""
+ if not self.filename:
+ return
+ fileobj = file(self.filename, 'w')
+ try:
+ self.parser.write(fileobj)
+ finally:
+ fileobj.close()
diff --git a/client/bin/xen.py b/client/bin/xen.py
index d69b2c5..a792427 100644
--- a/client/bin/xen.py
+++ b/client/bin/xen.py
@@ -8,201 +8,201 @@
class xen(kernel.kernel):
- def log(self, msg):
- print msg
- self.logfile.write('%s\n' % msg)
+ def log(self, msg):
+ print msg
+ self.logfile.write('%s\n' % msg)
- def __init__(self, job, base_tree, results_dir, tmp_dir, build_dir, \
- leave = False, kjob = None):
- # call base-class
- kernel.kernel.__init__(self, job, base_tree, results_dir, \
- tmp_dir, build_dir, leave)
- self.kjob = kjob
+ def __init__(self, job, base_tree, results_dir, tmp_dir, build_dir, \
+ leave = False, kjob = None):
+ # call base-class
+ kernel.kernel.__init__(self, job, base_tree, results_dir, \
+ tmp_dir, build_dir, leave)
+ self.kjob = kjob
- def config(self, config_file, config_list = None):
- raise NotImplementedError('config() not implemented for xen')
+ def config(self, config_file, config_list = None):
+ raise NotImplementedError('config() not implemented for xen')
- def build(self, make_opts = '', logfile = '', extraversion='autotest'):
- """build xen
+ def build(self, make_opts = '', logfile = '', extraversion='autotest'):
+ """build xen
- make_opts
- additional options to make, if any
- """
- self.log('running build')
- os_dep.commands('gcc', 'make')
- # build xen with extraversion flag
- os.environ['XEN_EXTRAVERSION'] = '-unstable-%s'% extraversion
- if logfile == '':
- logfile = os.path.join(self.log_dir, 'xen_build')
- os.chdir(self.build_dir)
- self.log('log_dir: %s ' % os.path.join(self.log_dir, 'stdout'))
- self.job.stdout.tee_redirect(logfile + '.stdout')
- self.job.stderr.tee_redirect(logfile + '.stderr')
+ make_opts
+ additional options to make, if any
+ """
+ self.log('running build')
+ os_dep.commands('gcc', 'make')
+ # build xen with extraversion flag
+ os.environ['XEN_EXTRAVERSION'] = '-unstable-%s'% extraversion
+ if logfile == '':
+ logfile = os.path.join(self.log_dir, 'xen_build')
+ os.chdir(self.build_dir)
+ self.log('log_dir: %s ' % os.path.join(self.log_dir, 'stdout'))
+ self.job.stdout.tee_redirect(logfile + '.stdout')
+ self.job.stderr.tee_redirect(logfile + '.stderr')
- # build xen hypervisor and user-space tools
- targets = ['xen', 'tools']
- threads = 2 * autotest_utils.count_cpus()
- for t in targets:
- build_string = 'make -j %d %s %s' % (threads, make_opts, t)
- self.log('build_string: %s' % build_string)
- system(build_string)
+ # build xen hypervisor and user-space tools
+ targets = ['xen', 'tools']
+ threads = 2 * autotest_utils.count_cpus()
+ for t in targets:
+ build_string = 'make -j %d %s %s' % (threads, make_opts, t)
+ self.log('build_string: %s' % build_string)
+ system(build_string)
- # make a kernel job out of the kernel from the xen src if one isn't provided
- if self.kjob == None:
- # get xen kernel tree ready
- self.log("prep-ing xen'ified kernel source tree")
- system('make prep-kernels')
+ # make a kernel job out of the kernel from the xen src if one isn't provided
+ if self.kjob == None:
+ # get xen kernel tree ready
+ self.log("prep-ing xen'ified kernel source tree")
+ system('make prep-kernels')
- v = self.get_xen_kernel_build_ver()
- self.log('building xen kernel version: %s' % v)
+ v = self.get_xen_kernel_build_ver()
+ self.log('building xen kernel version: %s' % v)
- # build xen-ified kernel in xen tree
- kernel_base_tree = os.path.join(self.build_dir, \
- 'linux-%s' % self.get_xen_kernel_build_ver())
+ # build xen-ified kernel in xen tree
+ kernel_base_tree = os.path.join(self.build_dir, \
+ 'linux-%s' % self.get_xen_kernel_build_ver())
- self.log('kernel_base_tree = %s' % kernel_base_tree)
- # fix up XENGUEST value in EXTRAVERSION; we can't have
- # files with '$(XENGEUST)' in the name, =(
- self.fix_up_xen_kernel_makefile(kernel_base_tree)
+ self.log('kernel_base_tree = %s' % kernel_base_tree)
+ # fix up XENGUEST value in EXTRAVERSION; we can't have
+ # files with '$(XENGEUST)' in the name, =(
+ self.fix_up_xen_kernel_makefile(kernel_base_tree)
- # make the kernel job
- self.kjob = self.job.kernel(kernel_base_tree)
+ # make the kernel job
+ self.kjob = self.job.kernel(kernel_base_tree)
- # hardcoding dom0 config (no modules for testing, yay!)
- # FIXME: probe host to determine which config to pick
- c = self.build_dir + '/buildconfigs/linux-defconfig_xen0_x86_32'
- self.log('using kernel config: %s ' % c)
- self.kjob.config(c)
+ # hardcoding dom0 config (no modules for testing, yay!)
+ # FIXME: probe host to determine which config to pick
+ c = self.build_dir + '/buildconfigs/linux-defconfig_xen0_x86_32'
+ self.log('using kernel config: %s ' % c)
+ self.kjob.config(c)
- # Xen's kernel tree sucks; doesn't use bzImage, but vmlinux
- self.kjob.set_build_target('vmlinuz')
+ # Xen's kernel tree sucks; doesn't use bzImage, but vmlinux
+ self.kjob.set_build_target('vmlinuz')
- # also, the vmlinuz is not out in arch/*/boot, ARGH! more hackery
- self.kjob.set_build_image(self.job.tmpdir + '/build/linux/vmlinuz')
+ # also, the vmlinuz is not out in arch/*/boot, ARGH! more hackery
+ self.kjob.set_build_image(self.job.tmpdir + '/build/linux/vmlinuz')
- self.kjob.build()
+ self.kjob.build()
- self.job.stdout.restore()
- self.job.stderr.restore()
+ self.job.stdout.restore()
+ self.job.stderr.restore()
- xen_version = self.get_xen_build_ver()
- self.log('BUILD VERSION: Xen: %s Kernel:%s' % \
- (xen_version, self.kjob.get_kernel_build_ver()))
+ xen_version = self.get_xen_build_ver()
+ self.log('BUILD VERSION: Xen: %s Kernel:%s' % \
+ (xen_version, self.kjob.get_kernel_build_ver()))
- def build_timed(self, *args, **kwds):
- raise NotImplementedError('build_timed() not implemented')
+ def build_timed(self, *args, **kwds):
+ raise NotImplementedError('build_timed() not implemented')
- def install(self, tag='', prefix = '/', extraversion='autotest'):
- """make install in the kernel tree"""
- self.log('Installing ...')
+ def install(self, tag='', prefix = '/', extraversion='autotest'):
+ """make install in the kernel tree"""
+ self.log('Installing ...')
- os.chdir(self.build_dir)
+ os.chdir(self.build_dir)
- if not os.path.isdir(prefix):
- os.mkdir(prefix)
- self.boot_dir = os.path.join(prefix, 'boot')
- if not os.path.isdir(self.boot_dir):
- os.mkdir(self.boot_dir)
+ if not os.path.isdir(prefix):
+ os.mkdir(prefix)
+ self.boot_dir = os.path.join(prefix, 'boot')
+ if not os.path.isdir(self.boot_dir):
+ os.mkdir(self.boot_dir)
- # remember what we are going to install
- xen_version = '%s-%s' % (self.get_xen_build_ver(), extraversion)
- self.xen_image = self.boot_dir + '/xen-' + xen_version + '.gz'
- self.xen_syms = self.boot_dir + '/xen-syms-' + xen_version
+ # remember what we are going to install
+ xen_version = '%s-%s' % (self.get_xen_build_ver(), extraversion)
+ self.xen_image = self.boot_dir + '/xen-' + xen_version + '.gz'
+ self.xen_syms = self.boot_dir + '/xen-syms-' + xen_version
- self.log('Installing Xen ...')
- os.environ['XEN_EXTRAVERSION'] = '-unstable-%s'% extraversion
+ self.log('Installing Xen ...')
+ os.environ['XEN_EXTRAVERSION'] = '-unstable-%s'% extraversion
- # install xen
- system('make DESTDIR=%s -C xen install' % prefix)
+ # install xen
+ system('make DESTDIR=%s -C xen install' % prefix)
- # install tools
- system('make DESTDIR=%s -C tools install' % prefix)
+ # install tools
+ system('make DESTDIR=%s -C tools install' % prefix)
- # install kernel
- ktag = self.kjob.get_kernel_build_ver()
- kprefix = prefix
- self.kjob.install(tag=ktag, prefix=kprefix)
+ # install kernel
+ ktag = self.kjob.get_kernel_build_ver()
+ kprefix = prefix
+ self.kjob.install(tag=ktag, prefix=kprefix)
- def add_to_bootloader(self, tag='autotest', args=''):
- """ add this kernel to bootloader, taking an
- optional parameter of space separated parameters
- e.g.: kernel.add_to_bootloader('mykernel', 'ro acpi=off')
- """
+ def add_to_bootloader(self, tag='autotest', args=''):
+ """ add this kernel to bootloader, taking an
+ optional parameter of space separated parameters
+ e.g.: kernel.add_to_bootloader('mykernel', 'ro acpi=off')
+ """
- # turn on xen mode
- self.job.bootloader.enable_xen_mode()
+ # turn on xen mode
+ self.job.bootloader.enable_xen_mode()
- # remove existing entry if present
- self.job.bootloader.remove_kernel(tag)
+ # remove existing entry if present
+ self.job.bootloader.remove_kernel(tag)
- # add xen and xen kernel
- self.job.bootloader.add_kernel(self.kjob.image, tag, \
- self.kjob.initrd, self.xen_image)
+ # add xen and xen kernel
+ self.job.bootloader.add_kernel(self.kjob.image, tag, \
+ self.kjob.initrd, self.xen_image)
- # if no args passed, populate from /proc/cmdline
- if not args:
- args = open('/proc/cmdline', 'r').readline().strip()
+ # if no args passed, populate from /proc/cmdline
+ if not args:
+ args = open('/proc/cmdline', 'r').readline().strip()
- # add args to entry one at a time
- for a in args.split(' '):
- self.job.bootloader.add_args(tag, a)
+ # add args to entry one at a time
+ for a in args.split(' '):
+ self.job.bootloader.add_args(tag, a)
- # turn off xen mode
- self.job.bootloader.disable_xen_mode()
+ # turn off xen mode
+ self.job.bootloader.disable_xen_mode()
- def get_xen_kernel_build_ver(self):
- """Check xen buildconfig for current kernel version"""
- version = patchlevel = sublevel = ''
- extraversion = localversion = ''
+ def get_xen_kernel_build_ver(self):
+ """Check xen buildconfig for current kernel version"""
+ version = patchlevel = sublevel = ''
+ extraversion = localversion = ''
- version_file = self.build_dir + '/buildconfigs/mk.linux-2.6-xen'
+ version_file = self.build_dir + '/buildconfigs/mk.linux-2.6-xen'
- for line in open(version_file, 'r').readlines():
- if line.startswith('LINUX_VER'):
- start = line.index('=') + 1
- version = line[start:].strip() + "-xen"
- break
+ for line in open(version_file, 'r').readlines():
+ if line.startswith('LINUX_VER'):
+ start = line.index('=') + 1
+ version = line[start:].strip() + "-xen"
+ break
- return version
+ return version
- def fix_up_xen_kernel_makefile(self, kernel_dir):
- """Fix up broken EXTRAVERSION in xen-ified Linux kernel Makefile"""
- xenguest = ''
- makefile = kernel_dir + '/Makefile'
+ def fix_up_xen_kernel_makefile(self, kernel_dir):
+ """Fix up broken EXTRAVERSION in xen-ified Linux kernel Makefile"""
+ xenguest = ''
+ makefile = kernel_dir + '/Makefile'
- for line in open(makefile, 'r').readlines():
- if line.startswith('XENGUEST'):
- start = line.index('=') + 1
- xenguest = line[start:].strip()
- break;
+ for line in open(makefile, 'r').readlines():
+ if line.startswith('XENGUEST'):
+ start = line.index('=') + 1
+ xenguest = line[start:].strip()
+ break;
- # change out $XENGUEST in EXTRAVERSION line
- system('sed -i.old "s,\$(XENGUEST),%s," %s' % \
- (xenguest, makefile))
+ # change out $XENGUEST in EXTRAVERSION line
+ system('sed -i.old "s,\$(XENGUEST),%s," %s' % \
+ (xenguest, makefile))
- def get_xen_build_ver(self):
- """Check Makefile and .config to return kernel version"""
- version = patchlevel = sublevel = ''
- extraversion = localversion = ''
+ def get_xen_build_ver(self):
+ """Check Makefile and .config to return kernel version"""
+ version = patchlevel = sublevel = ''
+ extraversion = localversion = ''
- for line in open(self.build_dir + '/xen/Makefile', 'r').readlines():
- if line.startswith('export XEN_VERSION'):
- start = line.index('=') + 1
- version = line[start:].strip()
- if line.startswith('export XEN_SUBVERSION'):
- start = line.index('=') + 1
- sublevel = line[start:].strip()
- if line.startswith('export XEN_EXTRAVERSION'):
- start = line.index('=') + 1
- extraversion = line[start:].strip()
+ for line in open(self.build_dir + '/xen/Makefile', 'r').readlines():
+ if line.startswith('export XEN_VERSION'):
+ start = line.index('=') + 1
+ version = line[start:].strip()
+ if line.startswith('export XEN_SUBVERSION'):
+ start = line.index('=') + 1
+ sublevel = line[start:].strip()
+ if line.startswith('export XEN_EXTRAVERSION'):
+ start = line.index('=') + 1
+ extraversion = line[start:].strip()
- return "%s.%s%s" % (version, sublevel, extraversion)
+ return "%s.%s%s" % (version, sublevel, extraversion)
