client Package

autotest_local Module

class autotest.client.autotest_local.AutotestLocalApp

Autotest local app runs tests locally

Point it to a control file and let it rock

main()

parse_cmdline()

usage()

base_sysinfo Module

class autotest.client.base_sysinfo.base_sysinfo(job_resultsdir)

Bases: object

deserialize(serialized)

log_after_each_iteration(*args, **dargs)

log_after_each_test(*args, **dargs)

log_before_each_iteration(*args, **dargs)

log_before_each_test(*args, **dargs)

log_per_reboot_data(*args, **dargs)

log_test_keyvals(test_sysinfodir)

Logging hook called by log_after_each_test to collect keyval entries to be written in the test keyval.

serialize()

class autotest.client.base_sysinfo.command(cmd, logf=None, log_in_keyval=False, compress_log=False)

Bases: autotest.client.base_sysinfo.loggable

run(logdir)

class autotest.client.base_sysinfo.logfile(path, logf=None, log_in_keyval=False)

Bases: autotest.client.base_sysinfo.loggable

run(logdir)

class autotest.client.base_sysinfo.loggable(logf, log_in_keyval)

Bases: object

Abstract class for representing all things “loggable” by sysinfo.

readline(logdir)

base_utils Module

DO NOT import this file directly - import client/bin/utils.py, which will mix this in

Convenience functions for use by tests or whomever.

Note that this file is mixed in by utils.py - note very carefully the precedence order defined there

autotest.client.base_utils.append_path(oldpath, newpath)

append newpath to oldpath

autotest.client.base_utils.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.

autotest.client.base_utils.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

autotest.client.base_utils.check_for_kernel_feature(feature)

autotest.client.base_utils.check_glibc_ver(ver)

autotest.client.base_utils.check_kernel_ver(ver)

autotest.client.base_utils.count_cpus()

number of CPUs in the local machine according to /proc/cpuinfo

autotest.client.base_utils.cpu_has_flags(flags)

Check if a list of flags are available on current CPU info

Parameters:flags – A list of cpu flags that must exists

on the current CPU. :type flags: list :returns: bool True if all the flags were found or False if not :rtype: list

autotest.client.base_utils.cpu_online_map()

Check out the available cpu online map

autotest.client.base_utils.difflist(list1, list2)

returns items in list2 that are not in list1

autotest.client.base_utils.disk_block_size(path)

Return the disk block size, in bytes

autotest.client.base_utils.dump_object(object)

Dump an object’s attributes and methods

kind of like dir()

autotest.client.base_utils.environ(env_key)

return the requested environment variable, or ‘’ if unset

autotest.client.base_utils.extract_all_time_results(results_string)

Extract user, system, and elapsed times into a list of tuples

autotest.client.base_utils.extract_tarball(tarball)

Returns the directory extracted by the tarball.

autotest.client.base_utils.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

autotest.client.base_utils.file_contains_pattern(file, pattern)

Return true if file contains the specified egrep pattern

autotest.client.base_utils.force_copy(src, dest)

Replace dest with a new copy of src, even if it exists

autotest.client.base_utils.force_link(src, dest)

Link src to dest, overwriting it if it exists

autotest.client.base_utils.freespace(path)

Return the disk free space, in bytes

autotest.client.base_utils.get_cc()

autotest.client.base_utils.get_cpu_arch()

Work out which CPU architecture we’re running on

autotest.client.base_utils.get_cpu_family()

autotest.client.base_utils.get_cpu_info()

Reads /proc/cpuinfo and returns a list of file lines

Returns:list of lines from /proc/cpuinfo file Return type:list

autotest.client.base_utils.get_cpu_stat(key)

Get load per cpu from /proc/stat :return: list of values of CPU times

autotest.client.base_utils.get_cpu_vendor()

autotest.client.base_utils.get_cpu_vendor_name()

Get the current cpu vendor name

Returns:string ‘intel’ or ‘amd’ or ‘power7’ depending

on the current CPU architecture. :rtype: string

autotest.client.base_utils.get_current_kernel_arch()

Get the machine architecture

autotest.client.base_utils.get_disks()

autotest.client.base_utils.get_file_arch(filename)

autotest.client.base_utils.get_hwclock_seconds(utc=True)

Return the hardware clock in seconds as a floating point value. Use Coordinated Universal Time if utc is True, local time otherwise. Raise a ValueError if unable to read the hardware clock.

autotest.client.base_utils.get_loaded_modules()

autotest.client.base_utils.get_modules_dir()

Return the modules dir for the running kernel version

autotest.client.base_utils.get_os_vendor()

Try to guess what’s the os vendor.

autotest.client.base_utils.get_systemmap()

Return the full path to System.map

Ahem. This is crap. Pray harder. Bad Martin.

autotest.client.base_utils.get_uptime()

Returns:return the uptime of system in secs in float

in error case return ‘None’

autotest.client.base_utils.get_vmlinux()

Return the full path to vmlinux

Ahem. This is crap. Pray harder. Bad Martin.

autotest.client.base_utils.grep(pattern, file)

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.

autotest.client.base_utils.hash_file(filename, size=None, method='md5')

Calculate the hash of filename. If size is not None, limit to first size bytes. Throw exception if something is wrong with filename. Can be also implemented with bash one-liner (assuming size%1024==0): dd if=filename bs=1024 count=size/1024 | sha1sum -

Parameters:

• filename – Path of the file that will have its hash calculated.
• method – Method used to calculate the hash. Supported methods: * md5 * sha1

Returns:

Hash of the file, if something goes wrong, return None.

autotest.client.base_utils.human_format(number)

autotest.client.base_utils.list_grep(list, pattern)

True if any item in list matches the specified pattern.

autotest.client.base_utils.load_module(module_name)

autotest.client.base_utils.locate(pattern, root='/home/docs/checkouts/readthedocs.org/user_builds/autotest/checkouts/0.16.0/documentation/source')

autotest.client.base_utils.module_is_loaded(module_name)

autotest.client.base_utils.pickle_load(filename)

autotest.client.base_utils.ping_default_gateway()

Ping the default gateway.

autotest.client.base_utils.prepend_path(newpath, oldpath)

prepend newpath to oldpath

autotest.client.base_utils.print_to_tty(string)

Output string straight to the tty

autotest.client.base_utils.process_is_alive(name_pattern)

‘pgrep name’ misses all python processes and also long process names. ‘pgrep -f name’ gets all shell commands with name in args. So look only for command whose initial pathname ends with name. Name itself is an egrep pattern, so it can use | etc for variations.

autotest.client.base_utils.running_config()

Return path of config file of the currently running kernel

autotest.client.base_utils.running_os_full_version()

autotest.client.base_utils.running_os_ident()

autotest.client.base_utils.running_os_release()

autotest.client.base_utils.set_power_state(state)

Set the system power state to ‘state’.

autotest.client.base_utils.set_wake_alarm(alarm_time)

Set the hardware RTC-based wake alarm to ‘alarm_time’.

autotest.client.base_utils.standby()

Power-on suspend (S1)

autotest.client.base_utils.suspend_to_disk()

Suspend the system to disk (S4)

autotest.client.base_utils.suspend_to_ram()

Suspend the system to RAM (S3)

autotest.client.base_utils.sysctl(key, value=None)

Generic implementation of sysctl, to read and write.

Parameters:

• key – A location under /proc/sys
• value – If not None, a value to write into the sysctl.

Returns:

The single-line sysctl value as a string.

autotest.client.base_utils.sysctl_kernel(key, value=None)

(Very) partial implementation of sysctl, for kernel params

autotest.client.base_utils.to_seconds(time_string)

Converts a string in M+:SS.SS format to S+.SS

autotest.client.base_utils.unload_module(module_name)

Removes a module. Handles dependencies. If even then it’s not possible to remove one of the modules, it will trhow an error.CmdError exception.

Parameters:module_name – Name of the module we want to remove.

autotest.client.base_utils.unmap_url_cache(cachedir, url, expected_hash, method='md5')

Downloads a file from a URL to a cache directory. If the file is already at the expected position and has the expected hash, let’s not download it again.

Parameters:

• cachedir – Directory that might hold a copy of the file we want to download.
• url – URL for the file we want to download.
• expected_hash – Hash string that we expect the file downloaded to have.
• method – Method used to calculate the hash string (md5, sha1).

autotest.client.base_utils.where_art_thy_filehandles()

Dump the current list of filehandles

bkr_proxy Module

bkr_proxy - class used to talk to beaker

class autotest.client.bkr_proxy.BkrProxy(recipe_id, labc_url=None)

Bases: object

get_recipe()

recipe_abort()

recipe_stop()

recipe_upload_file(localfile, remotepath='')

result_upload_file(task_id, result_id, localfile, remotepath='')

task_abort(task_id)

task_result(task_id, result_type, result_path, result_score, result_summary)

task_start(task_id, kill_time=0)

task_stop(task_id)

task_upload_file(task_id, localfile, remotepath='')

update_watchdog(task_id, kill_time)

exception autotest.client.bkr_proxy.BkrProxyException(text)

Bases: exceptions.Exception

autotest.client.bkr_proxy.copy_data(data, dest, header=None, use_put=None)

Copy data to a destination

To aid in debugging, copy a file locally to verify the contents. Attempts to write the same data that would otherwise be sent remotely.

Parameters:

• data – data string to copy
• dest – destination path
• header – header info item to return
• use_put – dictionary of items for PUT method

Returns:

nothing or header info if requested

autotest.client.bkr_proxy.copy_local(data, dest, use_put=None)

Copy data locally to a file

To aid in debugging, copy a file locally to verify the contents. Attempts to write the same data that would otherwise be sent remotely.

Parameters:

• data – encoded data string to copy locally
• dest – local file path
• use_put – chooses to write in binary or text

Returns:

nothing

autotest.client.bkr_proxy.copy_remote(data, dest, use_put=None)

Copy data to a remote server using http calls POST or PUT

Using http POST and PUT methods, copy data over http. To use PUT method, provide a dictionary of values to be populated in the Content-Range and Content-Length headers. Otherwise default is to use POST method.

Traps on HTTPError 500 and 400

Parameters:

• data – encoded data string to copy remotely
• dest – remote server URL
• use_put – dictionary of items if using PUT method

Returns:

html header info for post processing

autotest.client.bkr_proxy.make_path_bkrcache(r)

Converts a recipe id into an internal path for cache’ing recipe

Parameters:r – recipe id Returns:a path to the internal recipe cache file

autotest.client.bkr_proxy.make_path_cmdlog(r)

Converts a recipe id into an internal path for logging purposes

Parameters:r – recipe id Returns:a path to the internal command log

autotest.client.bkr_proxy.make_path_log(r, t=None, i=None)

Converts id into a beaker path to log file

Given a recipe id, a task id, and/or result id, translate them into the proper beaker path to the log file. Depending on which log file is needed, provide the appropriate params. Note the dependency, a result id needs a task id and recipe id, while a task id needs a recipe id.

Parameters:

• r – recipe id
• t – task id
• i – result id

Returns:

a beaker path of the task’s result file

autotest.client.bkr_proxy.make_path_recipe(r)

Converts a recipe id into a beaker path

Parameters:r – recipe id Returns:a beaker path to the recipe id

autotest.client.bkr_proxy.make_path_result(r, t)

Converts task id into a beaker path to result file

Given a recipe id and a task id, translate them into the proper beaker path to the result file.

Parameters:

• r – recipe id
• t – task id

Returns:

a beaker path of the task’s result file

autotest.client.bkr_proxy.make_path_status(r, t=None)

Converts id into a beaker path to status file

Given a recipe id and/or a task id, translate them into the proper beaker path to the status file. Recipe only, returns the path to the recipe’s status, whereas including a task returns the path to the task’s status.

Parameters:

• r – recipe id
• t – task id

Returns:

a beaker path of the recipe’s/task’s status file

autotest.client.bkr_proxy.make_path_watchdog(r)

Converts a recipe id into a beaker path for the watchdog

Parameters:r – recipe id Returns:a beaker path of the recipe’s watchdog file

bkr_xml Module

module to parse beaker xml recipe

class autotest.client.bkr_xml.BeakerXMLParser

Bases: object

Handles parsing of beaker job xml

handle_recipe(recipe_node)

handle_recipes(recipe_nodes)

handle_task(recipe, task_node)

handle_task_param(task, param_node)

handle_task_params(task, param_nodes)

handle_tasks(recipe, task_nodes)

parse_from_file(file_name)

parse_xml(xml)

Returns dict, mapping hostname to recipe

class autotest.client.bkr_xml.Recipe

Bases: object

class autotest.client.bkr_xml.Task

Bases: object

Simple record to store task properties

get_param(key, default=None)

autotest.client.bkr_xml.xml_attr(node, key, default=None)

autotest.client.bkr_xml.xml_get_nodes(node, tag)

client_logging_config Module

class autotest.client.client_logging_config.ClientLoggingConfig(use_console=True)

Bases: autotest.client.shared.logging_config.LoggingConfig

add_debug_file_handlers(log_dir, log_name=None)

configure_logging(results_dir=None, verbose=False)

cmdparser Module

Autotest command parser

copyright:Don Zickus <dzickus@redhat.com> 2011

class autotest.client.cmdparser.CmdParserLoggingConfig(use_console=True)

Bases: autotest.client.shared.logging_config.LoggingConfig

Used with the sole purpose of providing convenient logging setup for the KVM test auxiliary programs.

configure_logging(results_dir=None, verbose=False)

class autotest.client.cmdparser.CommandParser

Bases: object

A client-side command wrapper for the autotest client.

COMMAND_LIST = ['help', 'list', 'run', 'fetch', 'bootstrap']

bootstrap(args, options)

Bootstrap autotest by fetching the control file first and pass it back

Currently this relies on a harness to retrieve the file

fetch(args, options)

fetch a remote control file or packages

classmethod help()

List the commands and their usage strings.

:param args is not used here.

classmethod list_tests()

List the available tests for users to choose from

parse_args(args, options)

Process a client side command.

Parameters:args – Command line args.

run(args, options)

Wrap args with a path and send it back to autotest.

common Module

config Module

The Job Configuration

The job configuration, holding configuration variable supplied to the job.

The config should be viewed as a hierarchical namespace. The elements of the hierarchy are separated by periods (.) and where multiple words are required at a level they should be separated by underscores (_). Please no StudlyCaps.

For example:

boot.default_args

class autotest.client.config.config(job)

Bases: object

The BASIC job configuration

Properties:

job

The job object for this job

config

The job configuration dictionary

get(name)

set(name, value)

cpuset Module

autotest.client.cpuset.abbrev_list(vals)

Condense unsigned (0,4,5,6,7,10) to ‘0,4-7,10’.

autotest.client.cpuset.all_drive_names()

autotest.client.cpuset.avail_mbytes(parent='')

autotest.client.cpuset.available_exclusive_mem_nodes(parent_container)

autotest.client.cpuset.container_bytes(name)

autotest.client.cpuset.container_exists(name)

autotest.client.cpuset.container_mbytes(name)

autotest.client.cpuset.cpus_path(container_name)

autotest.client.cpuset.cpuset_attr(container_name, attr)

autotest.client.cpuset.create_container_directly(name, mbytes, cpus)

autotest.client.cpuset.create_container_via_memcg(name, parent, bytes, cpus)

autotest.client.cpuset.create_container_with_mbytes_and_specific_cpus(name, mbytes, cpus=None, root='', io={}, move_in=True, timeout=0)

Create a cpuset container and move job’s current pid into it Allocate the list “cpus” of cpus to that container

name = arbitrary string tag mbytes = reqested memory for job in megabytes cpus = list of cpu indices to associate with the cpuset

defaults to all cpus avail with given root

root = the parent cpuset to nest this new set within

‘’: unnested top-level container

io = arguments for proportional IO containers move_in = True: Move current process into the new container now. timeout = must be 0: persist until explicitly deleted.

autotest.client.cpuset.create_container_with_specific_mems_cpus(name, mems, cpus)

autotest.client.cpuset.delete_leftover_test_containers()

autotest.client.cpuset.discover_container_style()

autotest.client.cpuset.full_path(container_name)

autotest.client.cpuset.get_boot_numa()

autotest.client.cpuset.get_cpus(container_name)

autotest.client.cpuset.get_mem_nodes(container_name)

autotest.client.cpuset.get_tasks(container_name)

autotest.client.cpuset.inner_containers_of(parent)

autotest.client.cpuset.io_attr(container_name, attr)

autotest.client.cpuset.mbytes_per_mem_node()

autotest.client.cpuset.memory_path(container_name)

autotest.client.cpuset.mems_path(container_name)

autotest.client.cpuset.move_self_into_container(name)

autotest.client.cpuset.move_tasks_into_container(name, tasks)

autotest.client.cpuset.my_available_exclusive_mem_nodes()

autotest.client.cpuset.my_container_name()

autotest.client.cpuset.my_lock(lockname)

autotest.client.cpuset.my_mem_nodes()

autotest.client.cpuset.my_unlock(lockfile)

autotest.client.cpuset.need_fake_numa()

autotest.client.cpuset.need_mem_containers()

autotest.client.cpuset.node_avail_kbytes(node)

autotest.client.cpuset.nodes_avail_mbytes(nodes)

autotest.client.cpuset.rangelist_to_set(rangelist)

autotest.client.cpuset.release_container(container_name=None)

autotest.client.cpuset.remove_empty_prio_classes(prios)

autotest.client.cpuset.set_io_controls(container_name, disks=[], ioprio_classes=[2], io_shares=[95], io_limits=[0])

autotest.client.cpuset.tasks_path(container_name)

autotest.client.cpuset.unpath(container_path)

fsdev_disks Module

autotest.client.fsdev_disks.finish_fsdev(force_cleanup=False)

This method can be called from the test file to optionally restore all the drives used by the test to a standard ext2 format. Note that if use_fsdev_lib() was invoked with ‘reinit_disks’ not set to True, this method does nothing. Note also that only fsdev “server-side” dynamic control files should ever set force_cleanup to True.

class autotest.client.fsdev_disks.fsdev_disks(job)

Disk drive handling class used for file system development

config_sched_tunables(desc_file)

get_fsdev_mgr()

load_sched_tunable_values(val_file)

set_sched_tunables(disks)

Given a list of disks in the format returned by get_disk_list() above, set the I/O scheduler values on all the disks to the values loaded earlier by load_sched_tunables().

set_tunable(disk, name, path, val)

Given a disk name, a path to a tunable value under _TUNE_PATH and the new value for the parameter, set the value and verify that the value has been successfully set.

autotest.client.fsdev_disks.get_disk_list(std_mounts_only=True, get_all_disks=False)

Get a list of dictionaries with information about disks on this system.

Parameters:

• std_mounts_only – Whether the function should return only disks that have a mount point defined (True) or even devices that doesn’t (False).
• get_all_disks – Whether the function should return only partitioned disks (False) or return every disk, regardless of being partitioned or not (True).

Returns:

List of dictionaries with disk information (see more below).

The ‘disk_list’ array returned by get_disk_list() has an entry for each disk drive we find on the box. Each of these entries is a map with the following 3 string values:

‘device’ disk device name (i.e. the part after /dev/) ‘mountpt’ disk mount path ‘tunable’ disk name for setting scheduler tunables (/sys/block/sd??)

The last value is an integer that indicates the current mount status of the drive:

‘mounted’ 0 = not currently mounted

1 = mounted r/w on the expected path

-1 = mounted readonly or at an unexpected path

When the ‘std_mounts_only’ argument is True we don’t include drives mounted on ‘unusual’ mount points in the result. If a given device is partitioned, it will return all partitions that exist on it. If it’s not, it will return the device itself (ie, if there are /dev/sdb1 and /dev/sdb2, those will be returned but not /dev/sdb. if there is only a /dev/sdc, that one will be returned).

autotest.client.fsdev_disks.match_fs(disk, dev_path, fs_type, fs_makeopt)

Matches the user provided fs_type and fs_makeopt with the current disk.

autotest.client.fsdev_disks.mkfs_all_disks(job, disk_list, fs_type, fs_makeopt, fs_mnt_opt)

Prepare all the drives in ‘disk_list’ for testing. For each disk this means unmounting any mount points that use the disk, running mkfs with ‘fs_type’ as the file system type and ‘fs_makeopt’ as the ‘mkfs’ options, and finally remounting the freshly formatted drive using the flags in ‘fs_mnt_opt’.

autotest.client.fsdev_disks.prepare_disks(job, fs_desc, disk1_only=False, disk_list=None)

Prepare drive(s) to contain the file system type / options given in the description line ‘fs_desc’. When ‘disk_list’ is not None, we prepare all the drives in that list; otherwise we pick the first available data drive (which is usually hdc3) and prepare just that one drive.

Args:

fs_desc: A partition.FsOptions instance describing the test -OR- a

legacy string describing the same in ‘/’ separated format:

‘fstype / mkfs opts / mount opts / short name’.

disk1_only: Boolean, defaults to False. If True, only test the first

disk.

disk_list: A list of disks to prepare. If None is given we default to

asking get_disk_list().

Returns:

(mount path of the first disk, short name of the test, list of disks) OR (None, ‘’, None) if no fs_desc was given.

autotest.client.fsdev_disks.prepare_fsdev(job)

Called from the test file to get the necessary drive(s) ready; return a pair of values: the absolute path to the first drive’s mount point plus the complete disk list (which is useful for tests that need to use more than one drive).

autotest.client.fsdev_disks.restore_disks(job, restore=False, disk_list=None)

Restore ext2 on the drives in ‘disk_list’ if ‘restore’ is True; when disk_list is None, we do nothing.

autotest.client.fsdev_disks.use_fsdev_lib(fs_desc, disk1_only, reinit_disks)

Called from the control file to indicate that fsdev is to be used.

autotest.client.fsdev_disks.wipe_disks(job, disk_list)

Wipe all of the drives in ‘disk_list’ using the ‘wipe’ functionality in the filesystem class.

fsdev_mgr Module

This module defines the BaseFsdevManager Class which provides an implementation of the ‘fsdev’ helper API; site specific extensions to any of these methods should inherit this class.

class autotest.client.fsdev_mgr.BaseFsdevManager

Bases: object

check_mount_point(part_name, mount_point)

Parameters:

• part_name – A partition name such as ‘sda3’ or similar.
• mount_point – A mount point such as ‘/usr/local’ or an empty string if no mount point is known.

Returns:

The expected mount point for part_name or a false value (None or ‘’) if the client should not mount this partition.

include_partition(part_name)

map_drive_name(part_name)

use_partition(part_name)

Parameters:part_name – A partition name such as ‘sda3’ or similar. Returns:bool, should we use this partition for testing?

class autotest.client.fsdev_mgr.FsdevManager

Bases: autotest.client.fsdev_mgr.BaseFsdevManager

autotest.client.fsdev_mgr.SiteFsdevManager

alias of BaseFsdevManager

fsinfo Module

This module gives the mkfs creation options for an existing filesystem.

tune2fs or xfs_growfs is called according to the filesystem. The results, filesystem tunables, are parsed and mapped to corresponding mkfs options.

autotest.client.fsinfo.compare_features(needed_feature, current_feature)

Compare two ext* feature lists.

autotest.client.fsinfo.convert_conf_opt(default_opt)

autotest.client.fsinfo.ext_mkfs_options(tune2fs_dict, mkfs_option)

Map the tune2fs options to mkfs options.

autotest.client.fsinfo.ext_tunables(dev)

Call tune2fs -l and parse the result.

autotest.client.fsinfo.match_ext_options(fs_type, dev, needed_options)

Compare the current ext* filesystem tunables with needed ones.

autotest.client.fsinfo.match_mkfs_option(fs_type, dev, needed_options)

Compare the current filesystem tunables with needed ones.

autotest.client.fsinfo.match_xfs_options(dev, needed_options)

Compare the current ext* filesystem tunables with needed ones.

autotest.client.fsinfo.merge_ext_features(conf_feature, user_feature)

autotest.client.fsinfo.opt_string2dict(opt_string)

Breaks the mkfs.ext* option string into dictionary.

autotest.client.fsinfo.parse_mke2fs_conf(fs_type, conf_file='/etc/mke2fs.conf')

Parses mke2fs config file for default settings.

autotest.client.fsinfo.xfs_mkfs_options(tune2fs_dict, mkfs_option)

Maps filesystem tunables to their corresponding mkfs options.

autotest.client.fsinfo.xfs_tunables(dev)

Call xfs_grow -n to get filesystem tunables.

harness Module

The harness interface

The interface between the client and the server when hosted.

class autotest.client.harness.harness(job)

Bases: object

The NULL server harness

Properties:

job

The job object for this job

run_abort()

A run within this job is aborting. It all went wrong

run_complete()

A run within this job is completing (all done)

run_pause()

A run within this job is completing (expect continue)

run_reboot()

A run within this job is performing a reboot (expect continue following reboot)

run_start()

A run within this job is starting

run_test_complete()

A test run by this job is complete. Note that if multiple tests are run in parallel, this will only be called when all of the parallel runs complete.

setup(job)

job

The job object for this job

test_status(status, tag)

A test within this job is completing

test_status_detail(code, subdir, operation, status, tag, optional_fields)

A test within this job is completing (detail)

autotest.client.harness.select(which, job, harness_args)

harness_ABAT Module

harness_autoserv Module

class autotest.client.harness_autoserv.AutoservFetcher(package_manager, job_harness)

Bases: autotest.client.shared.base_packages.RepositoryFetcher

fetch_pkg_file(filename, dest_path)

class autotest.client.harness_autoserv.harness_autoserv(job, harness_args)

Bases: autotest.client.harness.harness

The server harness for running from autoserv

Properties:

job

The job object for this job

fetch_package(pkg_name, dest_path)

Request a package from the remote autoserv.

Parameters:

• pkg_name – The name of the package, as generally used by the client.shared.packages infrastructure.
• dest_path – The path the package should be copied to.

run_start()

run_test_complete()

A test run by this job is complete, signal it to autoserv and wait for it to signal to continue

test_status(status, tag)

A test within this job is completing

harness_beaker Module

The harness interface The interface between the client and beaker lab controller.

exception autotest.client.harness_beaker.HarnessException(text)

Bases: exceptions.Exception

autotest.client.harness_beaker.get_beaker_code(at_code)

class autotest.client.harness_beaker.harness_beaker(job, harness_args)

Bases: autotest.client.harness.harness

bootstrap(fetchdir)

How to kickstart autotest when you have no control file? You download the beaker XML, convert it to a control file and pass it back to autotest. Much like bootstrapping.. :-)

convert_task_to_control(fetchdir, control, task)

Tasks are really just: # yum install $TEST # cd /mnt/tests/$TEST # make run

Convert that into a test module with a control file

find_recipe(recipes_dict)

get_processed_tests()

get_recipe_from_LC()

get_test_name(task)

init_recipe_from_beaker()

init_task_params(task)

kill_watchdog()

parse_args(args, is_bootstrap)

parse_quickcmd(args)

run_abort()

A run within this job is aborting. It all went wrong

run_complete()

A run within this job is completing (all done)

run_pause()

A run within this job is completing (expect continue)

run_reboot()

A run within this job is performing a reboot (expect continue following reboot)

run_start()

A run within this job is starting

run_test_complete()

A test run by this job is complete. Note that if multiple tests are run in parallel, this will only be called when all of the parallel runs complete.

setupInitSymlink()

start_watchdog(heartbeat)

tear_down()

called from complete and abort. clean up and shutdown

test_status(status, tag)

A test within this job is completing

test_status_detail(code, subdir, operation, status, tag, optional_fields)

A test within this job is completing (detail)

upload_recipe_files()

upload_result_files(task_id, resultid, subdir)

upload_task_files(task_id, subdir)

watchdog_loop(heartbeat)

write_processed_tests(subdir, t_id='0')

harness_simple Module

The simple harness interface

class autotest.client.harness_simple.harness_simple(job, harness_args)

Bases: autotest.client.harness.harness

The simple server harness

Properties:

job

The job object for this job

test_status(status, tag)

A test within this job is completing

harness_standalone Module

The standalone harness interface

The default interface as required for the standalone reboot helper.

class autotest.client.harness_standalone.harness_standalone(job, harness_args)

Bases: autotest.client.harness.harness

The standalone server harness

Properties:

job

The job object for this job

job Module

The main job wrapper

This is the core infrastructure.

Copyright Andy Whitcroft, Martin J. Bligh 2006

exception autotest.client.job.NotAvailableError

Bases: autotest.client.shared.error.AutotestError

exception autotest.client.job.StepError

Bases: autotest.client.shared.error.AutotestError

class autotest.client.job.base_client_job(control, options, drop_caches=True, extra_copy_cmdline=None)

Bases: autotest.client.shared.base_job.base_job

The client-side concrete implementation of base_job.

Optional properties provided by this implementation:

control bootloader harness

add_repository(repo_urls)

Adds the repository locations to the job so that packages can be fetched from them when needed. The repository list needs to be a string list Ex: job.add_repository([‘http://blah1’,’http://blah2‘])

add_sysinfo_command(command, logfile=None, on_every_test=False)

add_sysinfo_logfile(file, on_every_test=False)

barrier(*args, **kwds)

Create a barrier object

complete(status)

Write pending TAP reports, clean up, and exit

config_get(name)

config_set(name, value)

control_get()

control_set(control)

cpu_count()

disable_external_logging()

disable_warnings(warning_type)

enable_external_logging()

enable_warnings(warning_type)

end_reboot(subdir, kernel, patches, running_id=None)

end_reboot_and_verify(expected_when, expected_id, subdir, type='src', patches=[])

Check the passed kernel identifier against the command line and the running kernel, abort the job on missmatch.

filesystem(*args, **dargs)

Same as partition

@deprecated: Use partition method instead

handle_persistent_option(options, option_name)

Select option from command line or persistent state. Store selected option to allow standalone client to continue after reboot with previously selected options. Priority: 1. explicitly specified via command line 2. stored in state file (if continuing job ‘-c’) 3. default is None

harness_select(which, harness_args)

install_pkg(name, pkg_type, install_dir)

This method is a simple wrapper around the actual package installation method in the Packager class. This is used internally by the profilers, deps and tests code. name : name of the package (ex: sleeptest, dbench etc.) pkg_type : Type of the package (ex: test, dep etc.) install_dir : The directory in which the source is actually

untarred into. (ex: client/profilers/<name> for profilers)

kernel(base_tree, results_dir='', tmp_dir='', leave=False)

Summon a kernel object

monitor_disk_usage(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’.

Parameters:

max_rate - the maximium allowed rate of disk consumption

during a test, in MB/hour, or 0 to indicate no limit.

next_step(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

next_step_append(fn, *args, **dargs)

Define the next step and place it at the end

next_step_prepend(fn, *args, **dargs)

Insert a new step, executing first

noop(text)

parallel(*args, **dargs)

Run tasks in parallel

partition(device, loop_size=0, mountpoint=None)

Work with a machine partition

param device:e.g. /dev/sda2, /dev/sdb1 etc... param mountpoint:  Specify a directory to mount to. If not specified autotest tmp directory will be used. param loop_size:  Size of loopback device (in MB). Defaults to 0. return:A L{client.partition.partition} object

quit()

reboot(tag=<object object>)

reboot_setup()

relative_path(path)

Return a patch relative to the job results directory

require_gcc()

Test whether gcc is installed on the machine.

run_group(function, tag=None, **dargs)

Run a function nested within a group level.

function:

Callable to run.

tag:

An optional tag name for the group. If None (default) function.__name__ will be used.

**dargs:

Named arguments for the function.

run_test(*args, **dargs)

Summon a test object and run it.

:param url A url that identifies the test to run. :param tag An optional keyword argument that will be added to the

test and subdir name.

:param subdir_tag An optional keyword argument that will be added

to the subdir name.

Returns:True if the test passes, False otherwise.

run_test_detail(*args, **dargs)

Summon a test object and run it, returning test status.

:param url A url that identifies the test to run. :param tag An optional keyword argument that will be added to the

test and subdir name.

:param subdir_tag An optional keyword argument that will be added

to the subdir name.

Returns:Test status

@see: client/shared/error.py, exit_status

setup_dep(deps)

Set up the dependencies for this test. deps is a list of libraries required for this test.

setup_dirs(results_dir, tmp_dir)

start_reboot()

step_engine()

The multi-run engine used when the control file defines step_init.

Does the next step.

xen(base_tree, results_dir='', tmp_dir='', leave=False, kjob=None)

Summon a xen object

class autotest.client.job.disk_usage_monitor(logging_func, device, max_mb_per_hour)

start()

stop()

classmethod watch(*monitor_args, **monitor_dargs)

Generic decorator to wrap a function call with the standard create-monitor -> start -> call -> stop idiom.

class autotest.client.job.job(control, options, drop_caches=True, extra_copy_cmdline=None)

Bases: autotest.client.job.base_client_job

autotest.client.job.runjob(control, drop_caches, options)

Run a job using the given control file.

This is the main interface to this module.

@see base_job.__init__ for parameter info.

autotest.client.job.site_job

alias of base_client_job

class autotest.client.job.status_indenter(job)

Bases: autotest.client.shared.base_job.status_indenter

Provide a status indenter that is backed by job._record_prefix.

decrement()

increment()

indent

kernel Module

class autotest.client.kernel.BootableKernel(job)

Bases: object

add_to_bootloader(args='')

autotest.client.kernel.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.

class autotest.client.kernel.kernel(job, base_tree, subdir, tmp_dir, build_dir, leave=False)

Bases: autotest.client.kernel.BootableKernel

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

Properties:

job

Backpointer to the job object we’re part of

autodir

Path to the top level autotest dir (see global_config.ini, session COMMON/autotest_top_path)

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/

apply_patches(local_patches)

apply the list of patches, in order

autodir = ''

boot(args='', ident=True)

install and boot this kernel, do not care how just make it happen.

build(*args, **dargs)

build_timed(threads, timefile='/dev/null', make_opts='', output='/dev/null')

time the bulding of the kernel

clean(*args, **dargs)

config(*args, **dargs)

extract(*args, **dargs)

extraversion(tag, append=True)

get_kernel_build_arch(arch=None)

Work out the current kernel architecture (as a kernel arch)

get_kernel_build_ident()

get_kernel_build_release()

get_kernel_build_ver()

Check Makefile and .config to return kernel version

get_kernel_tree(base_tree)

Extract/link base_tree to self.build_dir

get_patches(patches)

fetch the patches to the local src_dir

install(*args, **dargs)

kernelexpand(kernel)

mkinitrd(*args, **dargs)

patch(*args, **dargs)

pickle_dump(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).

set_build_image(image)

set_build_target(build_target)

set_cross_cc(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.

autotest.client.kernel.preprocess_path(path)

class autotest.client.kernel.rpm_kernel(job, rpm_package, subdir)

Bases: autotest.client.kernel.BootableKernel

Class for installing a binary rpm kernel package

boot(args='', ident=True)

install and boot this kernel

build(*args, **dargs)

Dummy function, binary kernel so nothing to build.

install(*args, **dargs)

class autotest.client.kernel.rpm_kernel_suse(job, rpm_package, subdir)

Bases: autotest.client.kernel.rpm_kernel

Class for installing openSUSE/SLE rpm kernel package

add_to_bootloader(tag='dummy', args='')

Set parameters of this kernel in bootloader

install()

autotest.client.kernel.rpm_kernel_vendor(job, rpm_package, subdir)

autotest.client.kernel.tee_output_logdir_mark(fn)

kernel_config Module

autotest.client.kernel_config.apply_overrides(orig_file, changes_file, output_file)

autotest.client.kernel_config.config_by_name(name, s)

autotest.client.kernel_config.diff_configs(old, new)

autotest.client.kernel_config.feature_enabled(feature, config)

Verify whether a given kernel option is enabled.

Parameters:

• feature – Kernel feature, such as “CONFIG_DEFAULT_UIMAGE”.
• config – Config file path, such as /tmp/config.

class autotest.client.kernel_config.kernel_config(job, build_dir, config_dir, orig_file, overrides, defconfig=False, name=None, make=None)

Bases: object

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 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.

config_record(name)

Copy the current .config file to the config.<name>[.<n>]

update_config(old_config, new_config=None)

autotest.client.kernel_config.modules_needed(config)

kernel_versions Module

autotest.client.kernel_versions.is_release_candidate(version)

autotest.client.kernel_versions.is_released_kernel(version)

autotest.client.kernel_versions.version_choose_config(version, candidates)

autotest.client.kernel_versions.version_encode(version)

autotest.client.kernel_versions.version_len(version)

autotest.client.kernel_versions.version_limit(version, n)

kernelexpand Module

Program and API used to expand kernel versions, trying to match them with the URL of the correspondent package on kernel.org or a mirror. Example:

$ ./kernelexpand.py 3.1 http://www.kernel.org/pub/linux/kernel/v3.x/linux-3.1.tar.bz2

author:Andy Whitcroft (apw@shadowen.org) copyright:IBM 2008

@license: GPL v2 @see: Inspired by kernelexpand by Martin J. Bligh, 2003

autotest.client.kernelexpand.decompose_kernel(kernel)

autotest.client.kernelexpand.decompose_kernel_2x_once(kernel)

Generate the parameters for the patches (2.X version):

full => full kernel name base => all but the matches suffix minor => 2.n.m major => 2.n minor-prev => 2.n.m-1

Parameters:kernel – String representing a kernel version to be expanded.

autotest.client.kernelexpand.decompose_kernel_post_2x_once(kernel)

Generate the parameters for the patches (post 2.X version):

full => full kernel name base => all but the matches suffix minor => o.n.m major => o.n minor-prev => o.n.m-1

Parameters:kernel – String representing a kernel version to be expanded.

autotest.client.kernelexpand.expand_classic(kernel, mirrors)

autotest.client.kernelexpand.get_mappings_2x()

autotest.client.kernelexpand.get_mappings_post_2x()

autotest.client.kernelexpand.mirror_kernel_components(mirrors, components)

autotest.client.kernelexpand.select_kernel_components(components)

autotest.client.kernelexpand.url_accessible(url)

kvm_control Module

Utilities useful to client control files that test KVM.

autotest.client.kvm_control.get_kvm_arch()

Get the kvm kernel module to be loaded based on the CPU architecture

Raises:error.TestError if no vendor name or cpu flags are found Returns:‘kvm_amd’ or ‘kvm_intel’ or ‘kvm_power7’ Return type:string

autotest.client.kvm_control.load_kvm()

Loads the appropriate KVM kernel modules depending on the current CPU architecture

Returns:0 on success or 1 on failure Return type:int

autotest.client.kvm_control.unload_kvm()

Unloads the current KVM kernel modules ( if loaded )

Returns:0 on success or 1 on failure Return type:int

local_host Module

This file contains the implementation of a host object for the local machine.

class autotest.client.local_host.LocalHost(*args, **dargs)

Bases: autotest.client.shared.hosts.base_classes.Host

list_files_glob(path_glob)

Get a list of files on a remote host given a glob pattern path.

run(command, timeout=3600, ignore_status=False, stdout_tee=<object object>, stderr_tee=<object object>, stdin=None, args=())

@see shared.hosts.Host.run()

symlink_closure(paths)

Given a sequence of path strings, return the set of all paths that can be reached from the initial set by following symlinks.

Parameters:paths – sequence of path strings. Returns:a sequence of path strings that are all the unique paths that can be reached from the given ones after following symlinks.

wait_up(timeout=None)

lv_utils Module

Utility for taking shapshots from existing logical volumes or creates such.

author:Plamen Dimitrov copyright:Intra2net AG 2012

@license: GPL v2

param vg_name:Name of the volume group. param lv_name:Name of the logical volume. param lv_size:Size of the logical volume as string in the form “#G” (for example 30G). param lv_snapshot_name:  Name of the snapshot with origin the logical volume. param lv_snapshot_size:  Size of the snapshot with origin the logical volume also as “#G”. param ramdisk_vg_size:  Size of the ramdisk virtual group. param ramdisk_basedir:  Base directory for the ramdisk sparse file. param ramdisk_sparse_filename:  Name of the ramdisk sparse file.

Sample ramdisk params:

ramdisk_vg_size = “40000” ramdisk_basedir = “/tmp” ramdisk_sparse_filename = “virtual_hdd”

Sample general params:

vg_name=’autotest_vg’, lv_name=’autotest_lv’, lv_size=‘1G’, lv_snapshot_name=’autotest_sn’, lv_snapshot_size=‘1G’

The ramdisk volume group size is in MB.

autotest.client.lv_utils.lv_check(vg_name, lv_name)

Check whether provided logical volume exists.

autotest.client.lv_utils.vg_check(vg_name)

Check whether provided volume group exists.

autotest.client.lv_utils.vg_list()

List available volume groups.

autotest.client.lv_utils.vg_ramdisk_cleanup(ramdisk_filename, vg_ramdisk_dir, vg_name, loop_device)

Inline cleanup function in case of test error.

optparser Module

Autotest client/local option parser

class autotest.client.optparser.AutotestLocalOptionParser

Bases: optparse.OptionParser

Default autotest option parser

os_dep Module

autotest.client.os_dep.command(cmd)

autotest.client.os_dep.commands(*cmds)

autotest.client.os_dep.header(hdr)

autotest.client.os_dep.headers(*hdrs)

autotest.client.os_dep.libraries(*libs)

autotest.client.os_dep.library(lib)

parallel Module

Parallel execution management

autotest.client.parallel.fork_nuke_subprocess(tmp, pid)

autotest.client.parallel.fork_start(tmp, l)

autotest.client.parallel.fork_waitfor(tmp, pid)

autotest.client.parallel.fork_waitfor_timed(tmp, pid, timeout)

Waits for pid until it terminates or timeout expires. If timeout expires, test subprocess is killed.

partition Module

APIs to write tests and control files that handle partition creation, deletion and formatting.

copyright:Google 2006-2008 author:Martin Bligh (mbligh@google.com)

class autotest.client.partition.FsOptions(fstype, fs_tag, mkfs_flags=None, mount_options=None)

Bases: object

A class encapsulating a filesystem test’s parameters.

fs_tag

fstype

mkfs_flags

mount_options

autotest.client.partition.filesystems()

Return a list of all available filesystems

autotest.client.partition.filter_partition_list(partitions, devnames)

Pick and choose which partition to keep.

filter_partition_list accepts a list of partition objects and a list of strings. If a partition has the device name of the strings it is returned in a list.

Parameters:

• partitions – A list of L{partition} objects
• devnames – A list of devnames of the form ‘/dev/hdc3’ that specifies which partitions to include in the returned list.

Returns:

A list of L{partition} objects specified by devnames, in the order devnames specified

autotest.client.partition.get_iosched_path(device_name, component)

autotest.client.partition.get_mount_info(partition_list)

Picks up mount point information about the machine mounts. By default, we try to associate mount points with UUIDs, because in newer distros the partitions are uniquely identified using them.

autotest.client.partition.get_partition_list(job, min_blocks=0, filter_func=None, exclude_swap=True, open_func=<built-in function open>)

Get a list of partition objects for all disk partitions on the system.

Loopback devices and unnumbered (whole disk) devices are always excluded.

Parameters:

• job – The job instance to pass to the partition object constructor.
• min_blocks – The minimum number of blocks for a partition to be considered.
• filter_func – A callable that returns True if a partition is desired. It will be passed one parameter: The partition name (hdc3, etc.). Some useful filter functions are already defined in this module.
• exclude_swap – If True any partition actively in use as a swap device will be excluded.
• __open – Reserved for unit testing.

Returns:

A list of L{partition} objects.

autotest.client.partition.get_unmounted_partition_list(root_part, job=None, min_blocks=0, filter_func=None, exclude_swap=True, open_func=<built-in function open>)

Return a list of partition objects that are not mounted.

Parameters:

• root_part –

  The root device name (without the ‘/dev/’ prefix, example ‘hda2’) that will be filtered from the partition list.

  Reasoning: in Linux /proc/mounts will never directly mention the root partition as being mounted on / instead it will say that /dev/root is mounted on /. Thus require this argument to filter out the root_part from the ones checked to be mounted.

• min_blocks, filter_func, exclude_swap, open_func (job,) – Forwarded to get_partition_list().

Returns:

List of L{partition} objects that are not mounted.

autotest.client.partition.is_linux_fs_type(device)

Checks if specified partition is type 83

Parameters:device – the device, e.g. /dev/sda3 Returns:False if the supplied partition name is not type 83 linux, True otherwise

autotest.client.partition.is_valid_disk(device)

Checks if a disk is valid

Parameters:device – e.g. /dev/sda, /dev/hda

autotest.client.partition.is_valid_partition(device)

Checks if a partition is valid

Parameters:device – e.g. /dev/sda1, /dev/hda1

autotest.client.partition.list_mount_devices()

autotest.client.partition.list_mount_points()

autotest.client.partition.parallel(partitions, method_name, *args, **dargs)

Run a partition method (with appropriate arguments) in parallel, across a list of partition objects

class autotest.client.partition.partition(job, device, loop_size=0, mountpoint=None)

Bases: object

Class for handling partitions and filesystems

fsck(args='-fy', record=True)

Run filesystem check

Parameters:args – arguments to filesystem check tool. Default is “-n” which works on most tools.

get_fsck_exec()

Return the proper mkfs executable based on self.fstype

get_io_scheduler(device_name)

get_io_scheduler_list(device_name)

get_mountpoint(open_func=<built-in function open>, filename=None)

Find the mount point of this partition object.

Parameters:

• open_func – the function to use for opening the file containing the mounted partitions information
• filename – where to look for the mounted partitions information (default None which means it will search /proc/mounts and/or /etc/mtab)

Returns:

a string with the mount point of the partition or None if not mounted

mkfs(fstype=None, args='', record=True)

Format a partition to filesystem type

Parameters:

• fstype – the filesystem type, e.g.. “ext3”, “ext2”
• args – arguments to be passed to mkfs command.
• record – if set, output result of mkfs operation to autotest output

mkfs_exec(fstype)

Return the proper mkfs executable based on fs

mount(mountpoint=None, fstype=None, args='', record=True)

Mount this partition to a mount point

Parameters:

• mountpoint – If you have not provided a mountpoint to partition object or want to use a different one, you may specify it here.
• fstype – Filesystem type. If not provided partition object value will be used.
• args – Arguments to be passed to “mount” command.
• record – If True, output result of mount operation to autotest output.

run_test(test, **dargs)

run_test_on_partition(test, mountpoint_func, **dargs)

Executes a test fs-style (umount,mkfs,mount,test)

Here we unmarshal the args to set up tags before running the test. Tests are also run by first umounting, mkfsing and then mounting before executing the test.

Parameters:

• test – name of test to run
• mountpoint_func – function to return mount point string

set_fs_options(fs_options)

Set filesystem options

param fs_options:  A L{FsOptions} object

set_io_scheduler(device_name, name)

setup_before_test(mountpoint_func)

Prepare a partition for running a test. Unmounts any filesystem that’s currently mounted on the partition, makes a new filesystem (according to this partition’s filesystem options) and mounts it where directed by mountpoint_func.

Parameters:mountpoint_func – A callable that returns a path as a string, given a partition instance.

unmount(ignore_status=False, record=True)

Umount this partition.

It’s easier said than done to umount a partition. We need to lock the mtab file to make sure we don’t have any locking problems if we are umounting in paralllel.

If there turns out to be a problem with the simple umount we end up calling umount_force to get more aggressive.

Parameters:

• ignore_status – should we notice the umount status
• record – if True, output result of umount operation to autotest output

unmount_force()

Kill all other jobs accessing this partition. Use fuser and ps to find all mounts on this mountpoint and unmount them.

Returns:true for success or false for any errors

wipe()

Delete all files of a given partition filesystem.

autotest.client.partition.partname_to_device(part)

Converts a partition name to its associated device

autotest.client.partition.run_test_on_partitions(job, test, partitions, mountpoint_func, tag, fs_opt, do_fsck=True, **dargs)

Run a test that requires multiple partitions. Filesystems will be made on the partitions and mounted, then the test will run, then the filesystems will be unmounted and optionally fsck’d.

Parameters:

• job – A job instance to run the test
• test – A string containing the name of the test
• partitions – A list of partition objects, these are passed to the test as partitions=
• mountpoint_func – A callable that returns a mountpoint given a partition instance
• tag – A string tag to make this test unique (Required for control files that make multiple calls to this routine with the same value of ‘test’.)
• fs_opt – An FsOptions instance that describes what filesystem to make
• do_fsck – include fsck in post-test partition cleanup.
• dargs – Dictionary of arguments to be passed to job.run_test() and eventually the test

autotest.client.partition.unmount_partition(device)

Unmount a mounted partition

Parameters:device – e.g. /dev/sda1, /dev/hda1

class autotest.client.partition.virtual_partition(file_img, file_size)

Handles block device emulation using file images of disks. It’s important to note that this API can be used only if we have the following programs present on the client machine:

• sfdisk
• losetup
• kpartx

destroy()

Removes the virtual partition from /dev/mapper, detaches the image file from the loopback device and removes the image file.

autotest.client.partition.wipe_filesystem(job, mountpoint)

profiler Module

class autotest.client.profiler.profiler(job)

initialize(*args, **dargs)

preserve_srcdir = False

report(test)

setup(*args, **dargs)

start(test)

stop(test)

supports_reboot = False

setup Module

autotest.client.setup.get_data_files()

autotest.client.setup.get_filelist()

autotest.client.setup.get_package_data()

autotest.client.setup.get_package_dir()

autotest.client.setup.get_packages()

autotest.client.setup.get_scripts()

autotest.client.setup.run()

setup_job Module

autotest.client.setup_job.init_test(options, testdir)

Instantiate a client test object from a given test directory.

:param options Command line options passed in to instantiate a setup_job

which associates with this test.

:param testdir The test directory. :return: A test object or None if failed to instantiate.

autotest.client.setup_job.load_all_client_tests(options)

Load and instantiate all client tests.

This function is inspired from runtest() on client/shared/test.py.

Parameters:options – an object passed in from command line OptionParser. See all options defined on client/autotest. Returns:a tuple containing the list of all instantiated tests and a list of tests that failed to instantiate.

class autotest.client.setup_job.setup_job(options)

Bases: autotest.client.job.job

setup_job is a job which runs client test setup() method at server side.

This job is used to pre-setup client tests when development toolchain is not available at client.

autotest.client.setup_job.setup_test(client_test)

Direct invoke test.setup() method.

Returns:A boolean to represent success or not.

autotest.client.setup_job.setup_tests(options)

Load and instantiate all client tests.

This function is inspired from runtest() on client/shared/test.py.

Parameters:options – an object passed in from command line OptionParser. See all options defined on client/autotest.

setup_modules Module

Module used to create the autotest namespace for single dir use case.

Autotest programs can be used and developed without requiring it to be installed system-wide. In order for the code to see the library namespace:

from autotest.client.shared import error from autotest.server import hosts ...

Without system wide install, we need some hacks, that are performed here.

author:John Admanski (jadmanski@google.com)

autotest.client.setup_modules.import_module(module, from_where)

Equivalent to ‘from from_where import module’.

Parameters:

• module – Module name.
• from_where – Package from where the module is being imported.

Returns:

The corresponding module.

autotest.client.setup_modules.setup(base_path, root_module_name='autotest')

Setup a library namespace, with the appropriate top root module name.

Perform all the necessary setup so that all the packages at ‘base_path’ can be imported via “import root_module_name.package”.

Parameters:

• base_path – Base path for the module.
• root_module_name – Top level name for the module.

sysinfo Module

test Module

autotest.client.test.runtest(job, url, tag, args, dargs)

class autotest.client.test.test(job, bindir, outputdir)

Bases: autotest.client.shared.test.base_test

configure_crash_handler()

Configure the crash handler by:

• Setting up core size to unlimited
• Putting an appropriate crash handler on /proc/sys/kernel/core_pattern
• Create files that the crash handler will use to figure which tests are active at a given moment

The crash handler will pick up the core file and write it to self.debugdir, and perform analysis on it to generate a report. The program also outputs some results to syslog.

If multiple tests are running, an attempt to verify if we still have the old PID on the system process table to determine whether it is a parent of the current test execution. If we can’t determine it, the core file and the report file will be copied to all test debug dirs.

crash_handler_report()

If core dumps are found on the debugdir after the execution of the test, let the user know.

test_config Module

Wrapper around ConfigParser to manage testcases configuration.

author:rsalveti@linux.vnet.ibm.com (Ricardo Salveti de Araujo)

class autotest.client.test_config.config_loader(cfg, tmpdir='/tmp', raise_errors=False)

Base class of the configuration parser

check(section)

Check if the config file has valid values

check_parameter(param_type, parameter)

Check if a option has a valid value

get(section, option, 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.

Parameters:

• section – Configuration file section.
• option – Option we’re looking after.

@default: In case the option is not available and raise_errors is set

to False, return the default.

remove(section, option)

Remove an option.

save()

Save the configuration file with all modifications

set(section, option, value)

Set an option.

This change is not persistent unless saved with ‘save()’.

utils Module

Convenience functions for use by tests or whomever.

NOTE: this is a mixin library that pulls in functions from several places Note carefully what the precendece order is

There’s no really good way to do this, as this isn’t a class we can do inheritance with, just a collection of static methods.

xen Module

class autotest.client.xen.xen(job, base_tree, results_dir, tmp_dir, build_dir, leave=False, kjob=None)

Bases: autotest.client.kernel.kernel

add_to_bootloader(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’)

build(make_opts='', logfile='', extraversion='autotest')

build xen

make_opts

additional options to make, if any

build_timed(*args, **kwds)

config(config_file, config_list=None)

fix_up_xen_kernel_makefile(kernel_dir)

Fix up broken EXTRAVERSION in xen-ified Linux kernel Makefile

get_xen_build_ver()

Check Makefile and .config to return kernel version

get_xen_kernel_build_ver()

Check xen buildconfig for current kernel version

install(tag='', prefix='/', extraversion='autotest')

make install in the kernel tree

log(msg)

Subpackages

• net Package
  • basic_machine Module
  • common Module
  • net_tc Module
  • net_utils Module
  • net_utils_mock Module
• profilers Package
  • profilers Package
  • Subpackages
    • blktrace Package
      • blktrace Module
    • catprofile Package
      • catprofile Module
    • cmdprofile Package
      • cmdprofile Module
    • cpistat Package
      • cpistat Module
    • ftrace Package
      • ftrace Module
    • inotify Package
      • inotify Module
    • iostat Package
      • iostat Module
    • kvm_stat Package
      • kvm_stat Module
    • lockmeter Package
      • lockmeter Module
    • lttng Package
      • lttng Module
    • mpstat Package
      • mpstat Module
    • oprofile Package
      • oprofile Module
    • perf Package
      • perf Module
    • powertop Package
      • powertop Module
    • readprofile Package
      • readprofile Module
    • sar Package
      • sar Module
    • systemtap Package
      • systemtap Module
    • vmstat Package
      • vmstat Module
• shared Package
  • autotemp Module
  • barrier Module
  • base_barrier Module
  • base_check_version Module
  • base_job Module
  • base_packages Module
  • base_syncdata Module
  • boottool Module
  • check_version Module
  • common Module
  • control_data Module
  • distro Module
  • distro_def Module
  • enum Module
  • error Module
  • git Module
  • host_protections Module
  • host_queue_entry_states Module
  • iscsi Module
  • iso9660 Module
  • jsontemplate Module
  • kernel_versions Module
  • log Module
  • logging_config Module
  • logging_manager Module
  • magic Module
  • mail Module
  • mock Module
  • openvswitch Module
  • packages Module
  • pexpect Module
  • pidfile Module
  • profiler_manager Module
  • progressbar Module
  • pxssh Module
  • report Module
  • service Module
  • settings Module
  • software_manager Module
  • ssh_key Module
  • syncdata Module
  • test Module
  • utils Module
  • utils_cgroup Module
  • utils_koji Module
  • utils_memory Module
  • version Module
  • Subpackages
    • backports Package
      • backports Package
      • Subpackages
        • collections Package
          • collections Package
          • OrderedDict Module
          • defaultdict Module
          • namedtuple Module
        • simplejson Package
          • simplejson Package
          • decoder Module
          • encoder Module
          • ordered_dict Module
          • scanner Module
          • tool Module
    • hosts Package
      • hosts Package
      • base_classes Module
      • common Module
    • test_utils Package
      • config_change_validation Module
      • functools_24 Module
      • mock Module
      • mock_demo Module
      • mock_demo_MUT Module
      • unittest Module
• tools Package
  • JUnit_api Module
  • boottool Module
  • cd_hash Module
  • common Module
  • crash_handler Module
  • process_metrics Module
  • regression Module
  • results2junit Module
  • scan_results Module
  • virt_disk Module