8.1.6. cobbler.utils package

8.1.6.1. Submodules

8.1.6.2. cobbler.utils.event module

This module contains logic to support the events Cobbler generates in its XML-RPC API.

class cobbler.utils.event.CobblerEvent(name: str = '', statetime: float = 0.0)

Bases: object

This is a small helper class that represents an event in Cobbler.

property event_id: str

Read only property to retrieve the internal ID of the event.

property name: str

Read only property to retrieve the human-readable name of the event.

8.1.6.3. cobbler.utils.filesystem_helpers module

TODO

cobbler.utils.filesystem_helpers.cachefile(src: str, dst: str) → None

Copy a file into a cache and link it into place. Use this with caution, otherwise you could end up copying data twice if the cache is not on the same device as the destination.

Parameters

• src – The sourcefile for the copy action.

• dst – The destination for the copy action.

cobbler.utils.filesystem_helpers.copyfile(src: str, dst: str, symlink: bool = False) → None

Copy a file from source to the destination.

Parameters

• src – The source file. This may also be a folder.

• dst – The destination for the file or folder.

• symlink – If instead of a copy, a symlink is okay, then this may be set explicitly to “True”.

Raises

OSError – Raised in case src could not be read.

cobbler.utils.filesystem_helpers.copyfileimage(src: str, image_location: str, dst: str) → None

Copy a file from source to the destination in the image.

Parameters

• src – The source file.

• image_location – The location of the image.

• dst – The destination for the file.

cobbler.utils.filesystem_helpers.copyremotefile(src: str, dst1: str, api: Optional[CobblerAPI] = None) → None

Copys a file from a remote place to the local destionation.

Parameters

• src – The remote file URI.

• dst1 – The copy destination on the local filesystem.

• api – This parameter is not used currently.

Raises

OSError – Raised in case an error occurs when fetching or writing the file.

cobbler.utils.filesystem_helpers.create_json_database_dirs(api: CobblerAPI) → None

Creates the database directories for the file serializer

Parameters

api – CobblerAPI

cobbler.utils.filesystem_helpers.create_tftpboot_dirs(api: CobblerAPI) → None

Create directories for tftpboot images

Parameters

api – CobblerAPI

cobbler.utils.filesystem_helpers.create_trigger_dirs(api: CobblerAPI) → None

Creates the directories that the user/admin can fill with dynamically executed scripts.

Parameters

api – CobblerAPI

cobbler.utils.filesystem_helpers.create_web_dirs(api: CobblerAPI) → None

Create directories for HTTP content

Parameters

api – CobblerAPI

cobbler.utils.filesystem_helpers.hashfile(file_name: str, lcache: Optional[Path] = None) → Optional[str]

Returns the sha1sum of the file

Parameters

• file_name – The file to get the sha1sum of.

• lcache – This is a directory where Cobbler would store its link_cache.json file to speed up the return of the hash. The hash looked up would be checked against the Cobbler internal mtime of the object.

Returns

The sha1 sum or None if the file doesn’t exist.

cobbler.utils.filesystem_helpers.is_safe_to_hardlink(src: str, dst: str, api: CobblerAPI) → bool

Determine if it is safe to hardlink a file to the destination path.

Parameters

• src – The hardlink source path.

• dst – The hardlink target path.

• api – The api-instance to resolve needed information with.

Returns

True if selinux is disabled, the file is on the same device, the source in not a link, and it is not a remote path. If selinux is enabled the functions still may return true if the object is a kernel or initrd. Otherwise returns False.

cobbler.utils.filesystem_helpers.linkfile(api: CobblerAPI, src: str, dst: str, symlink_ok: bool = False, cache: bool = True) → None

Attempt to create a link dst that points to src. Because file systems suck we attempt several different methods or bail to just copying the file.

Parameters

• api – This parameter is needed to check if a file can be hardlinked. This method fails if this parameter is not present.

• src – The source file.

• dst – The destination for the link.

• symlink_ok – If it is okay to just use a symbolic link.

• cache – If it is okay to use a cached file instead of the real one.

Raises

CX – Raised in case the API is not given.

cobbler.utils.filesystem_helpers.mkdir(path: str, mode: int = 493) → None

Create directory with a given mode.

Parameters

• path – The path to create the directory at.

• mode – The mode to create the directory with.

Raises

CX – Raised in case creating the directory fails with something different from error code 17 (directory already exists).

cobbler.utils.filesystem_helpers.mkdirimage(path: Path, image_location: str) → None

Create a directory in an image.

Parameters

• path – The path to create the directory at.

• image_location – The location of the image.

cobbler.utils.filesystem_helpers.path_tail(apath: str, bpath: str) → str

Given two paths (B is longer than A), find the part in B not in A

Parameters

• apath – The first path.

• bpath – The second path.

Returns

If the paths are not starting at the same location this function returns an empty string.

cobbler.utils.filesystem_helpers.rmfile(path: str) → None

Delete a single file.

Parameters

path – The file to delete.

cobbler.utils.filesystem_helpers.rmglob_files(path: str, glob_pattern: str) → None

Deletes all files in path with glob_pattern with the help of rmfile().

Parameters

• path – The folder of the files to remove.

• glob_pattern – The glob pattern for the files to remove in path.

cobbler.utils.filesystem_helpers.rmtree(path: str) → None

Delete a complete directory or just a single file.

Parameters

path – The directory or folder to delete.

Raises

CX – Raised in case path does not exist.

cobbler.utils.filesystem_helpers.rmtree_contents(path: str) → None

Delete the content of a folder with a glob pattern.

Parameters

path – This parameter presents the glob pattern of what should be deleted.

cobbler.utils.filesystem_helpers.safe_filter(var: Optional[str]) → None

This function does nothing if the argument does not find any semicolons or two points behind each other.

Parameters

var – This parameter shall not be None or have “..”/”;” at the end.

Raises

CX – In case any .. or / is found in var.

cobbler.utils.filesystem_helpers.sha1_file(file_path: Union[str, Path], buffer_size: int = 65536) → str

This function is emulating the functionality of the sha1sum tool.

Parameters

• file_path – The path to the file that should be hashed.

• buffer_size – The buffer-size that should be used to hash the file.

Returns

The SHA1 hash as sha1sum would return it.

8.1.6.4. cobbler.utils.input_converters module

TODO

cobbler.utils.input_converters.input_boolean(value: Union[str, bool, int]) → bool

Convert a str to a boolean. If this is not possible or the value is false return false.

Parameters

value – The value to convert to boolean.

Returns

True if the value is in the following list, otherwise false: “true”, “1”, “on”, “yes”, “y” .

cobbler.utils.input_converters.input_int(value: Union[str, int, float]) → int

Convert a value to integer.

Parameters

value – The value to convert.

Raises

TypeError – In case after the attempted conversion we still don’t have an int.

Returns

The integer if the conversion was successful.

cobbler.utils.input_converters.input_string_or_dict(options: Union[str, List[Any], Dict[Any, Any]], allow_multiples: bool = True) → Union[str, Dict[Any, Any]]

Older Cobbler files stored configurations in a flat way, such that all values for strings. Newer versions of Cobbler allow dictionaries. This function is used to allow loading of older value formats so new users of Cobbler aren’t broken in an upgrade.

Parameters

• options – The str or dict to convert.

• allow_multiples – True (default) to allow multiple identical keys, otherwise set this false explicitly.

Returns

A dict or the value <<inherit>> in case it is the only content of options.

Raises

TypeError – Raised in case the input type is wrong.

cobbler.utils.input_converters.input_string_or_dict_no_inherit(options: Union[str, List[Any], Dict[Any, Any]], allow_multiples: bool = True) → Dict[Any, Any]

See input_string_or_dict()

cobbler.utils.input_converters.input_string_or_list(options: Optional[Union[str, List[Any]]]) → Union[List[Any], str]

Accepts a delimited list of stuff or a list, but always returns a list.

Parameters

options – The object to split into a list.

Returns

str when this functions get’s passed <<inherit>>. if option is delete then an empty list is returned. Otherwise, this function tries to return the arg option or tries to split it into a list.

Raises

TypeError – In case the type of options was neither None, str or list.

cobbler.utils.input_converters.input_string_or_list_no_inherit(options: Optional[Union[str, List[Any]]]) → List[Any]

Accepts a delimited list of stuff or a list, but always returns a list.

Parameters

options – The object to split into a list.

Returns

If option is delete, None (object not literal) or an empty str, then an empty list is returned. Otherwise, this function tries to return the arg option or tries to split it into a list.

Raises

TypeError – In case the type of options was neither None, str or list.

8.1.6.5. cobbler.utils.mtab module

We cache the contents of /etc/mtab. The following module is used to keep our cache in sync.

class cobbler.utils.mtab.MntEntObj(input_data: Optional[str] = None)

Bases: object

TODO

mnt_dir = None

mnt_freq = 0

mnt_fsname = None

mnt_opts = None

mnt_passno = 0

mnt_type = None

cobbler.utils.mtab.get_file_device_path(fname: str) → Tuple[Optional[str], str]

What this function attempts to do is take a file and return:

• the device the file is on

• the path of the file relative to the device.

For example:

/boot/vmlinuz -> (/dev/sda3, /vmlinuz) /boot/efi/efi/redhat/elilo.conf -> (/dev/cciss0, /elilo.conf) /etc/fstab -> (/dev/sda4, /etc/fstab)

Parameters

fname – The filename to split up.

Returns

A tuple containing the device and relative filename.

cobbler.utils.mtab.get_mtab(mtab: str = '/etc/mtab', vfstype: bool = False) → List[MntEntObj]

Get the list of mtab entries. If a custom mtab should be read then the location can be overridden via a parameter.

Parameters

• mtab – The location of the mtab. Argument can be omitted if the mtab is at its default location.

• vfstype – If this is True, then all filesystems which are nfs are returned. Otherwise this returns all mtab entries.

Returns

The list of requested mtab entries.

cobbler.utils.mtab.is_remote_file(file: str) → bool

This function is trying to detect if the file in the argument is remote or not.

Parameters

file – The filepath to check.

Returns

If remote True, otherwise False.

8.1.6.6. cobbler.utils.process_management module

TODO

cobbler.utils.process_management.is_service() → bool

Return whether this system uses service.

This method currently checks if the path /usr/sbin/service exists.

cobbler.utils.process_management.is_supervisord() → bool

Return whether this system uses supervisord.

This method currently checks if there is a running supervisord instance on localhost.

cobbler.utils.process_management.is_systemd() → bool

Return whether this system uses systemd.

This method currently checks if the path /usr/lib/systemd/systemd exists.

cobbler.utils.process_management.service_restart(service_name: str) → int

Restarts a daemon service independent of the underlining process manager. Currently, supervisord, systemd and SysV are supported. Checks which manager is present is done in the order just described.

Parameters

service_name – The name of the service

Returns

If the system is SystemD or SysV based the return code of the restart command.

8.1.6.7. cobbler.utils.signatures module

TODO

cobbler.utils.signatures.get_supported_distro_boot_loaders(item: Union[Distro, Image], api_handle: Optional[CobblerAPI] = None) → List[str]

This is trying to return you the list of known bootloaders if all resorts fail. Otherwise this returns a list which contains only the subset of bootloaders which are available by the distro in the argument.

Parameters

• distro – The distro to check for.

• api_handle – The api instance to resolve metadata and settings from.

Returns

The list of bootloaders or a dict of well known bootloaders.

cobbler.utils.signatures.get_valid_archs() → List[str]

Return a list of valid architectures found in the import signatures

Returns

All architectures which are known to Cobbler according to the signature cache.

cobbler.utils.signatures.get_valid_breeds() → List[str]

Return a list of valid breeds found in the import signatures

cobbler.utils.signatures.get_valid_os_versions() → List[str]

Return a list of valid os-versions found in the import signatures

Returns

All operating system versions which are known to Cobbler according to the signature cache.

cobbler.utils.signatures.get_valid_os_versions_for_breed(breed: str) → List[str]

Return a list of valid os-versions for the given breed

Parameters

breed – The operating system breed to check for.

Returns

All operating system version which are known to Cobbler according to the signature cache filtered by a os-breed.

cobbler.utils.signatures.load_signatures(filename: str, cache: bool = True) → None

Loads the import signatures for distros.

Parameters

• filename – Loads the file with the given name.

• cache – If the cache should be set with the newly read data.

8.1.6.8. cobbler.utils.thread module

This module is responsible for managing the custom common threading logic Cobbler has.

class cobbler.utils.thread.CobblerThread(event_id: str, remote: CobblerXMLRPCInterface, options: Optional[Union[List[str], Dict[str, Any]]], task_name: str, api: CobblerAPI, run: Callable[[CobblerThread], None], on_done: Optional[Callable[[CobblerThread], None]] = None)

Bases: Thread

This is a custom thread that has a custom logger as well as logic to execute Cobbler triggers.

run() → None

Run the thread.

Returns

The return code of the action. This may a boolean or a Linux return code.

8.1.6.9. Module contents

Misc heavy lifting functions for Cobbler

cobbler.utils.blender(api_handle: CobblerAPI, remove_dicts: bool, root_obj: ITEM_UNION) → Dict[str, Any]

Combine all of the data in an object tree from the perspective of that point on the tree, and produce a merged dictionary containing consolidated data.

Parameters

• api_handle – The api to use for collecting the information to blender the item.

• remove_dicts – Boolean to decide whether dicts should be converted.

• root_obj – The object which should act as the root-node object.

Returns

A dictionary with all the information from the root node downwards.

cobbler.utils.cheetah_exc(exc: Exception) → str

Converts an exception thrown by Cheetah3 into a custom error message.

Parameters

exc – The exception to convert.

Returns

The string representation of the Cheetah3 exception.

cobbler.utils.command_existing(cmd: str) → bool

This takes a command which should be known to the system and checks if it is available.

Parameters

cmd – The executable to check

Returns

If the binary does not exist False, otherwise True.

cobbler.utils.compare_versions_gt(ver1: str, ver2: str) → bool

Compares versions like “0.9.3” with each other and decides if ver1 is greater than ver2.

Parameters

• ver1 – The first version.

• ver2 – The second version.

Returns

True if ver1 is greater, otherwise False.

cobbler.utils.dhcp_service_name() → str

Determine the dhcp service which is different on various distros. This is currently a hardcoded detection.

Returns

This will return one of the following names: “dhcp3-server”, “isc-dhcp-server”, “dhcpd”

cobbler.utils.dhcpconf_location(protocol: DHCP, filename: str = 'dhcpd.conf') → str

This method returns the location of the dhcpd.conf file.

Parameters

• protocol – The DHCP protocol version (v4/v6) that is used.

• filename – The filename of the DHCP configuration file.

Raises

AttributeError – If the protocol is not v4/v6.

Returns

The path possibly used for the dhcpd.conf file.

cobbler.utils.dict_annihilate(dictionary: Dict[Any, Any]) → None

Annihilate entries marked for removal. This method removes all entries with key names starting with “!”. If a dictionary contains keys “!xxx” and “xxx”, then both will be removed.

Parameters

dictionary – A dictionary to clean up.

cobbler.utils.dict_removals(results: Dict[Any, Any], subkey: str) → None

Remove entries from a dictionary starting with a “!”.

Parameters

• results – The dictionary to search in

• subkey – The subkey to search through.

cobbler.utils.dict_to_string(_dict: Dict[Any, Any]) → Union[str, Dict[Any, Any]]

Convert a dictionary to a printable string. Used primarily in the kernel options string and for some legacy stuff where koan expects strings (though this last part should be changed to dictionaries)

A KV-Pair is joined with a “=”. Values are enclosed in single quotes.

Parameters

_dict – The dictionary to convert to a string.

Returns

The string which was previously a dictionary.

cobbler.utils.die(msg: str) → None

This method let’s Cobbler crash with an exception. Log the exception once in the per-task log or the main log if this is not a background op.

Parameters

msg – The message to send for raising the exception

Raises

CX – Raised in all cases with msg.

cobbler.utils.file_is_remote(file_location: str) → bool

Returns true if the file is remote and referenced via a protocol we support.

Parameters

file_location – The URI to check.

Returns

True if the URI is http, https or ftp. Otherwise false.

cobbler.utils.find_highest_files(directory: str, unversioned: str, regex: Pattern[str]) → str

Find the highest numbered file (kernel or initrd numbering scheme) in a given directory that matches a given pattern. Used for auto-booting the latest kernel in a directory.

Parameters

• directory – The directory to search in.

• unversioned – The base filename which also acts as a last resort if no numbered files are found.

• regex – The regex to search for.

Returns

The file with the highest number or an empty string.

cobbler.utils.find_initrd(path: str) → Optional[str]

Given a directory or a filename, see if the path can be made to resolve into an intird, return that full path if possible.

Parameters

path – The path to check for initrd files.

Returns

None or the path to the found initrd.

cobbler.utils.find_kernel(path: str) → str

Given a filename, find if the path can be made to resolve into a kernel, and return that full path if possible.

Parameters

path – The path to check for a kernel.

Returns

path if at the specified location a possible match for a kernel was found, otherwise an empty string.

cobbler.utils.find_matching_files(directory: str, regex: Pattern[str]) → List[str]

Find all files in a given directory that match a given regex. Can’t use glob directly as glob doesn’t take regexen. The search does not include subdirectories.

Parameters

• directory – The directory to search in.

• regex – The regex to apply to the found files.

Returns

An array of files which apply to the regex.

cobbler.utils.flatten(data: Dict[str, Any]) → Optional[Dict[str, Any]]

Convert certain nested dicts to strings. This is only really done for the ones koan needs as strings this should not be done for everything

Parameters

data – The dictionary in which various keys should be converted into a string.

Returns

None (if data is None) or the flattened string.

cobbler.utils.get_exc(exc: Exception, full: bool = True) → str

This tries to analyze if an exception comes from Cobbler and potentially enriches or shortens the exception.

Parameters

• exc – The exception which should be analyzed.

• full – If the full exception should be returned or only the most important information.

Returns

The exception which has been converted into a string which then can be logged easily.

cobbler.utils.get_family() → str

Get family of running operating system.

Family is the base Linux distribution of a Linux distribution, with a set of common parents.

Returns

May be “redhat”, “debian” or “suse” currently. If none of these are detected then just the distro name is returned.

cobbler.utils.get_host_ip(ip_address: str, shorten: bool = True) → str

Return the IP encoding needed for the TFTP boot tree.

Parameters

• ip_address – The IP address to pretty print.

• shorten – Whether the IP-Address should be shortened or not.

Returns

The IP encoded as a hexadecimal value.

cobbler.utils.get_random_mac(api_handle: CobblerAPI, virt_type: str = 'xenpv') → str

Generate a random MAC address.

The code of this method was taken from xend/server/netif.py

Parameters

• api_handle – The main Cobbler api instance.

• virt_type – The virtualization provider. Currently possible is ‘vmware’, ‘xen’, ‘qemu’, ‘kvm’.

Returns

MAC address string

Raises

CX – Raised in case unsupported virt_type given.

cobbler.utils.get_shared_secret() → Union[str, int]

The ‘web.ss’ file is regenerated each time cobblerd restarts and is used to agree on shared secret interchange between the web server and cobblerd, and also the CLI and cobblerd, when username/password access is not required. For the CLI, this enables root users to avoid entering username/pass if on the Cobbler server.

Returns

The Cobbler secret which enables full access to Cobbler.

cobbler.utils.get_supported_system_boot_loaders() → List[str]

Return the list of currently supported bootloaders.

Returns

The list of currently supported bootloaders.

cobbler.utils.is_ip(strdata: str) → bool

Return whether the argument is an IP address.

Parameters

strdata – The IP in a string format. This get’s passed to the IP object of Python.

cobbler.utils.is_selinux_enabled() → bool

This check is achieved via a subprocess call to selinuxenabled. Default return is false.

Returns

Whether selinux is enabled or not.

cobbler.utils.is_str_float(value: str) → bool

Checks if the string value could be converted into a float. This is necessary since the CLI only works with strings but many methods and checks expects a float.

Parameters

value – The value to check

Returns

True if conversion is successful

cobbler.utils.is_str_int(value: str) → bool

Checks if the string value could be converted into an integer. This is necessary since the CLI only works with strings but many methods and checks expects an integer.

Parameters

value – The value to check

Returns

True if conversion is successful

cobbler.utils.kopts_overwrite(kopts: Dict[Any, Any], cobbler_server_hostname: str = '', distro_breed: str = '', system_name: str = '') → None

SUSE is not using ‘text’. Instead ‘textmode’ is used as kernel option.

Parameters

• kopts – The kopts of the system.

• cobbler_server_hostname – The server setting from our Settings.

• distro_breed – The distro for the system to change to kopts for.

• system_name – The system to overwrite the kopts for.

cobbler.utils.local_get_cobbler_api_url() → str

Get the URL of the Cobbler HTTP API from the Cobbler settings file.

Returns

The api entry point. This does not respect modifications from Loadbalancers or API-Gateways.

cobbler.utils.local_get_cobbler_xmlrpc_url() → str

Get the URL of the Cobbler XMLRPC API from the Cobbler settings file.

Returns

The api entry point.

cobbler.utils.lod_sort_by_key(list_to_sort: List[Any], indexkey: Hashable) → List[Any]

Sorts a list of dictionaries by a given key in the dictionaries.

Note: This is a destructive operation and does not sort the dictionaries.

Parameters

• list_to_sort – The list of dictionaries to sort.

• indexkey – The key to index to dicts in the list.

Returns

The sorted list.

cobbler.utils.lod_to_dod(_list: List[Any], indexkey: Hashable) → Dict[Any, Any]

Things like get_distros() returns a list of a dictionaries. Convert this to a dict of dicts keyed off of an arbitrary field.

Example: [ { "a" : 2 }, { "a" : 3 } ] -> { "2" : { "a" : 2 }, "3" : { "a" : "3" } }

Parameters

• _list – The list of dictionaries to use for the conversion.

• indexkey – The position to use as dictionary keys.

Returns

The converted dictionary. It is not guaranteed that the same key is not used multiple times.

cobbler.utils.log_exc() → None

Log an exception.

cobbler.utils.named_service_name() → str

Determine the named service which is normally different on various distros.

Returns

This will return for debian/ubuntu bind9 and on other distros named-chroot or named.

cobbler.utils.namedconf_location() → str

This returns the location of the named.conf file.

Returns

If the distro is Debian/Ubuntu then this returns “/etc/bind/named.conf”. Otherwise “/etc/named.conf”

cobbler.utils.os_release() → Tuple[str, float]

Get the os version of the linux distro. If the get_family() method succeeds then the result is normalized.

Returns

The os-name and os version.

cobbler.utils.pretty_hex(ip_address: IPAddress, length: int = 8) → str

Pads an IP object with leading zeroes so that the result is _length_ hex digits. Also do an upper().

Parameters

• ip_address – The IP address to pretty print.

• length – The length of the resulting hexstring. If the number is smaller than the resulting hex-string then no front-padding is done.

cobbler.utils.read_file_contents(file_location: str, fetch_if_remote: bool = False) → Optional[str]

Reads the contents of a file, which could be referenced locally or as a URI.

Parameters

• file_location – The location of the file to read.

• fetch_if_remote – If True a remote file will be tried to read, otherwise remote files are skipped and None is returned.

Returns

Returns None if file is remote and templating of remote files is disabled.

Raises

FileNotFoundError – if the file does not exist at the specified location.

cobbler.utils.remote_file_exists(file_url: str) → bool

Return True if the remote file exists.

Parameters

file_url – The URL to check.

Returns

True if Cobbler can reach the specified URL, otherwise false.

cobbler.utils.remove_yum_olddata(path: Union[str, os.PathLike[str]]) → None

Delete .olddata folders that might be present from a failed run of createrepo.

Parameters

path – The path to check for .olddata files.

cobbler.utils.revert_strip_none(data: Union[str, int, float, bool, List[Any], Dict[Any, Any]]) → Optional[Union[str, int, float, bool, List[Any], Dict[Any, Any]]]

Does the opposite to strip_none. If a value which represents None is detected, it replaces it with None.

Parameters

data – The data to check.

Returns

The data without None.

cobbler.utils.rsync_files(src: str, dst: str, args: str, quiet: bool = True) → bool

Sync files from src to dst. The extra arguments specified by args are appended to the command.

Parameters

• src – The source for the copy process.

• dst – The destination for the copy process.

• args – The extra arguments are appended to our standard arguments.

• quiet – If True no progress is reported. If False then progress will be reported by rsync.

Returns

True on success, otherwise False.

cobbler.utils.run_triggers(api: CobblerAPI, ref: Optional[Item] = None, globber: str = '', additional: Optional[List[Any]] = None) → None

Runs all the trigger scripts in a given directory. Example: /var/lib/cobbler/triggers/blah/*

As of Cobbler 1.5.X, this also runs Cobbler modules that match the globbing paths.

Python triggers are always run before shell triggers.

Parameters

• api – The api object to use for resolving the actions.

• ref – Can be a Cobbler object, if not None, the name will be passed to the script. If ref is None, the script will be called with no arguments.

• globber – is a wildcard expression indicating which triggers to run.

• additional – Additional arguments to run the triggers with.

Raises

CX – Raised in case the trigger failed.

cobbler.utils.strip_none(data: Optional[Union[List[Any], Dict[Any, Any], int, str, float]], omit_none: bool = False) → Union[List[Any], Dict[Any, Any], int, str, float]

Remove “None” entries from datastructures. Used prior to communicating with XMLRPC.

Parameters

• data – The data to strip None away.

• omit_none – If the datastructure is not a single item then None items will be skipped instead of replaced if set to “True”.

Returns

The modified data structure without any occurrence of None.

cobbler.utils.subprocess_call(cmd: Union[str, List[str]], shell: bool = False, process_input: Optional[Any] = None) → int

A simple subprocess call with no output capturing.

Parameters

• cmd – The command to execute.

• shell – Whether to use a shell or not for the execution of the command.

• process_input – If there is any process_input needed for that command to stdin.

Returns

The return code of the process

cobbler.utils.subprocess_get(cmd: Union[str, List[str]], shell: bool = True, process_input: Optional[Any] = None) → str

A simple subprocess call with no return code capturing.

Parameters

• cmd – The command to execute.

• shell – Whether to use a shell or not for the execution of the command.

• process_input – If there is any process_input needed for that command to stdin.

Returns

The data which the subprocess returns.

cobbler.utils.subprocess_sp(cmd: Union[str, List[str]], shell: bool = True, process_input: Optional[Any] = None) → Tuple[str, int]

Call a shell process and redirect the output for internal usage.

Parameters

• cmd – The command to execute in a subprocess call.

• shell – Whether to use a shell or not for the execution of the command.

• process_input – If there is any input needed for that command to stdin.

Returns

A tuple of the output and the return code.

cobbler.utils.uniquify(seq: List[Any]) → List[Any]

Remove duplicates from the sequence handed over in the args.

Parameters

seq – The sequence to check for duplicates.

Returns

The list without duplicates.