def test_has_option_in_help_command_failure_exception(self, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.has_option_in_help('command_that_fails',
'--non-existing-flag')
def test_has_option_in_help(self, mock_run):
command_type = namedtuple('command', ['output', 'error'])
mock_run.return_value = command_type(
output="Dummy line\n\t--some-flag\n\t--some-other-flag",
error="Dummy line\n\t--error-flag\n\t--some-other-flag"
)
assert CommandCapabilities.has_option_in_help('command', '--some-flag')
assert CommandCapabilities.has_option_in_help('command', '--error-flag')
assert CommandCapabilities.has_option_in_help(
'command', '--some-flag', help_flags=['subcommand', '-h']
)
assert CommandCapabilities.has_option_in_help(
'command', '--some-other-flag',
help_flags=['subcommand', '-h'], root='root_dir'
)
assert not CommandCapabilities.has_option_in_help(
'command', '--non-existing-flag'
)
mock_run.assert_has_calls([
call(['command', '--help']),
call(['command', '--help']),
call(['command', 'subcommand', '-h']),
call(['chroot', 'root_dir', 'command', 'subcommand', '-h']),
call(['command', '--help'])
])
def test_check_version_failure_exception(self, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.check_version('command_that_fails',
'--non-existing-flag')
def test_check_version_failure_warning(self, mock_warn, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.check_version('command_that_fails', (1, 2),
raise_on_error=False)
assert mock_warn.called
def test_check_version_failure_warning(self, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
with self._caplog.at_level(logging.WARNING):
CommandCapabilities.check_version('command_that_fails', (1, 2),
raise_on_error=False)
def test_check_version_failure_exception(self, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.check_version(
'command_that_fails', '--non-existing-flag'
)
def test_has_option_in_help_command_failure_exception(self, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.has_option_in_help(
'command_that_fails', '--non-existing-flag'
)
def test_check_version_failure_warning(self, mock_warn, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.check_version(
'command_that_fails', (1, 2), raise_on_error=False
)
assert mock_warn.called
def test_has_option_in_help_command_failure_warning(self, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
with self._caplog.at_level(logging.WARNING):
CommandCapabilities.has_option_in_help('command_that_fails',
'--non-existing-flag',
raise_on_error=False)
def test_has_option_in_help_command_failure_warning(
self, mock_warn, mock_run):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.has_option_in_help('command_that_fails',
'--non-existing-flag',
raise_on_error=False)
assert mock_warn.called
def test_has_option_in_help_command_failure_warning(
self, mock_warn, mock_run
):
def side_effect():
raise Exception("Something went wrong")
mock_run.side_effect = side_effect
CommandCapabilities.has_option_in_help(
'command_that_fails', '--non-existing-flag', raise_on_error=False
)
assert mock_warn.called
def setup_keyboard_map(self):
"""
Setup console keyboard
"""
if 'keytable' in self.preferences:
log.info('Setting up keytable: {0}'.format(
self.preferences['keytable']))
if CommandCapabilities.has_option_in_help('systemd-firstboot',
'--keymap',
root=self.root_dir,
raise_on_error=False):
Path.wipe(self.root_dir + '/etc/vconsole.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--keymap=' + self.preferences['keytable']
])
elif os.path.exists(self.root_dir + '/etc/sysconfig/keyboard'):
Shell.run_common_function('baseUpdateSysConfig', [
self.root_dir + '/etc/sysconfig/keyboard', 'KEYTABLE',
'"' + self.preferences['keytable'] + '"'
])
else:
log.warning(
'keyboard setup skipped no capable '
'systemd-firstboot or etc/sysconfig/keyboard found')
def setup_locale(self):
"""
Setup UTF8 system wide locale
"""
if 'locale' in self.preferences:
if 'POSIX' in self.preferences['locale'].split(','):
locale = 'POSIX'
else:
locale = '{0}.UTF-8'.format(
self.preferences['locale'].split(',')[0])
log.info('Setting up locale: %s', self.preferences['locale'])
if CommandCapabilities.has_option_in_help('systemd-firstboot',
'--locale',
root=self.root_dir,
raise_on_error=False):
Path.wipe(self.root_dir + '/etc/locale.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--locale=' + locale
])
if os.path.exists(self.root_dir + '/etc/sysconfig/language'):
Shell.run_common_function('baseUpdateSysConfig', [
self.root_dir + '/etc/sysconfig/language', 'RC_LANG',
locale
])
def setup_locale(self):
"""
Setup UTF8 system wide locale
"""
if 'locale' in self.preferences:
if 'POSIX' in self.preferences['locale'].split(','):
locale = 'POSIX'
else:
locale = '{0}.UTF-8'.format(
self.preferences['locale'].split(',')[0]
)
log.info('Setting up locale: %s', self.preferences['locale'])
if CommandCapabilities.has_option_in_help(
'systemd-firstboot', '--locale',
root=self.root_dir, raise_on_error=False
):
Path.wipe(self.root_dir + '/etc/locale.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--locale=' + locale
])
elif os.path.exists(self.root_dir + '/etc/sysconfig/language'):
Shell.run_common_function(
'baseUpdateSysConfig', [
self.root_dir + '/etc/sysconfig/language',
'RC_LANG', locale
]
)
else:
log.warning(
'locale setup skipped no capable '
'systemd-firstboot or etc/sysconfig/language not found'
)
def add_efi_loader_parameters(self):
"""
Add ISO creation parameters to embed the EFI loader
In order to boot the ISO from EFI, the EFI binary is added as
alternative loader to the ISO creation parameter list. The
EFI binary must be included into a fat filesystem in order
to become recognized by the firmware. For details about this
file refer to _create_embedded_fat_efi_image() from
bootloader/config/grub2.py
"""
loader_file = self.boot_path + '/efi'
if os.path.exists(os.sep.join([self.source_dir, loader_file])):
self.iso_loaders.append('-eltorito-alt-boot')
iso_tool = self.get_tool_name()
if iso_tool and CommandCapabilities.has_option_in_help(
iso_tool, '-eltorito-platform', raise_on_error=False
):
self.iso_loaders += ['-eltorito-platform', 'efi']
self.iso_loaders += [
'-b', loader_file, '-no-emul-boot', '-joliet-long'
]
loader_file_512_byte_blocks = os.path.getsize(
os.sep.join([self.source_dir, loader_file])
) / 512
# boot-load-size is stored in a 16bit range, thus we only
# set the value if it fits into that range
if loader_file_512_byte_blocks <= 0xffff:
self.iso_loaders.append(
'-boot-load-size'
)
self.iso_loaders.append(
format(int(loader_file_512_byte_blocks))
)
def add_efi_loader_parameters(self):
"""
Add ISO creation parameters to embed the EFI loader
In order to boot the ISO from EFI, the EFI binary is added as
alternative loader to the ISO creation parameter list. The
EFI binary must be included into a fat filesystem in order
to become recognized by the firmware. For details about this
file refer to _create_embedded_fat_efi_image() from
bootloader/config/grub2.py
"""
loader_file = self.boot_path + '/efi'
if os.path.exists(os.sep.join([self.source_dir, loader_file])):
self.iso_loaders.append('-eltorito-alt-boot')
iso_tool = self.get_tool_name()
if iso_tool and CommandCapabilities.has_option_in_help(
iso_tool, '-eltorito-platform', raise_on_error=False):
self.iso_loaders += ['-eltorito-platform', 'efi']
self.iso_loaders += [
'-b', loader_file, '-no-emul-boot', '-joliet-long'
]
loader_file_512_byte_blocks = os.path.getsize(
os.sep.join([self.source_dir, loader_file])) / 512
# boot-load-size is stored in a 16bit range, thus we only
# set the value if it fits into that range
if loader_file_512_byte_blocks <= 0xffff:
self.iso_loaders.append('-boot-load-size')
self.iso_loaders.append(
format(int(loader_file_512_byte_blocks)))
def setup_keyboard_map(self):
"""
Setup console keyboard
"""
if 'keytable' in self.preferences:
log.info(
'Setting up keytable: %s', self.preferences['keytable']
)
if CommandCapabilities.has_option_in_help(
'systemd-firstboot', '--keymap',
root=self.root_dir, raise_on_error=False
):
Path.wipe(self.root_dir + '/etc/vconsole.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--keymap=' + self.preferences['keytable']
])
elif os.path.exists(self.root_dir + '/etc/sysconfig/keyboard'):
Shell.run_common_function(
'baseUpdateSysConfig', [
self.root_dir + '/etc/sysconfig/keyboard', 'KEYTABLE',
'"' + self.preferences['keytable'] + '"'
]
)
else:
log.warning(
'keyboard setup skipped no capable '
'systemd-firstboot or etc/sysconfig/keyboard found'
)
def __init__(self, filename, create_from_file_list=True, file_list=None):
self.filename = filename
self.create_from_file_list = create_from_file_list
self.file_list = file_list
if CommandCapabilities.check_version('tar', (1, 27)):
self.xattrs_options = ['--xattrs', '--xattrs-include=*']
else:
self.xattrs_options = []
def test_check_version(self, mock_run):
command_type = namedtuple('command', ['output'])
mock_run.return_value = command_type(
output="Dummy line\ncommand v1.2.3\n")
assert CommandCapabilities.check_version('command', (1, 2, 3))
assert CommandCapabilities.check_version('command', (1, 1, 3))
assert not CommandCapabilities.check_version('command', (1, 3))
assert CommandCapabilities.check_version('command', (1, 2, 3),
version_flags=['-v'])
assert CommandCapabilities.check_version('command', (1, 2, 3),
version_flags=['-v'],
root='root_dir')
mock_run.assert_has_calls([
call(['command', '--version']),
call(['command', '--version']),
call(['command', '--version']),
call(['command', '-v']),
call(['chroot', 'root_dir', 'command', '-v'])
])
def __init__(self, filename, create_from_file_list=True, file_list=None):
self.filename = filename
self.create_from_file_list = create_from_file_list
self.file_list = file_list
if CommandCapabilities.check_version('tar', (1, 27)):
self.xattrs_options = [
'--xattrs', '--xattrs-include=*'
]
else:
self.xattrs_options = []
def post_init(self):
"""
Initializes some umoci parameters and options
"""
self.container_name = ':'.join(
[self.container_dir, self.container_tag])
if CommandCapabilities.has_option_in_help('umoci', '--no-history',
['repack', '--help']):
self.no_history_flag = ['--no-history']
else:
self.no_history_flag = []
def test_has_option_in_help(self, mock_run):
command_type = namedtuple('command', ['output'])
mock_run.return_value = command_type(
output="Dummy line\n\t--some-flag\n\t--some-other-flag")
assert CommandCapabilities.has_option_in_help('command', '--some-flag')
assert CommandCapabilities.has_option_in_help(
'command', '--some-flag', help_flags=['subcommand', '-h'])
assert CommandCapabilities.has_option_in_help(
'command',
'--some-other-flag',
help_flags=['subcommand', '-h'],
root='root_dir')
assert not CommandCapabilities.has_option_in_help(
'command', '--non-existing-flag')
mock_run.assert_has_calls([
call(['command', '--help']),
call(['command', 'subcommand', '-h']),
call(['chroot', 'root_dir', 'command', 'subcommand', '-h']),
call(['command', '--help'])
])
def test_check_version(self, mock_run):
command_type = namedtuple('command', ['output'])
mock_run.return_value = command_type(
output="Dummy line\ncommand v1.2.3\n"
)
assert CommandCapabilities.check_version('command', (1, 2, 3))
assert CommandCapabilities.check_version('command', (1, 1, 3))
assert not CommandCapabilities.check_version('command', (1, 3))
assert CommandCapabilities.check_version(
'command', (1, 2, 3), version_flags=['-v']
)
assert CommandCapabilities.check_version(
'command', (1, 2, 3), version_flags=['-v'], root='root_dir'
)
mock_run.assert_has_calls([
call(['command', '--version']),
call(['command', '--version']),
call(['command', '--version']),
call(['command', '-v']),
call(['chroot', 'root_dir', 'command', '-v'])
])
def check_container_tool_chain_installed(self) -> None:
"""
When creating container images the specific tools are used in order
to import and export OCI or Docker compatible images. This check
searches for those tools to be installed in the build system and
fails if it can't find them
"""
message_tool_not_found = dedent('''\n
Required tool {name} not found in caller environment
Creation of OCI or Docker images requires the tools {name} and
skopeo to be installed on the build system. For SUSE based systems
you can find the tools at:
http://download.opensuse.org/repositories/Virtualization:/containers
''')
message_version_unsupported = dedent('''\n
{name} tool found with unknown version
''')
message_unknown_tool = dedent('''\n
Unknown tool: {0}.
Please configure KIWI with an appropriate value (umoci or buildah).
Consider this runtime configuration file syntax (/etc/kiwi.yml):
oci:
- archive_tool: umoci | buildah
''')
expected_version = (0, 1, 0)
if self.xml_state.get_build_type_name() in ['docker', 'oci']:
runtime_config = RuntimeConfig()
tool_name = runtime_config.get_oci_archive_tool()
if tool_name == 'buildah':
oci_tools = ['buildah', 'skopeo']
elif tool_name == 'umoci':
oci_tools = ['umoci', 'skopeo']
else:
raise KiwiRuntimeError(message_unknown_tool.format(tool_name))
for tool in oci_tools:
if not Path.which(filename=tool, access_mode=os.X_OK):
raise KiwiRuntimeError(
message_tool_not_found.format(name=tool)
)
elif not CommandCapabilities.check_version(
tool, expected_version, raise_on_error=False
):
raise KiwiRuntimeError(
message_version_unsupported.format(name=tool)
)
self._check_multitag_support()
def post_init(self):
"""
Initializes some umoci parameters and options
"""
self.oci_dir = mkdtemp(prefix='kiwi_oci_dir.')
self.container_dir = os.sep.join([self.oci_dir, 'oci_layout'])
self.working_image = '{0}:{1}'.format(
self.container_dir, Defaults.get_container_base_image_tag())
if CommandCapabilities.has_option_in_help('umoci', '--no-history',
['config', '--help']):
self.no_history_flag = ['--no-history']
else:
self.no_history_flag = []
def _check_multitag_support(self) -> None:
message = dedent('''\n
Using additionaltags attribute requires skopeo tool to be
capable to handle it, it must include the '--additional-tag'
option for copy subcommand (check it running 'skopeo copy
--help').\n
It is known to be present since v0.1.30
''')
if 'additional_names' in self.xml_state.get_container_config():
if not CommandCapabilities.has_option_in_help(
'skopeo', '--additional-tag', ['copy', '--help'],
raise_on_error=False
):
raise KiwiRuntimeError(message)
def create_image_format(self):
"""
Create ova disk format using ovftool from
https://www.vmware.com/support/developer/ovf
"""
# Check for required ovftool
ovftool = Path.which(filename='ovftool', access_mode=os.X_OK)
if not ovftool:
tool_not_found_message = dedent('''\n
Required tool {0} not found in PATH on the build host
Building OVA images requires VMware's {0} tool which
can be installed from the following location
https://www.vmware.com/support/developer/ovf
''')
raise KiwiCommandNotFound(
tool_not_found_message.format(ovftool)
)
# Create the vmdk disk image and vmx config
super(DiskFormatOva, self).create_image_format()
# Convert to ova using ovftool
vmx = self.get_target_file_path_for_format('vmx')
ova = self.get_target_file_path_for_format('ova')
try:
os.unlink(ova)
except OSError:
pass
ovftool_options = []
if CommandCapabilities.has_option_in_help(
ovftool, '--shaAlgorithm', raise_on_error=False
):
ovftool_options.append('--shaAlgorithm=SHA1')
Command.run(
[ovftool] + ovftool_options + [vmx, ova]
)
# ovftool ignores the umask and creates files with 0600
# apply file permission bits set in the vmx file to the
# ova file
st = os.stat(vmx)
os.chmod(ova, stat.S_IMODE(st.st_mode))
def create_image_format(self):
"""
Create ova disk format using ovftool from
https://www.vmware.com/support/developer/ovf
"""
# Check for required ovftool
ovftool = Path.which(filename='ovftool', access_mode=os.X_OK)
if not ovftool:
tool_not_found_message = dedent('''\n
Required tool {0} not found in PATH on the build host
Building OVA images requires VMware's {0} tool which
can be installed from the following location
https://www.vmware.com/support/developer/ovf
''')
raise KiwiCommandNotFound(
tool_not_found_message.format(ovftool)
)
# Create the vmdk disk image and vmx config
self.vmdk.create_image_format()
# Convert to ova using ovftool
vmx = self.get_target_file_path_for_format('vmx')
ova = self.get_target_file_path_for_format('ova')
try:
os.unlink(ova)
except OSError:
pass
ovftool_options = []
if CommandCapabilities.has_option_in_help(
ovftool, '--shaAlgorithm', raise_on_error=False
):
ovftool_options.append('--shaAlgorithm=SHA1')
Command.run(
[ovftool] + ovftool_options + [vmx, ova]
)
# ovftool ignores the umask and creates files with 0600
# apply file permission bits set in the vmx file to the
# ova file
st = os.stat(vmx)
os.chmod(ova, stat.S_IMODE(st.st_mode))
def setup_timezone(self):
"""
Setup timezone symlink
"""
if 'timezone' in self.preferences:
log.info('Setting up timezone: %s', self.preferences['timezone'])
if CommandCapabilities.has_option_in_help('systemd-firstboot',
'--timezone',
root=self.root_dir,
raise_on_error=False):
Path.wipe(self.root_dir + '/etc/localtime')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--timezone=' + self.preferences['timezone']
])
else:
zoneinfo = '/usr/share/zoneinfo/' + self.preferences['timezone']
Command.run([
'chroot', self.root_dir, 'ln', '-s', '-f', zoneinfo,
'/etc/localtime'
])
def setup_locale(self):
"""
Setup UTF8 system wide locale
"""
if 'locale' in self.preferences:
if 'POSIX' in self.preferences['locale'].split(','):
locale = 'POSIX'
else:
locale = '{0}.UTF-8'.format(
self.preferences['locale'].split(',')[0])
log.info('Setting up locale: {0}'.format(
self.preferences['locale']))
if CommandCapabilities.has_option_in_help('systemd-firstboot',
'--locale',
root=self.root_dir,
raise_on_error=False):
Path.wipe(self.root_dir + '/etc/locale.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--locale=' + locale
])
def setup_timezone(self):
"""
Setup timezone symlink
"""
if 'timezone' in self.preferences:
log.info(
'Setting up timezone: %s', self.preferences['timezone']
)
if CommandCapabilities.has_option_in_help(
'systemd-firstboot', '--timezone',
root=self.root_dir, raise_on_error=False
):
Path.wipe(self.root_dir + '/etc/localtime')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--timezone=' + self.preferences['timezone']
])
else:
zoneinfo = '/usr/share/zoneinfo/' + self.preferences['timezone']
Command.run([
'chroot', self.root_dir,
'ln', '-s', '-f', zoneinfo, '/etc/localtime'
])
def check_luksformat_options_valid(self) -> None:
"""
Options set via the luksformat element are passed along
to the cryptsetup tool. Only options that are known to
the tool should be allowed. Thus this runtime check looks
up the provided option names if they exist in the cryptsetup
version used on the build host
"""
message = dedent('''\n
Option {0!r} not found in cryptsetup
The Option {0!r} could not be found in the help output
of the cryptsetup tool.
''')
luksformat = self.xml_state.build_type.get_luksformat()
if luksformat:
for option in luksformat[0].get_option():
argument = option.get_name()
if not CommandCapabilities.has_option_in_help(
'cryptsetup', argument, ['--help'],
raise_on_error=False
):
raise KiwiRuntimeError(message.format(argument))
def create_image_format(self):
# Creates the vmdk disk image and vmx config
super(DiskFormatOva, self).create_image_format()
# Converts to ova using ovftool
vmx = self.get_target_file_path_for_format('vmx')
ova = self.get_target_file_path_for_format('ova')
try:
os.unlink(ova)
except OSError:
pass
ovftool_cmd = ['ovftool']
if CommandCapabilities.has_option_in_help(
'ovftool', '--shaAlgorithm', raise_on_error=False):
ovftool_cmd.append('--shaAlgorithm=SHA1')
ovftool_cmd.extend([vmx, ova])
try:
Command.run(ovftool_cmd)
except KiwiCommandNotFound as e:
log.info('Building OVA images requires VMware\'s ovftool, get it from https://www.vmware.com/support/developer/ovf/')
raise e
# ovftool ignores the umask and creates files with 0600 for some reason
st = os.stat(vmx)
os.chmod(ova, stat.S_IMODE(st.st_mode))
def create(self, overwrite: bool = True):
"""
Setup a loop device of the blocksize given in the constructor
The file to loop is created with the size specified in the
constructor unless an existing one should not be overwritten
:param bool overwrite: overwrite existing file to loop
"""
if overwrite:
qemu_img_size = format(self.filesize_mbytes) + 'M'
Command.run(['qemu-img', 'create', self.filename, qemu_img_size])
loop_options = []
if self.blocksize_bytes and self.blocksize_bytes != 512:
if CommandCapabilities.has_option_in_help('losetup',
'--sector-size',
raise_on_error=False):
loop_options.append('--sector-size')
else:
loop_options.append('--logical-blocksize')
loop_options.append(format(self.blocksize_bytes))
loop_call = Command.run(['losetup'] + loop_options +
['-f', '--show', self.filename])
self.node_name = loop_call.output.rstrip('\n')
def setup_disk_image_config(
self, boot_uuid=None, root_uuid=None, hypervisor=None,
kernel=None, initrd=None, boot_options={}
):
"""
Create grub2 config file to boot from disk using grub2-mkconfig
:param string boot_uuid: unused
:param string root_uuid: unused
:param string hypervisor: unused
:param string kernel: unused
:param string initrd: unused
:param dict boot_options:
options dictionary that has to contain the root and boot
device and optional volume configuration. KIWI has to
mount the system prior to run grub2-mkconfig.
.. code:: python
{
'root_device': string,
'boot_device': string,
'efi_device': string,
'system_volumes': volume_manager_instance.get_volumes()
}
"""
self._mount_system(
boot_options.get('root_device'),
boot_options.get('boot_device'),
boot_options.get('efi_device'),
boot_options.get('system_volumes')
)
config_file = os.sep.join(
[
self.root_mount.mountpoint, 'boot',
self.boot_directory_name, 'grub.cfg'
]
)
Command.run(
[
'chroot', self.root_mount.mountpoint,
os.path.basename(self._get_grub2_mkconfig_tool()), '-o',
config_file.replace(self.root_mount.mountpoint, '')
]
)
if self.validate_use_of_linuxefi:
# On systems that uses GRUB_USE_LINUXEFI with grub2 version
# less than 2.04 there is no support for dynamic EFI
# environment checking. In this condition we change the
# grub config to add this support as follows:
#
# * Apply only on grub < 2.04
# 1. Modify grub.cfg to set linux/initrd as variables
# 2. Prepend hybrid setup to select linux vs. linuxefi on demand
#
# Please note this is a one time modification done by kiwi
# Any subsequent call of the grub config tool will overwrite
# the setup and disables dynamic EFI environment checking
# at boot time
if not CommandCapabilities.check_version(
self._get_grub2_mkconfig_tool(),
version_waterline=(2, 4), raise_on_error=False
):
with open(config_file) as grub_config_file:
grub_config = grub_config_file.read()
grub_config = re.sub(
r'([ \t]+)linux[efi]*([ \t]+)', r'\1$linux\2',
grub_config
)
grub_config = re.sub(
r'([ \t]+)initrd[efi]*([ \t]+)', r'\1$initrd\2',
grub_config
)
with open(config_file, 'w') as grub_config_file:
grub_config_file.write(
Template(self.grub2.header_hybrid).substitute()
)
grub_config_file.write(grub_config)
if self.root_reference:
if self.root_filesystem_is_overlay or \
Defaults.is_buildservice_worker():
# grub2-mkconfig has no idea how the correct root= setup is
# for disk images created with overlayroot enabled or in a
# buildservice worker environment. Because of that the mkconfig
# tool just finds the raw partition loop device and includes it
# which is wrong. In this particular case we have to patch the
# written config file and replace the wrong root= reference with
# the correct value.
with open(config_file) as grub_config_file:
grub_config = grub_config_file.read()
grub_config = grub_config.replace(
'root={0}'.format(boot_options.get('root_device')),
self.root_reference
)
with open(config_file, 'w') as grub_config_file:
grub_config_file.write(grub_config)
if self.firmware.efi_mode():
self._copy_grub_config_to_efi_path(
self.efi_mount.mountpoint, config_file
)
def test_check_version_no_match(self, mock_run):
command_type = namedtuple('command', ['output'])
mock_run.return_value = command_type(
output="Dummy line\ncommand someother stuff\n")
with raises(KiwiCommandCapabilitiesError):
CommandCapabilities.check_version('command', (1, 2, 3))
def test_check_version_no_match(self, mock_run):
command_type = namedtuple('command', ['output'])
mock_run.return_value = command_type(
output="Dummy line\ncommand someother stuff\n"
)
CommandCapabilities.check_version('command', (1, 2, 3))
def test_check_version_complex_pattern(self, mock_run):
command_type = namedtuple('command', ['output'])
mock_run.return_value = command_type(
output="grub2-mkconfig (GRUB2) 2.02\n")
assert CommandCapabilities.check_version('command', (2, 2)) is True
assert CommandCapabilities.check_version('command', (2, 4)) is False
