pyanaconda package¶

Subpackages¶

Submodules¶

pyanaconda.addons module¶

class pyanaconda.addons.AddonSection(*args, **kwargs)¶

Bases: pykickstart.sections.Section

finalize()¶

Let addon know no additional data will come.

handleHeader(lineno, args)¶

Process the arguments to the %addon header.

handleLine(line)¶

sectionOpen = '%addon'¶

class pyanaconda.addons.AddonRegistry(dictionary)¶

Bases: object

This class represents the ksdata.addons object and maintains the ids and data structures for loaded addons.

It acts as a proxy during kickstart save.

execute(storage, ksdata, instClass, users, payload)¶

This method calls execute on all the registered addons.

setup(storage, ksdata, instClass, payload)¶

This method calls setup on all the registered addons.

class pyanaconda.addons.AddonData(name)¶

Bases: object

This is a common parent class for loading and storing 3rd party data to kickstart. It is instantiated by kickstart parser and stored as ksdata.addons.<name> to be used in the user interfaces.

The mandatory method handle_line receives all lines from the corresponding addon section in kickstart and the mandatory __str__ implementation is responsible for returning the proper kickstart text (to be placed into the %addon section) back.

There is also a mandatory method execute, which should make all the described changes to the installed system.

execute(storage, ksdata, instClass, users, payload)¶

Make the changes to the underlying system.

This method is called only once in the post-install setup phase.

finalize()¶

No additional data will come.

Addon should check if all mandatory attributes were populated.

handle_header(lineno, args)¶

Process additional arguments to the %addon line.

This function receives any arguments on the %addon line after the addon ID. For example, for the line:

%addon com_example_foo –argument=’example’

This function would be called with args=[“–argument=’example’”].

By default AddonData.handle_header just preserves the passed arguments by storing them and adding them to the __str__ output.

handle_line(line)¶

Process one kickstart line.

setup(storage, ksdata, instClass, payload)¶

Make the changes to the install system.

This method is called before the installation is started and directly from spokes. It must be possible to call it multiple times without breaking the environment.

pyanaconda.addons.collect_addon_paths(toplevel_addon_paths, ui_subdir='gui')¶

This method looks into the directories present in toplevel_addon_paths and registers each subdirectory as a new addon identified by that subdirectory name.

It then registers spokes, categories and data (ks) paths for the application to use. By default is looks for spokes and categories in <addon>/gui/ subdirectory but that can be changed using the ui_subdir argument.

pyanaconda.anaconda module¶

class pyanaconda.anaconda.Anaconda¶

Bases: object

bootloader¶

dumpState()¶

initInterface(addon_paths=None)¶

instClass¶

intf¶

payload¶

protected¶

storage¶

writeXdriver(root=None)¶

pyanaconda.anaconda_argparse module¶

class pyanaconda.anaconda_argparse.AnacondaArgumentParser(*args, **kwargs)¶

Bases: argparse.ArgumentParser

Subclass of ArgumentParser that also examines boot arguments.

If the “bootarg_prefix” keyword argument is set, it’s assumed that all bootargs will start with that prefix.

“require_prefix” is a bool:

False: accept the argument with or without the prefix. True: ignore the argument without the prefix. (default)

add_argument(*args, **kwargs)¶

Add a new option - like ArgumentParser.add_argument.

The long options will be added to the list of boot args, unless the keyword argument ‘bootarg’ is set to False.

Positional arguments that don’t start with ‘-‘ are considered extra boot args to look for.

NOTE: conflict_handler is currently ignored for boot args - they will always raise ArgumentError if they conflict.

parse_args(args=None, boot_cmdline=None)¶

Like ArgumentParser.parse_args(), but also parses the boot cmdline. (see parse_boot_cmdline for details on that process.) Program cmdline arguments will override boot cmdline arguments.

Parameters:	args (string or None) – program command line arguments boot_cmdline (string, dict or None) – the Anaconda boot command line arguments
Returns:	an argparse Namespace instance
Return type:	Namespace

parse_boot_cmdline(boot_cmdline)¶

Parse the boot cmdline and create an appropriate Namespace instance according to the option definitions set by add_argument.

boot_cmdline can be given as a string (to be parsed by BootArgs), or a dict (or any object with .items()) of {bootarg:value} pairs.

If boot_cmdline is None, the boot_cmdline data will be whatever BootArgs reads by default (/proc/cmdline, /run/initramfs/etc/cmdline, /etc/cmdline).

If an option requires a value but the boot arg doesn’t provide one, we’ll quietly not set anything in the Namespace. We also skip any boot options that were not specified by add_argument as we don’t care about them (there will usually be quite a lot of them (rd.*, etc.).

Parameters:	boot_cmdline (string, dict or None) – the Anaconda boot command line arguments
Returns:	an argparse Namespace instance
Return type:	Namespace

class pyanaconda.anaconda_argparse.HelpTextParser(path)¶

Bases: object

Class to parse help text from file and make it available to option parser.

Initializer :param path: The absolute path to the help text file

help_text(option)¶

Returns the help text corresponding to the given command-line option. If no help text is available, returns the empty string.

Parameters:	option (str) – The name of the option
Return type:	str

read(lines)¶

Reads option, help text pairs from a text file.

Each pair is separated from the next by an empty line. The option comes first, followed by any number of lines of help text.

Parameters:	lines – a sequence of lines of text

pyanaconda.anaconda_argparse.getArgumentParser(version_string, boot_cmdline=None)¶

Return the anaconda argument parser.

Parameters:	version_string (str) – The version string, e.g. 23.19.5. pyanaconda.flags.BootArgs – The boot command line options
Return type:	AnacondaArgumentParser

pyanaconda.anaconda_argparse.get_help_width()¶

Try to detect the terminal window width size and use it to compute optimal help text width. If it can’t be detected a default values is returned.

Returns:	optimal help text width in number of characters
Return type:	int

pyanaconda.anaconda_argparse.name_path_pairs(image_specs)¶

Processes and verifies image file specifications. Generates pairs of names and paths.

Parameters:	image_specs (list of str) – a list of image specifications

Each image spec in image_specs has format <path>[:<name>] where <path> is the path to a local file and <name> is an optional name used to identify the disk in UI. <name> may not contain colons or slashes.

If no name given in specification, synthesizes name from basename of path. Since two distinct paths may have the same basename, handles name collisions by synthesizing a different name for the colliding name.

Raises an exception if:

• A path is empty
• A path specifies a non-existant file
• A path specifies a directory
• Duplicate paths are specified
• A name contains a “/”

pyanaconda.anaconda_log module¶

class pyanaconda.anaconda_log.AnacondaFileHandler(filename, mode='a', encoding=None, delay=False)¶

Bases: pyanaconda.anaconda_log._AnacondaLogFixer, logging.FileHandler

Open the specified file and use it as the stream for logging.

class pyanaconda.anaconda_log.AnacondaLog¶

Bases: object

SYSLOG_CFGFILE = '/etc/rsyslog.conf'¶

VIRTIO_PORT = '/dev/virtio-ports/org.fedoraproject.anaconda.log.0'¶

addFileHandler(dest, addToLogger, minLevel=20, fmtStr='%(asctime)s, %(msecs)03d %(levelname)s %(name)s: %(message)s', autoLevel=False)¶

forwardToSyslog(logr)¶

Forward everything that goes in the logger to the syslog daemon.

restartSyslog()¶

setupVirtio()¶

Setup virtio rsyslog logging.

setup_remotelog(host, port)¶

showwarning(message, category, filename, lineno, file=<_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>, line=None)¶

Make sure messages sent through python’s warnings module get logged.

The warnings mechanism is used by some libraries we use, notably pykickstart.

updateRemote(remote_syslog)¶

Updates the location of remote rsyslogd to forward to.

Requires updating rsyslogd config and restarting rsyslog

class pyanaconda.anaconda_log.AnacondaSocketHandler(host, port)¶

Bases: pyanaconda.anaconda_log._AnacondaLogFixer, logging.handlers.SocketHandler

Initializes the handler with a specific host address and port.

When the attribute closeOnError is set to True - if a socket error occurs, the socket is silently closed and then reopened on the next logging call.

makePickle(record)¶

class pyanaconda.anaconda_log.AnacondaStreamHandler(stream=None)¶

Bases: pyanaconda.anaconda_log._AnacondaLogFixer, logging.StreamHandler

Initialize the handler.

If stream is not specified, sys.stderr is used.

class pyanaconda.anaconda_log.AnacondaSyslogHandler(address=('localhost', 514), facility=1, tag='')¶

Bases: pyanaconda.anaconda_log._AnacondaLogFixer, logging.handlers.SysLogHandler

emit(record)¶

levelMap = {'ERR': 'error', 'CRIT': 'critical'}¶

mapPriority(level)¶

Map the priority level to a syslog level

pyanaconda.anaconda_log.autoSetLevel(handler, value)¶

pyanaconda.anaconda_log.init()¶

pyanaconda.anaconda_log.setHandlersLevel(logr, level)¶

pyanaconda.bootloader module¶

class pyanaconda.bootloader.Aarch64EFIGRUB¶

Bases: pyanaconda.bootloader.EFIGRUB

class pyanaconda.bootloader.Arguments(iterable=None)¶

Bases: ordered_set.OrderedSet

add(key)¶

update(other)¶

class pyanaconda.bootloader.BootLoader¶

Bases: object

add_image(image)¶

Add a BootLoaderImage instance to the image list.

boot_prefix¶

Prefix, if any, to paths in /boot.

can_dual_boot = False¶

can_update = False¶

check()¶

Run additional bootloader checks

clear_images()¶

Empty out the image list.

config_file = None¶

config_file_mode = 384¶

default¶

The default image.

device_description(device)¶

device_descriptions¶

disk_order¶

Potentially partial order for disks.

disklabel_types¶

encryption_support = False¶

global_preserve_args = ['speakup_synth', 'apic', 'noapic', 'apm', 'ide', 'noht', 'acpi', 'video', 'pci', 'nodmraid', 'nompath', 'nomodeset', 'noiswmd', 'fips', 'selinux', 'biosdevname', 'ipv6.disable', 'net.ifnames']¶

has_windows(devices)¶

image_label(image)¶

Return the appropriate image label for this bootloader.

image_label_attr = 'label'¶

images¶

List of OS images that will be included in the configuration.

install(args=None)¶

is_valid_stage1_device(device, early=False)¶

Return True if the device is a valid stage1 target device.

Also collect lists of errors and warnings.

The criteria for being a valid stage1 target device vary from platform to platform. On some platforms a disk with an msdos disklabel is a valid stage1 target, while some platforms require a special device. Some examples of these special devices are EFI system partitions on EFI machines, PReP boot partitions on iSeries, and Apple bootstrap partitions on Mac.

The ‘early’ keyword argument is a boolean flag indicating whether or not this check is being performed at a point where the mountpoint cannot be expected to be set for things like EFI system partitions.

is_valid_stage2_device(device, linux=True, non_linux=False)¶

Return True if the device is suitable as a stage2 target device.

Also collect lists of errors and warnings.

name = 'Generic Bootloader'¶

packages = []¶

preserve_args = []¶

reset()¶

Reset stage1 and stage2 values

set_boot_args(*args, **kwargs)¶

Set up the boot command line.

Keyword Arguments:

storage - a blivet.Storage instance

All other arguments are expected to have a dracutSetupArgs() method.

set_disk_list(disks)¶

set_preferred_stage1_type(preferred)¶

Set a preferred type of stage1 device.

set_stage1_device(devices)¶

stage2_bootable = False¶

stage2_description = '/boot file system'¶

stage2_device = None¶

stage2_device_types = []¶

stage2_format_types¶

stage2_is_valid_stage1 = False¶

stage2_max_end = Size (2 TiB)¶

stage2_mountpoints = ['/boot', '/']¶

stage2_must_be_primary = True¶

stage2_raid_levels = []¶

stage2_raid_member_types = []¶

stage2_raid_metadata = []¶

timeout¶

Bootloader timeout in seconds.

trusted_boot¶

update()¶

Update an existing bootloader configuration.

update_only¶

write()¶

Write the bootloader configuration and install the bootloader.

write_config()¶

Write the bootloader configuration.

write_config_console(config)¶

Write console-related configuration lines.

write_config_header(config)¶

Write global configuration lines.

write_config_images(config)¶

Write image configuration entries.

write_config_password(config)¶

Write password-related configuration lines.

write_config_post()¶

exception pyanaconda.bootloader.BootLoaderError¶

Bases: Exception

class pyanaconda.bootloader.BootLoaderImage(device=None, label=None, short=None)¶

Bases: object

Base class for bootloader images. Suitable for non-linux OS images.

class pyanaconda.bootloader.EFIBase¶

Bases: object

add_efi_boot_target()¶

check()¶

efi_dir_as_efifs_dir¶

efibootmgr(*args, **kwargs)¶

install(args=None)¶

remove_efi_boot_target()¶

update()¶

write()¶

Write the bootloader configuration and install the bootloader.

class pyanaconda.bootloader.EFIGRUB¶

Bases: pyanaconda.bootloader.EFIBase, pyanaconda.bootloader.GRUB2

can_dual_boot = False¶

packages = ['grub2-efi', 'efibootmgr', 'shim']¶

stage2_bootable = False¶

stage2_is_valid_stage1 = False¶

class pyanaconda.bootloader.EFIGRUB1¶

Bases: pyanaconda.bootloader.EFIBase, pyanaconda.bootloader.GRUB

can_dual_boot = False¶

efi_product_path¶

The EFI product path.

eg: HD(1,800,64000,faacb4ef-e361-455e-bd97-ca33632550c3)

grub_conf_device_line¶

packages = ['efibootmgr']¶

stage2_bootable = False¶

stage2_device_types = ['partition']¶

stage2_is_valid_stage1 = False¶

stage2_max_end_mb = None¶

stage2_raid_levels = []¶

stage2_raid_member_types = []¶

stage2_raid_metadata = []¶

class pyanaconda.bootloader.EXTLINUX¶

Bases: pyanaconda.bootloader.BootLoader

boot_prefix¶

Prefix, if any, to paths in /boot.

config_file¶

install(args=None)¶

name = 'EXTLINUX'¶

packages = ['syslinux-extlinux']¶

stage1_device_types = ['disk']¶

stage2_bootable = True¶

stage2_device_types = ['partition']¶

stage2_format_types = ['ext4', 'ext3', 'ext2']¶

write_config()¶

write_config_console(config)¶

write_config_header(config)¶

write_config_images(config)¶

write_config_password(config)¶

write_config_post()¶

class pyanaconda.bootloader.GRUB¶

Bases: pyanaconda.bootloader.BootLoader

can_dual_boot = True¶

can_update = True¶

config_dir¶

Full path to configuration directory.

config_file¶

Full path to configuration file.

device_map_file¶

Full path to device.map file.

grub_conf_device_line¶

grub_config_dir¶

Config dir, adjusted for grub’s view of the world.

grub_device_name(device)¶

Return a grub-friendly representation of device.

has_serial_console¶

true if the console is a serial console.

has_windows(devices)¶

Potential boot devices containing non-linux operating systems.

install(args=None)¶

install_targets¶

List of (stage1, stage2) tuples representing install targets.

is_valid_stage2_device(device, linux=True, non_linux=False)¶

name = 'GRUB'¶

packages = ['grub']¶

serial_command¶

splash_dir¶

relative path to splash image directory.

stage2_bootable = True¶

stage2_device_types = ['partition', 'mdarray']¶

stage2_is_valid_stage1 = True¶

stage2_must_be_primary = False¶

stage2_raid_levels = [<blivet.devicelibs.raid.RAID1 object at 0x7fd4f59de668>]¶

stage2_raid_member_types = ['partition']¶

stage2_raid_metadata = ['0', '0.90', '1.0']¶

update()¶

write_config()¶

Write bootloader configuration to disk.

write_config_console(config)¶

Write console-related configuration.

write_config_header(config)¶

Write global configuration information.

write_config_images(config)¶

Write image entries into configuration file.

write_config_password(config)¶

Write password-related configuration.

write_config_post()¶

Perform additional configuration after writing config file(s).

write_device_map()¶

Write out a device map containing all supported devices.

class pyanaconda.bootloader.GRUB2¶

Bases: pyanaconda.bootloader.GRUB

GRUBv2

• configuration

  • password (insecure), password_pbkdf2

    • http://www.gnu.org/software/grub/manual/grub.html#Invoking-grub_002dmkpasswd_002dpbkdf2

  • –users per-entry specifies which users can access, otherwise entry is unrestricted

  • /etc/grub/custom.cfg

• how does grub resolve names of md arrays?

• disable automatic use of grub-mkconfig?

  • on upgrades?

• BIOS boot partition (GPT)

  • parted /dev/sda set <partition_number> bios_grub on
  • can’t contain a file system
  • 31KiB min, 1MiB recommended

check()¶

When installing to the mbr of a disk grub2 needs enough space before the first partition in order to embed its core.img

Until we have a way to ask grub2 what the size is we check to make sure it starts >= 512K, otherwise return an error.

defaults_file = '/etc/default/grub'¶

grub_device_name(device)¶

Return a grub-friendly representation of device.

Disks and partitions use the (hdX,Y) notation, while lvm and md devices just use their names.

install(args=None)¶

name = 'GRUB2'¶

packages = ['grub2']¶

stage2_device_types = ['partition', 'mdarray', 'lvmlv']¶

stage2_format_types¶

stage2_max_end = None¶

stage2_raid_levels = [<blivet.devicelibs.raid.RAID0 object at 0x7fd4f59ffda0>, <blivet.devicelibs.raid.RAID1 object at 0x7fd4f59de668>, <blivet.devicelibs.raid.RAID4 object at 0x7fd4f5a08940>, <blivet.devicelibs.raid.RAID5 object at 0x7fd4f5a08a58>, <blivet.devicelibs.raid.RAID6 object at 0x7fd4f5a5e908>, <blivet.devicelibs.raid.RAID10 object at 0x7fd4f5a5eba8>]¶

stage2_raid_metadata = ['0', '0.90', '1.0', '1.2']¶

terminal_type = 'console'¶

write()¶

Write the bootloader configuration and install the bootloader.

write_config()¶

write_config_console(config)¶

write_defaults()¶

write_device_map()¶

Write out a device map containing all supported devices.

write_password_config()¶

class pyanaconda.bootloader.IPSeriesGRUB2¶

Bases: pyanaconda.bootloader.GRUB2

install(args=None)¶

stage2_bootable = False¶

terminal_type = 'ofconsole'¶

updateNVRAMBootList()¶

write_defaults()¶

class pyanaconda.bootloader.IPSeriesYaboot¶

Bases: pyanaconda.bootloader.Yaboot

install(args=None)¶

prog = 'mkofboot'¶

updatePowerPCBootList()¶

write_config_variant_header(config)¶

class pyanaconda.bootloader.LinuxBootLoaderImage(device=None, label=None, short=None, version=None)¶

Bases: pyanaconda.bootloader.BootLoaderImage

initrd¶

kernel¶

class pyanaconda.bootloader.MacEFIGRUB¶

Bases: pyanaconda.bootloader.EFIGRUB

install(args=None)¶

is_valid_stage1_device(device, early=False)¶

mactel_config()¶

class pyanaconda.bootloader.MacYaboot¶

Bases: pyanaconda.bootloader.Yaboot

can_dual_boot = True¶

prog = 'mkofboot'¶

write_config_variant_header(config)¶

class pyanaconda.bootloader.TbootLinuxBootLoaderImage(device=None, label=None, short=None, version=None)¶

Bases: pyanaconda.bootloader.LinuxBootLoaderImage

args¶

mbargs¶

multiboot¶

class pyanaconda.bootloader.Yaboot¶

Bases: pyanaconda.bootloader.YabootBase

config_dir¶

config_file¶

image_label_attr = 'short_label'¶

install(args=None)¶

name = 'Yaboot'¶

packages = ['yaboot']¶

prog = 'ybin'¶

stage2_device_raid_levels = [<blivet.devicelibs.raid.RAID1 object at 0x7fd4f59de668>]¶

stage2_device_types = ['partition', 'mdarray']¶

write_config()¶

write_config_header(config)¶

write_config_post()¶

write_config_variant_header(config)¶

class pyanaconda.bootloader.YabootBase¶

Bases: pyanaconda.bootloader.BootLoader

write_config_images(config)¶

write_config_password(config)¶

class pyanaconda.bootloader.ZIPL¶

Bases: pyanaconda.bootloader.BootLoader

boot_dir¶

config_file = '/etc/zipl.conf'¶

image_label_attr = 'short_label'¶

install(args=None)¶

name = 'ZIPL'¶

packages = ['s390utils-base']¶

preserve_args = ['cio_ignore', 'rd.znet', 'rd_ZNET']¶

stage2_device_types = ['partition']¶

stage2_format_types¶

write_config_header(config)¶

write_config_images(config)¶

pyanaconda.bootloader.get_bootloader()¶

pyanaconda.bootloader.parse_serial_opt(arg)¶

Parse and split serial console options.

Note

Documentation/kernel-parameters.txt says:

ttyS<n>[,options]

Use the specified serial port. The options are of the form “bbbbpnf”, where “bbbb” is the baud rate, “p” is parity (“n”, “o”, or “e”), “n” is number of bits, and “f” is flow control (“r” for RTS or omit it). Default is “9600n8”.

but note that everything after the baud rate is optional, so these are all valid: 9600, 19200n, 38400n8, 9600e7r. Also note that the kernel assumes 1 stop bit; this can’t be changed.

class pyanaconda.bootloader.serial_opts¶

Bases: object

pyanaconda.bootloader.writeBootLoader(storage, payload, instClass, ksdata)¶

Write bootloader configuration to disk.

When we get here, the bootloader will already have a default linux image. We only have to add images for the non-default kernels and adjust the default to reflect whatever the default variant is.

pyanaconda.bootloader.writeBootLoaderFinal(storage, payload, instClass, ksdata)¶

Do the final write of the bootloader.

pyanaconda.bootloader.writeSysconfigKernel(storage, version, instClass)¶

pyanaconda.constants module¶

pyanaconda.constants_text module¶

pyanaconda.desktop module¶

class pyanaconda.desktop.Desktop¶

Bases: object

runlevel¶

write()¶

pyanaconda.errors module¶

exception pyanaconda.errors.InvalidImageSizeError(message, filename)¶

Bases: Exception

exception pyanaconda.errors.MissingImageError¶

Bases: Exception

exception pyanaconda.errors.MediaUnmountError(device)¶

Bases: Exception

exception pyanaconda.errors.MediaMountError(device)¶

Bases: Exception

exception pyanaconda.errors.ScriptError(lineno, details)¶

Bases: Exception

exception pyanaconda.errors.CmdlineError¶

Bases: Exception

pyanaconda.exception module¶

class pyanaconda.exception.AnacondaExceptionHandler(confObj, intfClass, exnClass, tty_num, gui_lock, interactive)¶

Bases: meh.handler.ExceptionHandler

See:	python-meh’s ExceptionHandler
Parameters:	tty_num – the number of tty the interface is running on

handleException(dump_info)¶

Our own handleException method doing some additional stuff before calling the original python-meh’s one.

See:	python-meh’s ExceptionHandler.handleException

postWriteHook(dump_info)¶

runDebug(exc_info)¶

class pyanaconda.exception.AnacondaReverseExceptionDump(exc_info, config_obj)¶

Bases: meh.dump.ReverseExceptionDump

Create a new ExceptionDump instance. Instance attributes:

Parameters:	exc_info (an instance of the meh.ExceptionInfo class) – info about the exception provided by Python config_obj (an instance of the meh.Config class) – configuration for python-meh

desc¶

When traceback will be part of the exception message split the description from traceback. Description is used in name of the bug in Bugzilla. This is useful when saving exception in exception handler and raising this exception elsewhere (subprocess exception).

Returns:	Exception description (bug name)
Return type:	str

pyanaconda.exception.initExceptionHandling(anaconda)¶

pyanaconda.exception.journalctl_callback()¶

Callback to get logs from journalctl.

pyanaconda.exception.list_addons_callback()¶

Callback to get info about the addons potentially affecting Anaconda’s behaviour.

pyanaconda.exception.lsblk_callback()¶

Callback to get info about block devices.

pyanaconda.exception.nmcli_dev_list_callback()¶

Callback to get info about network devices.

pyanaconda.exception.test_exception_handling()¶

Function that can be used for testing exception handling in anaconda. It tries to prepare a worst case scenario designed from bugs seen so far.

pyanaconda.flags module¶

class pyanaconda.flags.BootArgs(cmdline=None, files=None)¶

Bases: collections.OrderedDict

Hold boot arguments as an OrderedDict.

Create a BootArgs object. Reads each of the “files”, then parses “cmdline” if it was provided.

getbool(arg, default=False)¶

Return the value of the given arg, as a boolean. The rules are: - “arg”, “arg=val”: True - “noarg”, “noarg=val”, “arg=[0|off|no]”: False

read(filenames)¶

Read and parse a filename (or a list of filenames). Files that can’t be read are silently ignored. Returns a list of successfully read files. filenames can contain *, ?, and character ranges expressed with []

readstr(cmdline)¶

class pyanaconda.flags.Flags(read_cmdline=True)¶

Bases: object

get(attr, val=None)¶

read_cmdline()¶

set_cmdline_bool(flag)¶

pyanaconda.flags.can_touch_runtime_system(msg, touch_live=False)¶

Guard that should be used before doing actions that modify runtime system.

Parameters:	msg (str) – message to be logged in case that runtime system cannot be touched touch_live (bool) – whether to allow touching liveCD installation system
Return type:	bool

pyanaconda.geoloc module¶

A GeoIP and WiFi location module - location detection based on IP address

How to use the geolocation module

First call init_geolocation() - this creates the LocationInfo singleton and you can also use it to set what geolocation provider should be used. To actually look up current position, call refresh() - this will trigger the actual online geolocation query, which runs in a thread. After the look-up thread finishes, the results are stored in the singleton and can be retrieved using the get_territory_code() and get_result() methods. If you call these methods without calling refresh() first or if the look-up is currently in progress, both return None.

pyanaconda.i18n module¶

pyanaconda.i18n.N_(x)¶

pyanaconda.i18n.P_(x, y, z)¶

pyanaconda.i18n.C_(msgctxt, msgid)¶

pyanaconda.i18n.CN_(c, x)¶

pyanaconda.i18n.CP_(msgctxt, msgid, msgid_plural, n)¶

pyanaconda.ihelp module¶

Anaconda built-in help module

pyanaconda.ihelp.get_help_path(help_file, instclass)¶

Return the full path for the given help file name, if the help file path does not exist a fallback path is returned. There are actually two possible fallback paths that might be returned:

• first we try to return path to the main page of the installation guide (if it exists)
• if we can’t find the main page of the installation page, path to a “no help found” placeholder bundled with Anaconda is returned

Regarding help l10n, we try to respect the current locale as defined by the “LANG” environmental variable, but fallback to English if localized content is not available.

Parameters:	help_file (str or NoneType) – help file name instclass – current install class instance
Return str:	full path to the help file requested or to a placeholder

pyanaconda.ihelp.kill_yelp()¶

Try to kill any existing yelp processes

pyanaconda.ihelp.start_yelp(help_path)¶

Start a new yelp process and make sure to kill any existing ones

Parameters:	help_path (str or NoneType) – path to the help file yelp should load

pyanaconda.image module¶

pyanaconda.image.findFirstIsoImage(path)¶

Find the first iso image in path This also supports specifying a specific .iso image

Returns the basename of the image

pyanaconda.image.mountImage(isodir, tree)¶

pyanaconda.image.opticalInstallMedia(devicetree)¶

pyanaconda.image.potentialHdisoSources(devicetree)¶

pyanaconda.image.verifyMedia(tree, timestamp=None)¶

pyanaconda.install module¶

pyanaconda.install.doConfiguration(storage, payload, ksdata, instClass)¶

pyanaconda.install.doInstall(storage, payload, ksdata, instClass)¶

Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems.

pyanaconda.installclass module¶

class pyanaconda.installclass.BaseInstallClass¶

Bases: object

bootloaderExtraArgs = []¶

bootloaderTimeoutDefault = None¶

configure(anaconda)¶

defaultFS = None¶

defaultPackageEnvironment = None¶

getBackend()¶

help_folder = '/usr/share/anaconda/help'¶

help_main_page = 'Installation_Guide.xml'¶

help_placeholder = None¶

help_placeholder_with_links = None¶

hidden = False¶

ignoredPackages = []¶

installUpdates = True¶

l10n_domain¶

name = 'base'¶

setDefaultPartitioning(storage)¶

setNetworkOnbootDefault(ksdata)¶

setPackageSelection(anaconda)¶

stylesheet = None¶

class pyanaconda.installclass.DefaultInstall¶

Bases: fedora.FedoraBaseInstallClass

pyanaconda.installclass.availableClasses(showHidden=False)¶

pyanaconda.installclass.getBaseInstallClass()¶

pyanaconda.iutil module¶

class pyanaconda.iutil.DataHolder(**kwargs)¶

Bases: dict

A dict that lets you also access keys using dot notation.

kwargs are set as keys for the dict.

copy()¶

exception pyanaconda.iutil.ExitError¶

Bases: RuntimeError

class pyanaconda.iutil.ProxyString(url=None, protocol='http://', host=None, port='3128', username=None, password=None)¶

Bases: object

Handle a proxy url

Initialize with either url ([protocol://][username[:password]@]host[:port]) or pass host and optionally:

protocol http, https, ftp host hostname without protocol port port number (defaults to 3128) username username password password

The str() of the object is the full proxy url

ProxyString.url is the full url including username:password@ ProxyString.noauth_url is the url without username:password@

dict¶

return a dict of all the elements of the proxy string url, noauth_url, protocol, host, port, username, password

parse_components()¶

Parse the components of a proxy url into url and noauth_url

parse_url()¶

Parse the proxy url into its component pieces

exception pyanaconda.iutil.ProxyStringError¶

Bases: Exception

pyanaconda.iutil.add_po_path(directory)¶

Looks to see what translations are under a given path and tells the gettext module to use that path as the base dir

pyanaconda.iutil.augmentEnv()¶

pyanaconda.iutil.chown_dir_tree(root, uid, gid, from_uid_only=None, from_gid_only=None)¶

Change owner (uid and gid) of the files and directories under the given directory tree (recursively).

Parameters:	root (str) – root of the directory tree that should be chown’ed uid (int) – UID that should be set as the owner gid (int) – GID that should be set as the owner from_uid_only (int or None) – if given, the owner is changed only for the files and directories owned by that UID from_gid_only (int or None) – if given, the owner is changed only for the files and directories owned by that GID

pyanaconda.iutil.cmp_obj_attrs(obj1, obj2, attr_list)¶

Compare attributes of 2 objects for changes

Missing attrs are considered a mismatch

Parameters:	obj1 (Any object) – First object to compare obj2 (Any object) – Second object to compare attr_list (list or tuple of strings) – List of attributes to compare
Returns:	True if the attrs all match
Return type:	bool

pyanaconda.iutil.dir_tree_map(root, func, files=True, dirs=True)¶

Apply the given function to all files and directories in the directory tree under the given root directory.

Parameters:	root (str) – root of the directory tree the function should be mapped to func (path -> None) – a function taking the directory/file path files (bool) – whether to apply the function to the files in the dir. tree dirs (bool) – whether to apply the function to the directories in the dir. tree

TODO: allow using globs and thus more trees?

pyanaconda.iutil.disable_service(service)¶

Disable a systemd service in the sysroot

pyanaconda.iutil.dracut_eject(device)¶

Use dracut shutdown hook to eject media after the system is shutdown. This is needed because we are running from the squashfs.img on the media so ejecting too early will crash the installer.

pyanaconda.iutil.enable_service(service)¶

Enable a systemd service in the sysroot

pyanaconda.iutil.ensure_str(str_or_bytes, keep_none=True)¶

Returns a str instance for given string or None if requested to keep it.

Parameters:	str_or_bytes (str or bytes) – string to be kept or converted to str type keep_none (bool) – whether to keep None as it is or raise ValueError if None is passed
Raises ValueError:
	if applied on an object not being of type bytes nor str (nor NoneType if keep_none is False)

pyanaconda.iutil.execConsole()¶

pyanaconda.iutil.execInSysroot(command, argv, stdin=None)¶

Run an external program in the target root. :param command: The command to run :param argv: The argument list :param stdin: The file object to read stdin from. :return: The return code of the command

pyanaconda.iutil.execReadlines(command, argv, stdin=None, root='/', env_prune=None, filter_stderr=False)¶

Execute an external command and return the line output of the command in real-time.

This method assumes that there is a reasonably low delay between the end of output and the process exiting. If the child process closes stdout and then keeps on truckin’ there will be problems.

NOTE/WARNING: UnicodeDecodeError will be raised if the output of the

external command can’t be decoded as UTF-8.

Parameters:	command – The command to run argv – The argument list stdin – The file object to read stdin from. stdout – Optional file object to redirect stdout and stderr to. root – The directory to chroot to before running command. env_prune – environment variable to remove before execution filter_stderr – Whether stderr should be excluded from the returned output

Output from the file is not logged to program.log This returns an iterator with the lines from the command until it has finished

pyanaconda.iutil.execWithCapture(command, argv, stdin=None, root='/', log_output=True, filter_stderr=False)¶

Run an external program and capture standard out and err.

Parameters:	command – The command to run argv – The argument list stdin – The file object to read stdin from. root – The directory to chroot to before running command. log_output – Whether to log the output of command filter_stderr – Whether stderr should be excluded from the returned output
Returns:	The output of the command

pyanaconda.iutil.execWithCaptureBinary(command, argv, stdin=None, root='/', log_output=False, filter_stderr=False)¶

Run an external program and capture standard out and err as binary data. The binary data output is not logged by default but logging can be enabled.

Parameters:	command – The command to run argv – The argument list stdin – The file object to read stdin from. root – The directory to chroot to before running command. log_output – Whether to log the binary output of the command filter_stderr – Whether stderr should be excluded from the returned output
Returns:	The output of the command

pyanaconda.iutil.execWithRedirect(command, argv, stdin=None, stdout=None, root='/', env_prune=None, log_output=True, binary_output=False)¶

Run an external program and redirect the output to a file.

Parameters:	command – The command to run argv – The argument list stdin – The file object to read stdin from. stdout – Optional file object to redirect stdout and stderr to. root – The directory to chroot to before running command. env_prune – environment variable to remove before execution log_output – whether to log the output of command binary_output – whether to treat the output of command as binary data
Returns:	The return code of the command

pyanaconda.iutil.getDirSize(directory)¶

Get the size of a directory and all its subdirectories.

Parameters:	dir – The name of the directory to find the size of.
Returns:	The size of the directory in kilobytes.

pyanaconda.iutil.getSysroot()¶

Returns the path to the target OS installation.

For ordinary package-based installations, this is the same as the target root.

pyanaconda.iutil.getTargetPhysicalRoot()¶

Returns the path to the “physical” storage root, traditionally /mnt/sysimage.

This may be distinct from the sysroot, which could be a chroot-type subdirectory of the physical root. This is used for example by all OSTree-based installations.

pyanaconda.iutil.get_active_console(dev='console')¶

Find the active console device.

Some tty devices (/dev/console, /dev/tty0) aren’t actual devices; they just redirect input and output to the real console device(s).

These ‘fake’ ttys have an ‘active’ sysfs attribute, which lists the real console device(s). (If there’s more than one, the last one in the list is the primary console.)

pyanaconda.iutil.get_mount_paths(devnode)¶

given a device node, return a list of all active mountpoints.

pyanaconda.iutil.get_platform_groupid()¶

Return a platform group id string

This runs systemd-detect-virt and if the result is not ‘none’ it prefixes the lower case result with “platform-” for use as a group id.

Returns:	Empty string or a group id for the detected platform
Return type:	str

pyanaconda.iutil.getdeepattr(obj, name)¶

This behaves as the standard getattr, but supports composite (containing dots) attribute names.

As an example:

>>> import os
>>> from os.path import split
>>> getdeepattr(os, "path.split") == split
True

pyanaconda.iutil.have_word_match(str1, str2)¶

Tells if all words from str1 exist in str2 or not.

pyanaconda.iutil.id_generator()¶

Id numbers generator. Generating numbers from 0 to X and increments after every call.

Returns:	Generator which gives you unique numbers.

pyanaconda.iutil.ipmi_abort(scripts=None)¶

pyanaconda.iutil.ipmi_report(event)¶

pyanaconda.iutil.isConsoleOnVirtualTerminal(dev='console')¶

pyanaconda.iutil.is_unsupported_hw()¶

Check to see if the hardware is supported or not.

Returns:	True if this is unsupported hardware, False otherwise
Return type:	bool

pyanaconda.iutil.lowerASCII(s)¶

Convert a string to lowercase using only ASCII character definitions.

The returned string will contain only ASCII characters. This function is locale-independent.

pyanaconda.iutil.mkdirChain(directory)¶

Make a directory and all of its parents. Don’t fail if part or of it already exists.

Parameters:	directory (str) – The directory path to create

pyanaconda.iutil.open_with_perm(path, mode='r', perm=511, **kwargs)¶

Open a file with the given permission bits.

This is more or less the same as using os.open(path, flags, perm), but with the builtin open() semantics and return type instead of a file descriptor.

Parameters:	path (str) – The path of the file to be opened mode (str) – The same thing as the mode argument to open() perm (int) – What permission bits to use if creating a new file

pyanaconda.iutil.parent_dir(directory)¶

Return the parent’s path

pyanaconda.iutil.parseNfsUrl(nfsurl)¶

pyanaconda.iutil.persistent_root_image()¶

Returns:	whether we are running from a persistent (not in RAM) root.img

pyanaconda.iutil.reIPL(ipldev)¶

pyanaconda.iutil.requests_session()¶

Return a requests.Session object with file and ftp support.

pyanaconda.iutil.resetRpmDb()¶

pyanaconda.iutil.restart_service(service)¶

pyanaconda.iutil.runOnErrorScripts(scripts)¶

pyanaconda.iutil.save_screenshots()¶

Save screenshots to the installed system

pyanaconda.iutil.service_running(service)¶

pyanaconda.iutil.setSysroot(path)¶

Change the OS root path.

param path:	The new OS root path

This should only be used by Payload subclasses which install operating systems to non-default roots.

pyanaconda.iutil.setTargetPhysicalRoot(path)¶

Change the physical root path

Parameters:	path (string) – Path to use instead of /mnt/sysimage/

pyanaconda.iutil.setdeepattr(obj, name, value)¶

This behaves as the standard setattr, but supports composite (containing dots) attribute names.

As an example:

>>> class O:
>>>   pass
>>> a = O()
>>> a.b = O()
>>> a.b.c = O()
>>> setdeepattr(a, "b.c.d", True)
>>> a.b.c.d
True

pyanaconda.iutil.setenv(name, value)¶

Set an environment variable to be used by child processes.

This method does not modify os.environ for the running process, which is not thread-safe. If setenv has already been called for a particular variable name, the old value is overwritten.

Parameters:	name (str) – The name of the environment variable value (str) – The value of the environment variable

pyanaconda.iutil.setup_translations()¶

pyanaconda.iutil.startProgram(argv, root='/', stdin=None, stdout=-1, stderr=-2, env_prune=None, env_add=None, reset_handlers=True, reset_lang=True, **kwargs)¶

Start an external program and return the Popen object.

The root and reset_handlers arguments are handled by passing a preexec_fn argument to subprocess.Popen, but an additional preexec_fn can still be specified and will be run. The user preexec_fn will be run last.

Parameters:

argv – The command to run and argument root – The directory to chroot to before running command. stdin – The file object to read stdin from. stdout – The file object to write stdout to. stderr – The file object to write stderr to. env_prune – environment variables to remove before execution env_add – environment variables to add before execution reset_handlers – whether to reset to SIG_DFL any signal handlers set to SIG_IGN reset_lang – whether to set the locale of the child process to C kwargs – Additional parameters to pass to subprocess.Popen

Returns:

A Popen object for the running command.

pyanaconda.iutil.startX(argv, output_redirect=None)¶

Start X and return once X is ready to accept connections.

X11, if SIGUSR1 is set to SIG_IGN, will send SIGUSR1 to the parent process once it is ready to accept client connections. This method sets that up and waits for the signal or bombs out if nothing happens for a minute. The process will also be added to the list of watched processes.

Parameters:	argv – The command line to run, as a list output_redirect – file or file descriptor to redirect stdout and stderr to

pyanaconda.iutil.start_service(service)¶

pyanaconda.iutil.stop_service(service)¶

pyanaconda.iutil.strip_accents(s)¶

This function takes arbitrary unicode string and returns it with all the diacritics removed.

Parameters:	s (str) – arbitrary string
Returns:	s with diacritics removed
Return type:	str

pyanaconda.iutil.sysroot_path(path)¶

Make the given relative or absolute path “sysrooted” :param str path: path to be sysrooted :returns: sysrooted path :rtype: str

pyanaconda.iutil.touch(file_path)¶

Create an empty file.

pyanaconda.iutil.unwatchAllProcesses()¶

Clear the watched process list.

pyanaconda.iutil.unwatchProcess(proc)¶

Unwatch a process watched by watchProcess.

Parameters:	proc – The Popen object for the process.

pyanaconda.iutil.upcase_first_letter(text)¶

Helper function that upcases the first letter of the string. Python’s standard string.capitalize() not only upcases the first letter but also lowercases all the others. string.title() capitalizes all words in the string.

Returns:	the given text with the first letter upcased
Return type:	str

pyanaconda.iutil.upperASCII(s)¶

Convert a string to uppercase using only ASCII character definitions.

The returned string will contain only ASCII characters. This function is locale-independent.

pyanaconda.iutil.vtActivate(num)¶

Try to switch to tty number $num.

Returns:	whether the switch was successful or not
Return type:	bool

pyanaconda.iutil.watchProcess(proc, name)¶

Watch for a process exit, and raise a ExitError when it does.

This method installs a SIGCHLD signal handler and thus interferes the child_watch_add methods in GLib. Use watchProcessGLib to convert to GLib mode if using a GLib main loop.

Since the SIGCHLD handler calls wait() on the watched process, this call cannot be combined with Popen.wait() or Popen.communicate, and also doing so wouldn’t make a whole lot of sense.

Parameters:	proc – The Popen object for the process name – The name of the process

pyanaconda.iutil.watchProcessGLib()¶

Convert process watching to GLib mode.

This allows anaconda modes that use GLib main loops to use GLib.child_watch_add and continue to watch processes started before the main loop.

pyanaconda.iutil.xprogressive_delay()¶

A delay generator, the delay starts short and gets longer as the internal counter increases. For example for 10 retries, the delay will increases from 0.5 to 256 seconds.

Parameters:	retry_number (int) – retry counter
Returns float:	time to wait in seconds

pyanaconda.kexec module¶

exception pyanaconda.kexec.GrubbyInfoError¶

Bases: Exception

pyanaconda.kexec.run_grubby(args=None)¶

Run grubby and retrieve the kernel, initrd and boot arguments

Parameters:	args (list) – Arguments to pass to grubby.
Returns:	kernel path, initrd path, root device, kernel cmdline args.
Return type:	namedtuple
Raises:	some error on failure

The returned namedtuple contains the following attributes:

kernel, initrd, root, args

pyanaconda.kexec.setup_kexec(extra_args=None)¶

Setup kexec to use the new kernel and default bootloader entry

Parameters:	extra_args (list) – Extra arguments to pass to kexec

This uses grubby to determine the bootloader arguments from the default entry, and then sets up kexec so that reboot will use the new kernel and initrd instead of doing a full reboot.

Note

Once kexec is called there is nothing else to do, the reboot code already handles having kexec setup.

pyanaconda.keyboard module¶

This module provides functions for dealing with keyboard layouts/keymaps in Anaconda and the LocaledWrapper class with methods for setting, getting and mutually converting X layouts and VConsole keymaps.

exception pyanaconda.keyboard.InvalidLayoutVariantSpec¶

Bases: Exception

Exception class for errors related to parsing layout and variant specification strings.

exception pyanaconda.keyboard.KeyboardConfigError¶

Bases: Exception

Exception class for keyboard configuration related problems

class pyanaconda.keyboard.LocaledWrapper¶

Bases: object

Class wrapping systemd-localed daemon functionality. By using safe_dbus module it tries to prevent failures related to threads and main loops.

convert_keymap(keymap)¶

Method that returns X11 layouts and variants that (systemd-localed thinks) match given keymap best.

Parameters:	keymap (str) – VConsole keymap
Returns:	X11 layouts and variants that (systemd-localed thinks) match given keymap best
Return type:	str

convert_layout(layout_variant)¶

Method that returns VConsole keymap that (systemd-localed thinks) matches given layout and variant best.

Parameters:	layout_variant (str) – ‘layout (variant)’ or ‘layout’ specification
Returns:	a keymap matching layout and variant best
Return type:	string

keymap¶

layouts_variants¶

options¶

set_and_convert_keymap(keymap)¶

Method that sets VConsole keymap and returns X11 layouts and variants that (systemd-localed thinks) match given keymap best.

Returns:	string containing comma-separated “layout (variant)” or “layout” layout specifications
Return type:	string

set_and_convert_layout(layout_variant)¶

Method that sets X11 layout and variant (for later X sessions) and returns VConsole keymap that (systemd-localed thinks) matches given layout and variant best.

Returns:	a keymap matching layout and variant best
Return type:	string

set_keymap(keymap, convert=False)¶

Method that sets VConsole keymap via systemd-localed’s DBus API.

Parameters:	keymap (str) – VConsole keymap that should be set convert (bool) – whether the keymap should be converted to a X11 layout (see set_and_convert_keymap)

set_layouts(layouts_variants, options=None, convert=False)¶

Method that sets X11 layouts and variants (for later X sessions) via systemd-localed’s DBus API.

Parameters:	layout_variant (list of strings) – list of ‘layout (variant)’ or ‘layout’ specifications of layouts and variants options (list of strings) – list of X11 options that should be set convert (bool) – whether the keymap should be converted to a X11 layout (see set_and_convert_keymap)

exception pyanaconda.keyboard.LocaledWrapperError¶

Bases: pyanaconda.keyboard.KeyboardConfigError

Exception class for reporting Localed-related problems

pyanaconda.keyboard.activate_keyboard(keyboard)¶

Try to setup VConsole keymap and X11 layouts as specified in kickstart.

Parameters:	keyboard (ksdata.keyboard object) – ksdata.keyboard object

pyanaconda.keyboard.join_layout_variant(layout, variant='')¶

Join layout and variant to form the commonly used ‘layout (variant)’ or ‘layout’ (if variant is missing) format.

Returns:	‘layout (variant)’ or ‘layout’ string
Return type:	string

pyanaconda.keyboard.normalize_layout_variant(layout_str)¶

Normalize keyboard layout and variant specification given as a single string. E.g. for a ‘layout(variant) string missing the space between the left parenthesis return ‘layout (variant)’ which is a proper layout and variant specification we use.

Parameters:	layout_str (string) – a string specifying keyboard layout and its variant

pyanaconda.keyboard.parse_layout_variant(layout_variant_str)¶

Parse layout and variant from the string that may look like ‘layout’ or ‘layout (variant)’.

Parameters:	layout_variant_str (str) – keyboard layout and variant string specification
Returns:	the (layout, variant) pair, where variant can be “”
Return type:	tuple
Raises InvalidLayoutVariantSpec:
	if the given string isn’t a valid layout and variant specification string

pyanaconda.keyboard.populate_missing_items(keyboard)¶

Function that populates keyboard.vc_keymap and keyboard.x_layouts if they are missing. By invoking LocaledWrapper’s methods this function READS AND WRITES CONFIGURATION FILES (but tries to keep their content unchanged).

pyanaconda.keyboard.set_x_keyboard_defaults(ksdata, xkl_wrapper)¶

Set default keyboard settings (layouts, layout switching).

Parameters:	ksdata (object instance) – kickstart instance xkl_wrapper (object instance) – XklWrapper instance
Raises InvalidLocaleSpec:
	if an invalid locale is given (see localization.LANGCODE_RE)

pyanaconda.keyboard.write_keyboard_config(keyboard, root, convert=True)¶

Function that writes files with layouts configuration to $root/etc/X11/xorg.conf.d/01-anaconda-layouts.conf and $root/etc/vconsole.conf.

Parameters:	keyboard – ksdata.keyboard object root – path to the root of the installed system convert – whether to convert specified values to get the missing ones weight – weight (prefix) of the xorg.conf file written out

pyanaconda.kickstart module¶

class pyanaconda.kickstart.AnacondaInternalScript(*args, **kwargs)¶

Bases: pyanaconda.kickstart.AnacondaKSScript

class pyanaconda.kickstart.AnacondaKSHandler(addon_paths=None, commandUpdates=None, dataUpdates=None)¶

Bases: f25.F25Handler

AddonClassType¶

alias of AddonData

class pyanaconda.kickstart.AnacondaKSParser(handler, followIncludes=True, errorsAreFatal=True, missingIncludeIsFatal=True, scriptClass=<class 'pyanaconda.kickstart.AnacondaKSScript'>)¶

Bases: pykickstart.parser.KickstartParser

handleCommand(lineno, args)¶

setupSections()¶

class pyanaconda.kickstart.AnacondaKSScript(script, *args, **kwargs)¶

Bases: pykickstart.parser.Script

Execute a kickstart script

This will write the script to a file named /tmp/ks-script- before execution. Output is logged by the program logger, the path specified by –log or to /tmp/ks-script-*.log

Create a new Script instance. Instance attributes:

Parameters:

errorOnFail – If execution of the script fails, should anaconda stop, display an error, and then reboot without running any other scripts? inChroot – Does the script execute in anaconda’s chroot environment or not? interp – The program that should be used to interpret this script. lineno – The line number this script starts on. logfile – Where all messages from the script should be logged. script – A string containing all the lines of the script. type – The type of the script, which can be KS_SCRIPT_* from pykickstart.constants.

run(chroot)¶

Run the kickstart script @param chroot directory path to chroot into before execution

class pyanaconda.kickstart.AnacondaPreParser(handler, followIncludes=True, errorsAreFatal=True, missingIncludeIsFatal=True)¶

Bases: pykickstart.parser.KickstartParser

handleCommand(lineno, args)¶

setupSections()¶

class pyanaconda.kickstart.AnacondaSection(*args, **kwargs)¶

Bases: pykickstart.sections.Section

A section for anaconda specific commands.

finalize()¶

Let %anaconda know no additional data will come.

handleHeader(lineno, args)¶

Process the arguments to the %anaconda header.

handleLine(line)¶

sectionOpen = '%anaconda'¶

class pyanaconda.kickstart.AnacondaSectionHandler¶

Bases: pykickstart.base.BaseHandler

A handler for only the anaconda ection’s commands.

commandMap = {'pwpolicy': <class 'pyanaconda.pwpolicy.F22_PwPolicy'>}¶

dataMap = {'PwPolicyData': <class 'pyanaconda.pwpolicy.F22_PwPolicyData'>}¶

class pyanaconda.kickstart.Authconfig(*args, **kwargs)¶

Bases: pykickstart.commands.authconfig.FC3_Authconfig

execute(*args)¶

setup()¶

class pyanaconda.kickstart.AutoPart(writePriority=100, *args, **kwargs)¶

Bases: pykickstart.commands.autopart.F21_AutoPart

execute(storage, ksdata, instClass)¶

parse(args)¶

class pyanaconda.kickstart.BTRFS(writePriority=132, *args, **kwargs)¶

Bases: pykickstart.commands.btrfs.F23_BTRFS

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.BTRFSData(*args, **kwargs)¶

Bases: pykickstart.commands.btrfs.F23_BTRFSData

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.Bootloader(*args, **kwargs)¶

Bases: pykickstart.commands.bootloader.F21_Bootloader

execute(storage, ksdata, instClass)¶

parse(args)¶

class pyanaconda.kickstart.ClearPart(*args, **kwargs)¶

Bases: pykickstart.commands.clearpart.F21_ClearPart

execute(storage, ksdata, instClass)¶

parse(args)¶

class pyanaconda.kickstart.Fcoe(writePriority=71, *args, **kwargs)¶

Bases: pykickstart.commands.fcoe.F13_Fcoe

parse(args)¶

class pyanaconda.kickstart.Firewall(*args, **kwargs)¶

Bases: pykickstart.commands.firewall.F20_Firewall

execute(storage, ksdata, instClass)¶

setup()¶

class pyanaconda.kickstart.Firstboot(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.firstboot.FC3_Firstboot

execute(*args)¶

setup(*args)¶

class pyanaconda.kickstart.Group(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.group.F12_Group

execute(storage, ksdata, instClass, users)¶

class pyanaconda.kickstart.IgnoreDisk(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.ignoredisk.RHEL6_IgnoreDisk

parse(args)¶

class pyanaconda.kickstart.Iscsi(writePriority=71, *args, **kwargs)¶

Bases: pykickstart.commands.iscsi.F17_Iscsi

parse(args)¶

class pyanaconda.kickstart.IscsiName(writePriority=70, *args, **kwargs)¶

Bases: pykickstart.commands.iscsiname.FC6_IscsiName

parse(args)¶

class pyanaconda.kickstart.Keyboard(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.keyboard.F18_Keyboard

execute(*args)¶

class pyanaconda.kickstart.Lang(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.lang.F19_Lang

execute(*args, **kwargs)¶

class pyanaconda.kickstart.LogVol(writePriority=133, *args, **kwargs)¶

Bases: pykickstart.commands.logvol.F23_LogVol

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.LogVolData(*args, **kwargs)¶

Bases: pykickstart.commands.logvol.F23_LogVolData

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.Logging(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.logging.FC6_Logging

execute(*args)¶

class pyanaconda.kickstart.Network(*args, **kwargs)¶

Bases: pykickstart.commands.network.F24_Network

execute(storage, ksdata, instClass)¶

parse(args)¶

setup()¶

class pyanaconda.kickstart.Partition(writePriority=130, *args, **kwargs)¶

Bases: pykickstart.commands.partition.F23_Partition

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.PartitionData(*args, **kwargs)¶

Bases: pykickstart.commands.partition.F23_PartData

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.Raid(writePriority=131, *args, **kwargs)¶

Bases: pykickstart.commands.raid.F25_Raid

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.RaidData(*args, **kwargs)¶

Bases: pykickstart.commands.raid.F25_RaidData

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.Realm(*args)¶

Bases: pykickstart.commands.realm.F19_Realm

execute(*args)¶

setup()¶

class pyanaconda.kickstart.RepoData(*args, **kwargs)¶

Bases: pykickstart.commands.repo.F21_RepoData

Add enabled kwarg

Parameters:	enabled (bool) – The repo has been enabled

class pyanaconda.kickstart.ReqPart(writePriority=100, *args, **kwargs)¶

Bases: pykickstart.commands.reqpart.F23_ReqPart

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.RootPw(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.rootpw.F18_RootPw

execute(storage, ksdata, instClass, users)¶

class pyanaconda.kickstart.SELinux(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.selinux.FC3_SELinux

execute(*args)¶

class pyanaconda.kickstart.Services(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.services.FC6_Services

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.SkipX(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.skipx.FC3_SkipX

execute(*args)¶

class pyanaconda.kickstart.SshKey(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.sshkey.F22_SshKey

execute(storage, ksdata, instClass, users)¶

class pyanaconda.kickstart.Timezone(*args)¶

Bases: pykickstart.commands.timezone.F23_Timezone

execute(*args)¶

setup(ksdata)¶

class pyanaconda.kickstart.Upgrade¶

Bases: pykickstart.commands.upgrade.F20_Upgrade

parse(*args)¶

class pyanaconda.kickstart.User(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.user.F19_User

execute(storage, ksdata, instClass, users)¶

class pyanaconda.kickstart.VolGroup(writePriority=132, *args, **kwargs)¶

Bases: pykickstart.commands.volgroup.F21_VolGroup

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.VolGroupData(*args, **kwargs)¶

Bases: pykickstart.commands.volgroup.F21_VolGroupData

execute(storage, ksdata, instClass)¶

class pyanaconda.kickstart.XConfig(writePriority=0, *args, **kwargs)¶

Bases: pykickstart.commands.xconfig.F14_XConfig

execute(*args)¶

class pyanaconda.kickstart.ZFCP(*args, **kwargs)¶

Bases: pykickstart.commands.zfcp.F14_ZFCP

parse(args)¶

pyanaconda.kickstart.appendPostScripts(ksdata)¶

pyanaconda.kickstart.deviceMatches(spec, devicetree=None)¶

Return names of block devices matching the provided specification.

Parameters:	spec (str) – a device identifier (name, UUID=<uuid>, &c) devicetree (blivet.DeviceTree) – device tree to look up devices in (optional)
Returns:	names of matching devices
Return type:	list of str

parse methods will not have access to a devicetree, while execute methods will. The devicetree is superior in that it can resolve md array names and in that it reflects scheduled device removals, but for normal local disks udev.resolve_devspec should suffice.

pyanaconda.kickstart.doKickstartStorage(storage, ksdata, instClass)¶

Setup storage state from the kickstart data

pyanaconda.kickstart.getAvailableDiskSpace(storage)¶

Get overall disk space available on disks we may use.

Parameters:	storage – blivet.Blivet instance
Returns:	overall disk space available
Return type:	blivet.size.Size

pyanaconda.kickstart.getEscrowCertificate(escrowCerts, url)¶

pyanaconda.kickstart.lookupAlias(devicetree, alias)¶

pyanaconda.kickstart.parseKickstart(f)¶

pyanaconda.kickstart.preScriptPass(f)¶

pyanaconda.kickstart.refreshAutoSwapSize(storage)¶

Refresh size of the auto partitioning request for swap device according to the current state of the storage configuration.

Parameters:	storage – blivet.Blivet instance

pyanaconda.kickstart.removeExistingFormat(device, storage)¶

pyanaconda.kickstart.resetCustomStorageData(ksdata)¶

pyanaconda.kickstart.runPostScripts(scripts)¶

pyanaconda.kickstart.runPreInstallScripts(scripts)¶

pyanaconda.kickstart.runPreScripts(scripts)¶

pyanaconda.kickstart.runTracebackScripts(scripts)¶

pyanaconda.localization module¶

exception pyanaconda.localization.InvalidLocaleSpec¶

Bases: pyanaconda.localization.LocalizationConfigError

Exception class for the errors related to invalid locale specs

exception pyanaconda.localization.LocalizationConfigError¶

Bases: Exception

Exception class for localization configuration related problems

pyanaconda.localization.find_best_locale_match(locale, langcodes)¶

Find the best match for the locale in a list of langcodes. This is useful when e.g. pt_BR is a locale and there are possibilities to choose an item (e.g. rnote) for a list containing both pt and pt_BR or even also pt_PT.

Parameters:	locale (str) – a valid locale (e.g. en_US.UTF-8 or sr_RS.UTF-8@latin, etc.) langcodes (list(str) or generator(str)) – a list or generator of langcodes (e.g. en, en_US, en_US@latin, etc.)
Returns:	the best matching langcode from the list of None if none matches
Return type:	str or None

pyanaconda.localization.get_available_translations(localedir=None)¶

Method that generates (i.e. returns a generator) available translations for the installer in the given localedir.

Returns:	generator yielding available translations (languages)
Return type:	generator yielding strings

pyanaconda.localization.get_english_name(locale)¶

Function returning english name for the given locale.

Parameters:	locale (str) – locale to return english name for
Returns:	english name for the locale or empty string if unknown
Return type:	st
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_firmware_language(text_mode=False)¶

Procedure that returns the firmware language information (if any).

Parameters:	text_mode (boot) – if the locale is being setup for text mode
Returns:	the firmware language translated into a locale string, or None
Return type:	str

pyanaconda.localization.get_language_locales(lang)¶

Function returning all locales available for the given language.

Parameters:	lang (str) – language to get available locales for
Returns:	a list of available locales
Return type:	list of strings
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_locale_console_fonts(locale)¶

Function returning preferred console fonts for the given locale.

Parameters:	locale (str) – locale string (see LANGCODE_RE)
Returns:	list of preferred console fonts
Return type:	list of strings
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_locale_keyboards(locale)¶

Function returning preferred keyboard layouts for the given locale.

Parameters:	locale (str) – locale string (see LANGCODE_RE)
Returns:	list of preferred keyboard layouts
Return type:	list of strings
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_locale_scripts(locale)¶

Function returning preferred scripts (writing systems) for the given locale.

Parameters:	locale (str) – locale string (see LANGCODE_RE)
Returns:	list of preferred scripts
Return type:	list of strings
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_locale_territory(locale)¶

Function returning locale’s territory.

Parameters:	locale (str) – locale string (see LANGCODE_RE)
Returns:	territory or None
Return type:	str or None
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_locale_timezones(locale)¶

Function returning preferred timezones for the given locale.

Parameters:	locale (str) – locale string (see LANGCODE_RE)
Returns:	list of preferred timezones
Return type:	list of strings
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_native_name(locale)¶

Function returning native name for the given locale.

Parameters:	locale (str) – locale to return native name for
Returns:	english name for the locale or empty string if unknown
Return type:	st
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.get_territory_locales(territory)¶

Function returning list of locales for the given territory. The list is sorted from the most probable locale to the least probable one (based on langtable’s ranking.

Parameters:	territory (str) – territory to return locales for
Returns:	list of locales
Return type:	list of strings

pyanaconda.localization.get_xlated_timezone(tz_spec_part)¶

Function returning translated name of a region, city or complete timezone name according to the current value of the $LANG variable.

Parameters:	tz_spec_part (str) – a region, city or complete timezone name
Returns:	translated name of the given region, city or timezone
Return type:	str

pyanaconda.localization.is_supported_locale(locale)¶

Function that tells if the given locale is supported by the Anaconda or not. We consider locales supported by the langtable as supported by the Anaconda.

Parameters:	locale (str) – locale to test
Returns:	whether the given locale is supported or not
Return type:	bool
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.langcode_matches_locale(langcode, locale)¶

Function that tells if the given langcode matches the given locale. I.e. if all parts of appearing in the langcode (language, territory, script and encoding) are the same as the matching parts of the locale.

Parameters:	langcode (str) – a langcode (e.g. en, en_US, en_US@latin, etc.) locale (str) – a valid locale (e.g. en_US.UTF-8 or sr_RS.UTF-8@latin, etc.)
Returns:	whether the given langcode matches the given locale or not
Return type:	bool

pyanaconda.localization.locale_supported_in_console(locale)¶

Function that tells if the given locale can be displayed by the Linux console.

The Linux console can display Latin, Cyrillic and Greek characters reliably, but others such as Japanese, can’t be correctly installed.

Parameters:	locale (str) – locale to test
Returns:	whether the given locale is supported by the console or not
Return type:	bool
Raises InvalidLocaleSpec:
	if an invalid locale is given (see LANGCODE_RE)

pyanaconda.localization.parse_langcode(langcode)¶

For a given langcode (e.g. 'SR_RS.UTF-8@latin‘) returns a dictionary with the following keys and example values:

‘language’ : ‘SR’ ‘territory’ : ‘RS’ ‘encoding’ : ‘UTF-8’ ‘script’ : ‘latin’

or None if the given string doesn’t match the LANGCODE_RE.