def run(dest_dir, settings, mount_devices, blvm):
""" Runs mkinitcpio """
cpu = get_cpu()
# Add lvm and encrypt hooks if necessary
hooks = ["base", "udev", "autodetect", "modconf", "block", "keyboard", "keymap"]
modules = []
# It is important that the plymouth hook comes before any encrypt hook
plymouth_bin = os.path.join(dest_dir, "usr/bin/plymouth")
if os.path.exists(plymouth_bin):
hooks.append("plymouth")
# It is important that the encrypt hook comes before the filesystems hook
# (in case you are using LVM on LUKS, the order should be: encrypt lvm2 filesystems)
if settings.get("use_luks"):
if os.path.exists(plymouth_bin):
hooks.append("plymouth-encrypt")
else:
hooks.append("encrypt")
modules.extend(["dm_mod", "dm_crypt", "ext4"])
arch = os.uname()[-1]
if arch == 'x86_64':
modules.extend(["aes_x86_64"])
else:
modules.extend(["aes_i586"])
modules.extend(["sha256", "sha512"])
if settings.get("f2fs"):
modules.append("f2fs")
if blvm or settings.get("use_lvm"):
hooks.append("lvm2")
if "swap" in mount_devices:
hooks.append("resume")
hooks.append("filesystems")
if settings.get('btrfs') and cpu is not 'genuineintel':
modules.append('crc32c')
elif settings.get('btrfs') and cpu is 'genuineintel':
modules.append('crc32c-intel')
else:
hooks.append("fsck")
set_hooks_and_modules(dest_dir, hooks, modules)
# Run mkinitcpio on the target system
# Fix for bsdcpio error. See: http://forum.antergos.com/viewtopic.php?f=5&t=1378&start=20#p5450
locale = settings.get('locale')
kernel = configuration['install']['KERNEL']
cmd = ['sh', '-c', 'LANG={0} /usr/bin/mkinitcpio -p {1}'.format(locale,kernel)]
chroot.run(cmd, dest_dir)
def install_grub2_bios(self):
""" Install Grub2 bootloader in a BIOS system """
grub_location = self.settings.get('bootloader_device')
txt = _("Installing GRUB(2) BIOS boot loader in {0}").format(grub_location)
logging.info(txt)
# /dev and others need to be mounted (binded).
# We call mount_special_dirs here just to be sure
chroot.mount_special_dirs(self.dest_dir)
grub_install = ['grub-install',
'--directory=/usr/lib/grub/i386-pc',
'--target=i386-pc',
'--boot-directory=/boot',
'--recheck']
if len(grub_location) > len("/dev/sdX"): # Use --force when installing in /dev/sdXY
grub_install.append("--force")
grub_install.append(grub_location)
try:
chroot.run(grub_install, self.dest_dir)
except subprocess.CalledProcessError as process_error:
logging.error(_('Command grub-install failed. Error output: %s'), process_error.output)
except subprocess.TimeoutExpired:
logging.error(_('Command grub-install timed out.'))
except Exception as general_error:
logging.error(_('Command grub-install failed. Unknown Error: %s'), general_error)
self.install_grub2_locales()
self.copy_grub2_theme_files()
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
# Run grub-mkconfig last
logging.debug(_("Running grub-mkconfig..."))
locale = self.settings.get("locale")
try:
cmd = ['sh', '-c', 'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
msg = _("grub-mkconfig does not respond. Killing grub-mount and os-prober so we can continue.")
logging.error(msg)
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
cfg = os.path.join(self.dest_dir, "boot/grub/grub.cfg")
with open(cfg) as grub_cfg:
if "Apricity" in grub_cfg.read():
txt = _("GRUB(2) BIOS has been successfully installed.")
logging.info(txt)
self.settings.set('bootloader_installation_successful', True)
else:
txt = _("ERROR installing GRUB(2) BIOS.")
logging.warning(txt)
self.settings.set('bootloader_installation_successful', False)
def run(params, dest_dir="/install"):
cmd = ["ufw"]
cmd.extend(params)
if not _UFW:
# Could not import ufw module (missing?)
# Will call ufw command directly
try:
chroot.run(cmd, dest_dir)
except OSError as os_error:
logging.warning(os_error)
finally:
return
app_action = False
# Remember, will have to take --force into account if we use it with 'app'
idx = 1
if len(cmd) > 1 and cmd[1].lower() == "--dry-run":
idx += 1
if len(cmd) > idx and cmd[idx].lower() == "app":
app_action = True
res = ""
try:
cmd_line = ufw.frontend.parse_command(cmd)
ui = ufw.frontend.UFWFrontend(cmd_line.dryrun)
if app_action and 'type' in cmd_line.data and cmd_line.data[
'type'] == 'app':
res = ui.do_application_action(cmd_line.action,
cmd_line.data['name'])
else:
bailout = False
if cmd_line.action == "enable" and not cmd_line.force and \
not ui.continue_under_ssh():
res = _("Aborted")
bailout = True
if not bailout:
if 'rule' in cmd_line.data:
res = ui.do_action(cmd_line.action, cmd_line.data['rule'],
cmd_line.data['iptype'], cmd_line.force)
else:
res = ui.do_action(cmd_line.action, "", "", cmd_line.force)
except (ValueError, ufw.UFWError) as ufw_error:
logging.error(ufw_error)
# Error using ufw module
# Will call ufw command directly
try:
chroot.run(cmd, dest_dir)
except OSError as os_error:
logging.warning(os_error)
finally:
return
logging.debug(res)
def install_grub2_efi(self):
""" Install Grub2 bootloader in a UEFI system """
uefi_arch = "x86_64"
spec_uefi_arch = "x64"
spec_uefi_arch_caps = "X64"
bootloader_id = 'apricity_grub' if not os.path.exists('/install/boot/efi/EFI/apricity_grub') else \
'apricity_grub_{0}'.format(self.random_generator())
txt = _("Installing GRUB(2) UEFI {0} boot loader").format(uefi_arch)
logging.info(txt)
grub_install = [
'grub-install',
'--target={0}-efi'.format(uefi_arch),
'--efi-directory=/install/boot/efi',
'--bootloader-id={0}'.format(bootloader_id),
'--boot-directory=/install/boot',
'--recheck']
load_module = ['modprobe', '-a', 'efivarfs']
try:
subprocess.call(load_module, timeout=15)
subprocess.check_call(grub_install, timeout=120)
except subprocess.CalledProcessError as process_error:
logging.error('Command grub-install failed. Error output: %s', process_error.output)
except subprocess.TimeoutExpired:
logging.error('Command grub-install timed out.')
except Exception as general_error:
logging.error('Command grub-install failed. Unknown Error: %s', general_error)
self.install_grub2_locales()
self.copy_grub2_theme_files()
# Copy grub into dirs known to be used as default by some OEMs if they do not exist yet.
grub_defaults = [os.path.join(self.dest_dir, "boot/efi/EFI/BOOT", "BOOT{0}.efi".format(spec_uefi_arch_caps)),
os.path.join(self.dest_dir, "boot/efi/EFI/Microsoft/Boot", 'bootmgfw.efi')]
grub_path = os.path.join(self.dest_dir, "boot/efi/EFI/apricity_grub", "grub{0}.efi".format(spec_uefi_arch))
for grub_default in grub_defaults:
path = grub_default.split()[0]
if not os.path.exists(path):
msg = _("No OEM loader found in %s. Copying Grub(2) into dir.")
logging.info(msg, path)
os.makedirs(path)
msg_failed = _("Copying Grub(2) into OEM dir failed: %s")
try:
shutil.copy(grub_path, grub_default)
except FileNotFoundError:
logging.warning(msg_failed, _("File not found."))
except FileExistsError:
logging.warning(msg_failed, _("File already exists."))
except Exception as general_error:
logging.warning(msg_failed, general_error)
# Copy uefi shell if none exists in /boot/efi/EFI
shell_src = "/usr/share/cnchi/grub2-theme/shellx64_v2.efi"
shell_dst = os.path.join(self.dest_dir, "boot/efi/EFI/")
try:
shutil.copy2(shell_src, shell_dst)
except FileNotFoundError:
logging.warning(_("UEFI Shell drop-in not found at %s"), shell_src)
except FileExistsError:
pass
except Exception as general_error:
logging.warning(_("UEFI Shell drop-in could not be copied."))
logging.warning(general_error)
# Run grub-mkconfig last
logging.info(_("Generating grub.cfg"))
# /dev and others need to be mounted (binded).
# We call mount_special_dirs here just to be sure
chroot.mount_special_dirs(self.dest_dir)
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
logging.debug(_("Running grub-mkconfig..."))
locale = self.settings.get("locale")
try:
cmd = ['sh', '-c', 'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
txt = _("grub-mkconfig appears to be hung. Killing grub-mount and os-prober so we can continue.")
logging.error(txt)
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
paths = [os.path.join(self.dest_dir, "boot/grub/x86_64-efi/core.efi"),
os.path.join(self.dest_dir, "boot/efi/EFI/{0}".format(bootloader_id), "grub{0}.efi".format(spec_uefi_arch))]
exists = True
for path in paths:
if not os.path.exists(path):
exists = False
logging.debug(_("Path '%s' doesn't exist, when it should"), path)
if exists:
txt = _("GRUB(2) UEFI install completed successfully")
logging.info(txt)
self.settings.set('bootloader_installation_successful', True)
else:
txt = _("GRUB(2) UEFI install may not have completed successfully.")
logging.warning(txt)
self.settings.set('bootloader_installation_successful', False)
def chroot_run(cmd):
chroot.run(cmd, DEST_DIR)
def install_systemd_boot(self):
""" Install Systemd-boot (Gummiboot) bootloader to the EFI System Partition """
# Setup bootloader menu
menu_dir = os.path.join(self.dest_dir, "boot/loader")
os.makedirs(menu_dir, mode=0o755, exist_ok=True)
menu_path = os.path.join(menu_dir, "loader.conf")
with open(menu_path, 'w') as menu_file:
menu_file.write("default antergos")
# Setup boot entries
conf = {}
if not self.settings.get('use_luks'):
conf['default'] = []
conf['default'].append("title\tAntergos\n")
conf['default'].append("linux\t/vmlinuz-linux\n")
conf['default'].append("initrd\t/initramfs-linux.img\n")
conf['default'].append(
"options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid))
conf['fallback'] = []
conf['fallback'].append("title\tAntergos (fallback)\n")
conf['fallback'].append("linux\t/vmlinuz-linux\n")
conf['fallback'].append("initrd\t/initramfs-linux-fallback.img\n")
conf['fallback'].append(
"options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid))
if self.settings.get('feature_lts'):
conf['lts'] = []
conf['lts'].append("title\tAntergos LTS\n")
conf['lts'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts'].append("initrd\t/initramfs-linux-lts.img\n")
conf['lts'].append(
"options\troot=UUID={0} rw quiet\n\n".format(
self.root_uuid))
conf['lts_fallback'] = []
conf['lts_fallback'].append(
"title\tAntergos LTS (fallback)\n\n")
conf['lts_fallback'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts_fallback'].append(
"initrd\t/initramfs-linux-lts-fallback.img\n")
conf['lts_fallback'].append(
"options\troot=UUID={0} rw quiet\n\n".format(
self.root_uuid))
else:
luks_root_volume = self.settings.get('luks_root_volume')
luks_root_volume_uuid = fs.get_uuid(
"/dev/mapper/{0}".format(luks_root_volume))
# In automatic mode, root_device is in self.mount_devices, as it should be
root_device = self.root_device
if self.method == "advanced" and self.settings.get(
'use_luks_in_root'):
root_device = self.settings.get('luks_root_device')
root_uuid = fs.get_uuid(root_device)
key = ""
if self.settings.get("luks_root_password") == "":
key = "cryptkey=UUID={0}:ext2:/.keyfile-root".format(
self.boot_uuid)
root_uuid_line = "cryptdevice=UUID={0}:{1} {2} root=UUID={3} rw quiet"
root_uuid_line = root_uuid_line.format(root_uuid, luks_root_volume,
key, luks_root_volume_uuid)
conf['default'] = []
conf['default'].append("title\tAntergos\n")
conf['default'].append("linux\t/vmlinuz-linux\n")
conf['default'].append(
"options\tinitrd=/initramfs-linux.img {0}\n\n".format(
root_uuid_line))
conf['fallback'] = []
conf['fallback'].append("title\tAntergos (fallback)\n")
conf['fallback'].append("linux\t/vmlinuz-linux\n")
conf['fallback'].append(
"options\tinitrd=/initramfs-linux-fallback.img {0}\n\n".format(
root_uuid_line))
if self.settings.get('feature_lts'):
conf['lts'] = []
conf['lts'].append("title\tAntergos LTS\n")
conf['lts'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts'].append(
"options\tinitrd=/initramfs-linux-lts.img {0}\n\n".format(
root_uuid_line))
conf['lts_fallback'] = []
conf['lts_fallback'].append("title\tAntergos LTS (fallback)\n")
conf['lts_fallback'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts_fallback'].append(
"options\tinitrd=/initramfs-linux-lts-fallback.img {0}\n\n"
.format(root_uuid_line))
# Write boot entries
entries_dir = os.path.join(self.dest_dir, "boot/loader/entries")
os.makedirs(entries_dir, mode=0o755, exist_ok=True)
entry_path = os.path.join(entries_dir, "antergos.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['default']:
entry_file.write(line)
entry_path = os.path.join(entries_dir, "antergos-fallback.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['fallback']:
entry_file.write(line)
if self.settings.get('feature_lts'):
entry_path = os.path.join(entries_dir, "antergos-lts.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['lts']:
entry_file.write(line)
entry_path = os.path.join(entries_dir,
"antergos-lts-fallback.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['lts_fallback']:
entry_file.write(line)
# Install bootloader
logging.debug("Installing Systemd-boot bootloader...")
try:
# chroot.mount_special_dirs(self.dest_dir)
cmd = ['bootctl', '--path=/boot', 'install']
chroot.run(cmd, self.dest_dir, 300)
# chroot.umount_special_dirs(self.dest_dir)
logging.info("Systemd-boot install completed successfully")
self.settings.set('bootloader_installation_successful', True)
except subprocess.CalledProcessError as process_error:
logging.error('Command %s failed. Error output: %s', " ".join(cmd),
process_error.output)
self.settings.set('bootloader_installation_successful', False)
except subprocess.TimeoutExpired:
logging.error('Command %s timed out.', " ".join(cmd))
self.settings.set('bootloader_installation_successful', False)
except Exception as general_error:
logging.error('Command %s failed. Unknown Error: %s',
" ".join(cmd), general_error)
self.settings.set('bootloader_installation_successful', False)
def install_grub2_efi(self):
""" Install Grub2 bootloader in a UEFI system """
uefi_arch = "x86_64"
spec_uefi_arch = "x64"
spec_uefi_arch_caps = "X64"
bootloader_id = 'antergos_grub' if not os.path.exists('/install/boot/efi/EFI/antergos_grub') else \
'antergos_grub_{0}'.format(self.random_generator())
txt = _("Installing GRUB(2) UEFI {0} boot loader").format(uefi_arch)
logging.info(txt)
grub_install = [
'grub-install', '--target={0}-efi'.format(uefi_arch),
'--efi-directory=/install/boot/efi',
'--bootloader-id={0}'.format(bootloader_id),
'--boot-directory=/install/boot', '--recheck'
]
load_module = ['modprobe', '-a', 'efivarfs']
try:
subprocess.call(load_module, timeout=15)
subprocess.check_call(grub_install, timeout=120)
except subprocess.CalledProcessError as process_error:
logging.error('Command grub-install failed. Error output: %s',
process_error.output)
except subprocess.TimeoutExpired:
logging.error('Command grub-install timed out.')
except Exception as general_error:
logging.error('Command grub-install failed. Unknown Error: %s',
general_error)
self.install_grub2_locales()
# Copy grub into dirs known to be used as default by some OEMs if they do not exist yet.
grub_defaults = [
os.path.join(self.dest_dir, "boot/efi/EFI/BOOT",
"BOOT{0}.efi".format(spec_uefi_arch_caps)),
os.path.join(self.dest_dir, "boot/efi/EFI/Microsoft/Boot",
'bootmgfw.efi')
]
grub_path = os.path.join(self.dest_dir, "boot/efi/EFI/antergos_grub",
"grub{0}.efi".format(spec_uefi_arch))
for grub_default in grub_defaults:
path = grub_default.split()[0]
if not os.path.exists(path):
msg = _("No OEM loader found in %s. Copying Grub(2) into dir.")
logging.info(msg, path)
os.makedirs(path, mode=0o755)
msg_failed = _("Copying Grub(2) into OEM dir failed: %s")
try:
shutil.copy(grub_path, grub_default)
except FileNotFoundError:
logging.warning(msg_failed, _("File not found."))
except FileExistsError:
logging.warning(msg_failed, _("File already exists."))
except Exception as general_error:
logging.warning(msg_failed, general_error)
# Run grub-mkconfig last
logging.debug("Generating grub.cfg")
# /dev and others need to be mounted (binded).
# We call mount_special_dirs here just to be sure
chroot.mount_special_dirs(self.dest_dir)
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
logging.debug("Running grub-mkconfig...")
locale = self.settings.get("locale")
try:
cmd = [
'sh', '-c',
'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)
]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
txt = _(
"grub-mkconfig appears to be hung. Killing grub-mount and os-prober so we can continue."
)
logging.error(txt)
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
paths = [
os.path.join(self.dest_dir, "boot/grub/x86_64-efi/core.efi"),
os.path.join(self.dest_dir,
"boot/efi/EFI/{0}".format(bootloader_id),
"grub{0}.efi".format(spec_uefi_arch))
]
exists = True
for path in paths:
if not os.path.exists(path):
exists = False
logging.debug("Path '%s' doesn't exist, when it should", path)
if exists:
logging.info("GRUB(2) UEFI install completed successfully")
self.settings.set('bootloader_installation_successful', True)
else:
logging.warning(
"GRUB(2) UEFI install may not have completed successfully.")
self.settings.set('bootloader_installation_successful', False)
def install_grub2_bios(self):
""" Install Grub2 bootloader in a BIOS system """
grub_location = self.settings.get('bootloader_device')
txt = _("Installing GRUB(2) BIOS boot loader in {0}").format(
grub_location)
logging.info(txt)
# /dev and others need to be mounted (binded).
# We call mount_special_dirs here just to be sure
chroot.mount_special_dirs(self.dest_dir)
grub_install = [
'grub-install', '--directory=/usr/lib/grub/i386-pc',
'--target=i386-pc', '--boot-directory=/boot', '--recheck'
]
if len(grub_location) > len(
"/dev/sdX"): # Use --force when installing in /dev/sdXY
grub_install.append("--force")
grub_install.append(grub_location)
try:
chroot.run(grub_install, self.dest_dir)
except subprocess.CalledProcessError as process_error:
logging.error('Command grub-install failed. Error output: %s',
process_error.output)
except subprocess.TimeoutExpired:
logging.error('Command grub-install timed out.')
except Exception as general_error:
logging.error('Command grub-install failed. Unknown Error: %s',
general_error)
self.install_grub2_locales()
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
# Run grub-mkconfig last
logging.debug("Running grub-mkconfig...")
locale = self.settings.get("locale")
try:
cmd = [
'sh', '-c',
'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)
]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
msg = _(
"grub-mkconfig does not respond. Killing grub-mount and os-prober so we can continue."
)
logging.error(msg)
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
cfg = os.path.join(self.dest_dir, "boot/grub/grub.cfg")
with open(cfg) as grub_cfg:
if "Antergos" in grub_cfg.read():
txt = _("GRUB(2) BIOS has been successfully installed.")
logging.info(txt)
self.settings.set('bootloader_installation_successful', True)
else:
txt = _("ERROR installing GRUB(2) BIOS.")
logging.warning(txt)
self.settings.set('bootloader_installation_successful', False)
def install_grub2_efi(self):
""" Install Grub2 bootloader in a UEFI system """
uefi_arch = "x86_64"
spec_uefi_arch = "x64"
spec_uefi_arch_caps = "X64"
efi_path = self.settings.get('bootloader_device')
logging.debug(_('The efi directory is: {0}'.format(efi_path)))
if not os.path.exists('/install{0}/EFI/manjaro_grub'.format(efi_path)):
bootloader_id = 'manjaro_grub'
else:
bootloader_id = 'manjaro_grub_{0}'.format(self.random_generator())
logging.info(
_("Installing GRUB(2) UEFI {0} boot loader in {1}".format(
uefi_arch, efi_path)))
grub_install = [
'grub-install', '--target={0}-efi'.format(uefi_arch),
'--efi-directory={0}'.format(efi_path),
'--bootloader-id={0}'.format(bootloader_id),
'--boot-directory=/boot', '--recheck'
]
logging.debug(
_("grub-install command: {0}".format(" ".join(grub_install))))
try:
chroot.run(grub_install, self.dest_dir, 300)
except subprocess.CalledProcessError as process_error:
logging.error(
_('Command grub-install failed. Error output: {0}'.format(
process_error.output)))
except subprocess.TimeoutExpired:
logging.error(_('Command grub-install timed out.'))
except Exception as general_error:
logging.error(
_('Command grub-install failed. Unknown Error: {0}'.format(
general_error)))
self.install_grub2_locales()
# self.copy_grub2_theme_files()
# Copy grub into dirs known to be used as default by some OEMs if
# they do not exist yet.
grub_defaults = [
os.path.join(self.dest_dir, "{0}/EFI/BOOT".format(efi_path[1:]),
"BOOT{0}.efi".format(spec_uefi_arch_caps)),
os.path.join(self.dest_dir,
"{0}/EFI/Microsoft/Boot".format(efi_path[1:]),
'bootmgfw.efi')
]
grub_path = os.path.join(self.dest_dir,
"{0}/EFI/manjaro_grub".format(efi_path[1:]),
"grub{0}.efi".format(spec_uefi_arch))
for grub_default in grub_defaults:
path = grub_default.split()[0]
if not os.path.exists(path):
logging.info(
_("No OEM loader found in {0}. Copying Grub(2) "
"into dir.").format(path))
os.makedirs(path)
msg = _("Copying Grub(2) into OEM dir failed: {0}")
try:
shutil.copy(grub_path, grub_default)
except FileNotFoundError:
logging.warning(msg.format(_("File not found.")))
except FileExistsError:
logging.warning(msg.format(_("File already exists.")))
except Exception as general_error:
logging.warning(msg.format(general_error))
# Run grub-mkconfig last
logging.info(_("Generating grub.cfg"))
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
locale = self.settings.get("locale")
try:
cmd = [
'sh', '-c',
'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)
]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
txt = _("grub-mkconfig appears to be hung. Killing grub-mount and "
"os-prober so we can continue.")
logging.error(txt)
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
paths = [
os.path.join(self.dest_dir, "boot/grub/x86_64-efi/core.efi"),
os.path.join(self.dest_dir,
"{0}/EFI/{1}".format(efi_path[1:], bootloader_id),
"grub{0}.efi".format(spec_uefi_arch))
]
exists = True
for path in paths:
if not os.path.exists(path):
logging.debug(
"Path '{0}' doesn't exists, when it should".format(path))
exists = False
if exists:
txt = _("GRUB(2) UEFI install completed successfully")
logging.info(txt)
self.settings.set('bootloader_installation_successful', True)
else:
txt = _(
"GRUB(2) UEFI install may not have completed successfully.")
logging.warning(txt)
self.settings.set('bootloader_installation_successful', False)
def run(dest_dir, settings, mount_devices, blvm):
""" Runs mkinitcpio """
cpu = get_cpu()
# Add lvm and encrypt hooks if necessary
hooks = [
"base", "udev", "autodetect", "modconf", "block", "keyboard", "keymap"
]
modules = []
# It is important that the plymouth hook comes before any encrypt hook
plymouth_bin = os.path.join(dest_dir, "usr/bin/plymouth")
if os.path.exists(plymouth_bin):
hooks.append("plymouth")
# It is important that the encrypt hook comes before the filesystems hook
# (in case you are using LVM on LUKS, the order should be: encrypt lvm2 filesystems)
if settings.get("use_luks"):
if os.path.exists(plymouth_bin):
hooks.append("plymouth-encrypt")
else:
hooks.append("encrypt")
modules.extend(["dm_mod", "dm_crypt", "ext4"])
arch = os.uname()[-1]
if arch == 'x86_64':
modules.extend(["aes_x86_64"])
else:
modules.extend(["aes_i586"])
modules.extend(["sha256", "sha512"])
if settings.get("f2fs"):
modules.append("f2fs")
if blvm or settings.get("use_lvm"):
hooks.append("lvm2")
if "swap" in mount_devices:
hooks.append("resume")
hooks.append("filesystems")
if settings.get('btrfs') and cpu is not 'genuineintel':
modules.append('crc32c')
elif settings.get('btrfs') and cpu is 'genuineintel':
modules.append('crc32c-intel')
else:
hooks.append("fsck")
set_hooks_and_modules(dest_dir, hooks, modules)
# Run mkinitcpio on the target system
# Fix for bsdcpio error. See: http://forum.antergos.com/viewtopic.php?f=5&t=1378&start=20#p5450
locale = settings.get('locale')
# chroot.mount_special_dirs(dest_dir)
cmd = ['sh', '-c', 'LANG={0} /usr/bin/mkinitcpio -p linux'.format(locale)]
chroot.run(cmd, dest_dir)
if settings.get('feature_lts'):
cmd = [
'sh', '-c',
'LANG={0} /usr/bin/mkinitcpio -p linux-lts'.format(locale)
]
chroot.run(cmd, dest_dir)
def install_systemd_boot(self):
"""
Install Systemd-Boot bootloader to the EFI System Partition
and configure entry files
"""
logging.info("Installing the systemd-boot loader")
# Setup bootloader menu
menu_dir = os.path.join(self.dest_dir, "boot/loader")
os.makedirs(menu_dir, exist_ok=True)
menu_path = os.path.join(menu_dir, "loader.conf")
with open(menu_path, 'w') as menu_file:
menu_file.write("default manjaro-default")
# Setup boot entries
if not self.settings.get('use_luks'):
conf = {
'default': [
'title\tManjaro\n',
'linux\t/{0}\n'.format(self.vmlinuz),
'initrd\t/{0}\n'.format(self.initramfs),
'options\troot=UUID={0} rw quiet\n\n'.format(self.root_uuid)
],
'fallback': [
"title\tManjaro (fallback)\n",
"linux\t/{0}\n".format(self.vmlinuz),
"initrd\t/{0}\n".format(self.fallback),
"options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid)
]
}
else:
luks_root_volume = self.settings.get('luks_root_volume')
luks_root_volume_uuid = fs.get_info(luks_root_volume)['UUID']
# In automatic mode, root_device is in self.mount_devices
root_device = self.root_device
if (self.method == "advanced" and
self.settings.get('use_luks_in_root')):
root_device = self.settings.get('luks_root_device')
root_uuid = fs.get_info(root_device)['UUID']
key = ""
if self.settings.get("luks_root_password") == "":
key = ("cryptkey=UUID={0}:ext2:/.keyfile-root"
.format(self.boot_uuid))
root_uuid_line = "cryptdevice=UUID={0}:{1} {2} root=UUID={3} rw quit"\
.format(root_uuid, luks_root_volume, key, luks_root_volume_uuid)
conf = {
'default': [
"title\tManjaro\n",
"linux\t/{0}\n".format(self.vmlinuz),
"options\tinitrd=/{0} {1}\n\n".format(self.initramfs,
root_uuid_line)
],
'fallback': [
"title\tManjaro (fallback)\n",
"linux\t/{0}\n".format(self.vmlinuz),
"options\tinitrd=/{0} {1}\n\n".format(self.fallback,
root_uuid_line)
]
}
# Write boot entries
entries_dir = os.path.join(self.dest_dir, "boot/loader/entries")
os.makedirs(entries_dir, exist_ok=True)
for fname, entry in conf.items():
entry_path = os.path.join(entries_dir,
"manjaro-{}.conf".format(fname))
with open(entry_path, 'w') as file:
for line in entry:
file.write(line)
# Install bootloader
try:
cmd = ['bootctl', '--path=/boot', 'install']
chroot.run(cmd, self.dest_dir, 300)
logging.info(_("Systemd-Boot install completed successfully"))
self.settings.set('bootloader_installation_successful', True)
except subprocess.CalledProcessError as process_error:
logging.error(_('Command {0} failed. Error output: {1}'
.format(cmd,process_error.output)))
self.settings.set('bootloader_installation_successful', False)
except subprocess.TimeoutExpired:
logging.error(_('Command {0} timed out.'.format(cmd)))
self.settings.set('bootloader_installation_successful', False)
except Exception as general_error:
logging.error(_('Command {0} failed. Unknown Error: {1}'
.format(cmd,general_error)))
self.settings.set('bootloader_installation_successful', False)
def install_grub2_efi(self):
""" Install Grub2 bootloader in a UEFI system """
uefi_arch = "x86_64"
spec_uefi_arch = "x64"
spec_uefi_arch_caps = "X64"
efi_path = self.settings.get('bootloader_device')
logging.debug(_('The efi directory is: {0}'.format(efi_path)))
if not os.path.exists('/install{0}/EFI/manjaro_grub'.format(efi_path)):
bootloader_id = 'manjaro_grub'
else:
bootloader_id = 'manjaro_grub_{0}'.format(self.random_generator())
logging.info(_("Installing GRUB(2) UEFI {0} boot loader in {1}"
.format(uefi_arch, efi_path)))
grub_install = [
'grub-install',
'--target={0}-efi'.format(uefi_arch),
'--efi-directory={0}'.format(efi_path),
'--bootloader-id={0}'.format(bootloader_id),
'--boot-directory=/boot',
'--recheck']
logging.debug(_("grub-install command: {0}"
.format(" ".join(grub_install))))
try:
chroot.run(grub_install, self.dest_dir, 300)
except subprocess.CalledProcessError as process_error:
logging.error(_('Command grub-install failed. Error output: {0}'
.format(process_error.output)))
except subprocess.TimeoutExpired:
logging.error(_('Command grub-install timed out.'))
except Exception as general_error:
logging.error(_('Command grub-install failed. Unknown Error: {0}'
.format(general_error)))
self.install_grub2_locales()
# self.copy_grub2_theme_files()
# Copy grub into dirs known to be used as default by some OEMs if
# they do not exist yet.
grub_defaults = [
os.path.join(self.dest_dir,
"{0}/EFI/BOOT".format(efi_path[1:]),
"BOOT{0}.efi".format(spec_uefi_arch_caps)),
os.path.join(self.dest_dir,
"{0}/EFI/Microsoft/Boot".format(efi_path[1:]),
'bootmgfw.efi')
]
grub_path = os.path.join(self.dest_dir,
"{0}/EFI/manjaro_grub".format(efi_path[1:]),
"grub{0}.efi".format(spec_uefi_arch))
for grub_default in grub_defaults:
path = grub_default.split()[0]
if not os.path.exists(path):
logging.info(_("No OEM loader found in {0}. Copying Grub(2) "
"into dir.").format(path))
os.makedirs(path)
msg = _("Copying Grub(2) into OEM dir failed: {0}")
try:
shutil.copy(grub_path, grub_default)
except FileNotFoundError:
logging.warning(msg.format(_("File not found.")))
except FileExistsError:
logging.warning(msg.format(_("File already exists.")))
except Exception as general_error:
logging.warning(msg.format(general_error))
# Run grub-mkconfig last
logging.info(_("Generating grub.cfg"))
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
locale = self.settings.get("locale")
try:
cmd = [
'sh',
'-c',
'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)
]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
txt = _("grub-mkconfig appears to be hung. Killing grub-mount and "
"os-prober so we can continue.")
logging.error(txt)
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
paths = [os.path.join(self.dest_dir, "boot/grub/x86_64-efi/core.efi"),
os.path.join(self.dest_dir,
"{0}/EFI/{1}".format(efi_path[1:], bootloader_id),
"grub{0}.efi".format(spec_uefi_arch))]
exists = True
for path in paths:
if not os.path.exists(path):
logging.debug("Path '{0}' doesn't exists, when it should"
.format(path))
exists = False
if exists:
txt = _("GRUB(2) UEFI install completed successfully")
logging.info(txt)
self.settings.set('bootloader_installation_successful', True)
else:
txt = _("GRUB(2) UEFI install may not have completed successfully.")
logging.warning(txt)
self.settings.set('bootloader_installation_successful', False)
def install_grub2_bios(self):
""" Install Grub2 bootloader in a BIOS system """
grub_location = self.settings.get('bootloader_device')
txt = _("Installing GRUB(2) BIOS boot loader in {0}"
.format(grub_location))
logging.info(txt)
grub_install = ['grub-install',
'--directory=/usr/lib/grub/i386-pc',
'--target=i386-pc',
'--boot-directory=/boot',
'--recheck']
logging.debug("grub-install command: {0}"
.format(" ".join(grub_install)))
if len(grub_location) > len("/dev/sdX"): # ex: /dev/sdXY > 8
grub_install.append("--force")
grub_install.append(grub_location)
try:
chroot.run(grub_install, self.dest_dir, 300)
except subprocess.CalledProcessError as process_error:
logging.error(_('Command grub-install failed. Error output: {0}'
.format(process_error.output)))
except subprocess.TimeoutExpired:
logging.error(_('Command grub-install timed out.'))
except Exception as general_error:
logging.error(_('Command grub-install failed. Unknown Error: {0}'
.format(general_error)))
self.install_grub2_locales()
# self.copy_grub2_theme_files()
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
# Run grub-mkconfig last
locale = self.settings.get("locale")
try:
cmd = [
'sh',
'-c',
'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)
]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
logging.error(_("grub-mkconfig does not respond. Killing grub-mount"
" and os-prober so we can continue."))
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
cfg = os.path.join(self.dest_dir, "boot/grub/grub.cfg")
with open(cfg) as grub_cfg:
if "Manjaro" in grub_cfg.read():
logging.info(_("GRUB(2) BIOS has been successfully installed."))
self.settings.set('bootloader_installation_successful', True)
else:
logging.warning(_("ERROR installing GRUB(2) BIOS."))
self.settings.set('bootloader_installation_successful', False)
def run(params, dest_dir="/install"):
cmd = ["ufw"]
cmd.extend(params)
if not _UFW:
# Could not import ufw module (missing?)
# Will call ufw command directly
try:
chroot.run(cmd, dest_dir)
except OSError as os_error:
logging.warning(os_error)
finally:
return
app_action = False
# Remember, will have to take --force into account if we use it with 'app'
idx = 1
if len(cmd) > 1 and cmd[1].lower() == "--dry-run":
idx += 1
if len(cmd) > idx and cmd[idx].lower() == "app":
app_action = True
res = ""
try:
cmd_line = ufw.frontend.parse_command(cmd)
ui = ufw.frontend.UFWFrontend(cmd_line.dryrun)
if app_action and 'type' in cmd_line.data and cmd_line.data['type'] == 'app':
res = ui.do_application_action(cmd_line.action, cmd_line.data['name'])
else:
bailout = False
if cmd_line.action == "enable" and not cmd_line.force and \
not ui.continue_under_ssh():
res = _("Aborted")
bailout = True
if not bailout:
if 'rule' in cmd_line.data:
res = ui.do_action(
cmd_line.action,
cmd_line.data['rule'],
cmd_line.data['iptype'],
cmd_line.force)
else:
res = ui.do_action(
cmd_line.action,
"",
"",
cmd_line.force)
except (ValueError, ufw.UFWError) as ufw_error:
logging.error(ufw_error)
# Error using ufw module
# Will call ufw command directly
try:
chroot.run(cmd, dest_dir)
except OSError as os_error:
logging.warning(os_error)
finally:
return
logging.debug(res)
def install_systemd_boot(self):
"""
Install Systemd-Boot bootloader to the EFI System Partition
and configure entry files
"""
logging.info("Installing the systemd-boot loader")
# Setup bootloader menu
menu_dir = os.path.join(self.dest_dir, "boot/loader")
os.makedirs(menu_dir, exist_ok=True)
menu_path = os.path.join(menu_dir, "loader.conf")
with open(menu_path, 'w') as menu_file:
menu_file.write("default manjaro-default")
# Setup boot entries
if not self.settings.get('use_luks'):
conf = {
'default': [
'title\tManjaro\n', 'linux\t/{0}\n'.format(self.vmlinuz),
'initrd\t/{0}\n'.format(self.initramfs),
'options\troot=UUID={0} rw quiet\n\n'.format(
self.root_uuid)
],
'fallback': [
"title\tManjaro (fallback)\n",
"linux\t/{0}\n".format(self.vmlinuz),
"initrd\t/{0}\n".format(self.fallback),
"options\troot=UUID={0} rw quiet\n\n".format(
self.root_uuid)
]
}
else:
luks_root_volume = self.settings.get('luks_root_volume')
luks_root_volume_uuid = fs.get_info(luks_root_volume)['UUID']
# In automatic mode, root_device is in self.mount_devices
root_device = self.root_device
if (self.method == "advanced"
and self.settings.get('use_luks_in_root')):
root_device = self.settings.get('luks_root_device')
root_uuid = fs.get_info(root_device)['UUID']
key = ""
if self.settings.get("luks_root_password") == "":
key = ("cryptkey=UUID={0}:ext2:/.keyfile-root".format(
self.boot_uuid))
root_uuid_line = "cryptdevice=UUID={0}:{1} {2} root=UUID={3} rw quit"\
.format(root_uuid, luks_root_volume, key, luks_root_volume_uuid)
conf = {
'default': [
"title\tManjaro\n", "linux\t/{0}\n".format(self.vmlinuz),
"options\tinitrd=/{0} {1}\n\n".format(
self.initramfs, root_uuid_line)
],
'fallback': [
"title\tManjaro (fallback)\n",
"linux\t/{0}\n".format(self.vmlinuz),
"options\tinitrd=/{0} {1}\n\n".format(
self.fallback, root_uuid_line)
]
}
# Write boot entries
entries_dir = os.path.join(self.dest_dir, "boot/loader/entries")
os.makedirs(entries_dir, exist_ok=True)
for fname, entry in conf.items():
entry_path = os.path.join(entries_dir,
"manjaro-{}.conf".format(fname))
with open(entry_path, 'w') as file:
for line in entry:
file.write(line)
# Install bootloader
try:
cmd = ['bootctl', '--path=/boot', 'install']
chroot.run(cmd, self.dest_dir, 300)
logging.info(_("Systemd-Boot install completed successfully"))
self.settings.set('bootloader_installation_successful', True)
except subprocess.CalledProcessError as process_error:
logging.error(
_('Command {0} failed. Error output: {1}'.format(
cmd, process_error.output)))
self.settings.set('bootloader_installation_successful', False)
except subprocess.TimeoutExpired:
logging.error(_('Command {0} timed out.'.format(cmd)))
self.settings.set('bootloader_installation_successful', False)
except Exception as general_error:
logging.error(
_('Command {0} failed. Unknown Error: {1}'.format(
cmd, general_error)))
self.settings.set('bootloader_installation_successful', False)
def install_gummiboot(self):
""" Install Gummiboot bootloader to the EFI System Partition """
# Setup bootloader menu
menu_dir = os.path.join(self.dest_dir, "boot/loader")
os.makedirs(menu_dir)
menu_path = os.path.join(menu_dir, "loader.conf")
with open(menu_path, 'w') as menu_file:
menu_file.write("default apricity")
# Setup boot entries
conf = {}
if not self.settings.get('use_luks'):
conf['default'] = []
conf['default'].append("title\tApricity\n")
conf['default'].append("linux\t/vmlinuz-linux\n")
conf['default'].append("initrd\t/initramfs-linux.img\n")
conf['default'].append("options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid))
conf['fallback'] = []
conf['fallback'].append("title\tApricity (fallback)\n")
conf['fallback'].append("linux\t/vmlinuz-linux\n")
conf['fallback'].append("initrd\t/initramfs-linux-fallback.img\n")
conf['fallback'].append("options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid))
if self.settings.get('feature_lts'):
conf['lts'] = []
conf['lts'].append("title\tApricity LTS\n")
conf['lts'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts'].append("initrd\t/initramfs-linux-lts.img\n")
conf['lts'].append("options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid))
conf['lts_fallback'] = []
conf['lts_fallback'].append("title\tApricity LTS (fallback)\n\n")
conf['lts_fallback'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts_fallback'].append("initrd\t/initramfs-linux-lts-fallback.img\n")
conf['lts_fallback'].append("options\troot=UUID={0} rw quiet\n\n".format(self.root_uuid))
else:
luks_root_volume = self.settings.get('luks_root_volume')
luks_root_volume_device = "/dev/mapper/{0}".format(luks_root_volume)
luks_root_volume_uuid = fs.get_info(luks_root_volume_device)['UUID']
# In automatic mode, root_device is in self.mount_devices, as it should be
root_device = self.root_device
if self.method == "advanced" and self.settings.get('use_luks_in_root'):
root_device = self.settings.get('luks_root_device')
root_uuid = fs.get_info(root_device)['UUID']
key = ""
if self.settings.get("luks_root_password") == "":
key = "cryptkey=UUID={0}:ext2:/.keyfile-root".format(self.boot_uuid)
root_uuid_line = "cryptdevice=UUID={0}:{1} {2} root=UUID={3} rw quiet"
root_uuid_line = root_uuid_line.format(root_uuid, luks_root_volume, key, luks_root_volume_uuid)
conf['default'] = []
conf['default'].append("title\tApricity\n")
conf['default'].append("linux\t/vmlinuz-linux\n")
conf['default'].append("options\tinitrd=/initramfs-linux.img {0}\n\n".format(root_uuid_line))
conf['fallback'] = []
conf['fallback'].append("title\tApricity (fallback)\n")
conf['fallback'].append("linux\t/vmlinuz-linux\n")
conf['fallback'].append("options\tinitrd=/initramfs-linux-fallback.img {0}\n\n".format(root_uuid_line))
if self.settings.get('feature_lts'):
conf['lts'] = []
conf['lts'].append("title\tApricity LTS\n")
conf['lts'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts'].append("options\tinitrd=/initramfs-linux-lts.img {0}\n\n".format(root_uuid_line))
conf['lts_fallback'] = []
conf['lts_fallback'].append("title\tApricity LTS (fallback)\n")
conf['lts_fallback'].append("linux\t/vmlinuz-linux-lts\n")
conf['lts_fallback'].append("options\tinitrd=/initramfs-linux-lts-fallback.img {0}\n\n".format(root_uuid_line))
# Write boot entries
entries_dir = os.path.join(self.dest_dir, "boot/loader/entries")
os.makedirs(entries_dir)
entry_path = os.path.join(entries_dir, "apricity.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['default']:
entry_file.write(line)
entry_path = os.path.join(entries_dir, "apricity-fallback.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['fallback']:
entry_file.write(line)
if self.settings.get('feature_lts'):
entry_path = os.path.join(entries_dir, "apricity-lts.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['lts']:
entry_file.write(line)
entry_path = os.path.join(entries_dir, "apricity-lts-fallback.conf")
with open(entry_path, 'w') as entry_file:
for line in conf['lts_fallback']:
entry_file.write(line)
# Install bootloader
logging.debug(_("Installing gummiboot bootloader..."))
try:
chroot.mount_special_dirs(self.dest_dir)
cmd = ['gummiboot', '--path=/boot', 'install']
chroot.run(cmd, self.dest_dir, 300)
chroot.umount_special_dirs(self.dest_dir)
logging.info(_("Gummiboot install completed successfully"))
self.settings.set('bootloader_installation_successful', True)
except subprocess.CalledProcessError as process_error:
logging.error(_('Command gummiboot failed. Error output: %s'), process_error.output)
self.settings.set('bootloader_installation_successful', False)
except subprocess.TimeoutExpired:
logging.error(_('Command gummiboot timed out.'))
self.settings.set('bootloader_installation_successful', False)
except Exception as general_error:
logging.error(_('Command gummiboot failed. Unknown Error: %s'), general_error)
self.settings.set('bootloader_installation_successful', False)
def chroot_run(cmd):
chroot.run(cmd, DEST_DIR)
def install_grub2_bios(self):
""" Install Grub2 bootloader in a BIOS system """
grub_location = self.settings.get('bootloader_device')
txt = _(
"Installing GRUB(2) BIOS boot loader in {0}".format(grub_location))
logging.info(txt)
grub_install = [
'grub-install', '--directory=/usr/lib/grub/i386-pc',
'--target=i386-pc', '--boot-directory=/boot', '--recheck'
]
logging.debug("grub-install command: {0}".format(
" ".join(grub_install)))
if len(grub_location) > len("/dev/sdX"): # ex: /dev/sdXY > 8
grub_install.append("--force")
grub_install.append(grub_location)
try:
chroot.run(grub_install, self.dest_dir, 300)
except subprocess.CalledProcessError as process_error:
logging.error(
_('Command grub-install failed. Error output: {0}'.format(
process_error.output)))
except subprocess.TimeoutExpired:
logging.error(_('Command grub-install timed out.'))
except Exception as general_error:
logging.error(
_('Command grub-install failed. Unknown Error: {0}'.format(
general_error)))
self.install_grub2_locales()
# self.copy_grub2_theme_files()
# Add -l option to os-prober's umount call so that it does not hang
self.apply_osprober_patch()
# Run grub-mkconfig last
locale = self.settings.get("locale")
try:
cmd = [
'sh', '-c',
'LANG={0} grub-mkconfig -o /boot/grub/grub.cfg'.format(locale)
]
chroot.run(cmd, self.dest_dir, 300)
except subprocess.TimeoutExpired:
logging.error(
_("grub-mkconfig does not respond. Killing grub-mount"
" and os-prober so we can continue."))
subprocess.check_call(['killall', 'grub-mount'])
subprocess.check_call(['killall', 'os-prober'])
cfg = os.path.join(self.dest_dir, "boot/grub/grub.cfg")
with open(cfg) as grub_cfg:
if "Manjaro" in grub_cfg.read():
logging.info(
_("GRUB(2) BIOS has been successfully installed."))
self.settings.set('bootloader_installation_successful', True)
else:
logging.warning(_("ERROR installing GRUB(2) BIOS."))
self.settings.set('bootloader_installation_successful', False)
