perf(static): add static files to the directory

snigdhaos-calamares-config/modules/displaymanager/displaymanager.schema.yaml

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
+# SPDX-License-Identifier: GPL-3.0-or-later
+---
+$schema: https://json-schema.org/schema#
+$id: https://calamares.io/schemas/displaymanager
+additionalProperties: false
+type: object
+properties:
+    displaymanagers:
+        type: array
+        items:
+            type: string
+            enum: [slim, sddm, lightdm, gdm, mdm, lxdm, greetd]
+        minItems: 1  # Must be non-empty, if present at all
+    defaultDesktopEnvironment:
+        type: object
+        properties:
+            executable: { type: string }
+            desktopFile: { type: string }
+        required: [ executable, desktopFile ]
+    basicSetup: { type: boolean, default: false }
+    sysconfigSetup: { type: boolean, default: false }
+    greetd:
+        type: object
+        properties:
+            greeter_user: { type: string }
+            greeter_group: { type: string }
+            greeter_css_location: { type: string }
+        additionalProperties: false
+    lightdm:
+        type: object
+        properties:
+            preferred_greeters: { type: array, items: { type: string } }
+        additionalProperties: false
+    sddm:
+        type: object
+        properties:
+            configuration_file: { type: string }
+        additionalProperties: false

snigdhaos-calamares-config/modules/displaymanager/module.desc

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+---
+type:       "job"
+name:       "displaymanager"
+interface:  "python"
+script:     "main.py"

snigdhaos-calamares-config/modules/displaymanager/tests/1.global

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+rootMountPoint: /tmp

snigdhaos-calamares-config/modules/displaymanager/tests/CMakeTests.txt

@@ -0,0 +1,13 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# We have tests to load (some) of the DMs specifically, to test their
+# configuration code. Those tests conventionally live in Python
+# files here in the tests/ directory. Add them.
+foreach(_dmname greetd sddm)
+    add_test(
+        NAME configure-displaymanager-${_dmname}
+        COMMAND env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-dm-${_dmname}.py
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    )
+endforeach()

snigdhaos-calamares-config/modules/displaymanager/tests/test-dm-greetd.py

@@ -0,0 +1,33 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Calamares Boilerplate
+import libcalamares
+libcalamares.globalstorage = libcalamares.GlobalStorage(None)
+libcalamares.globalstorage.insert("testing", True)
+
+# Module prep-work
+from src.modules.displaymanager import main
+default_desktop_environment = main.DesktopEnvironment("startplasma-x11", "kde-plasma.desktop")
+
+import os
+os.makedirs("/tmp/etc/greetd/", exist_ok=True)
+try:
+    os.remove("/tmp/etc/greetd/config.toml")
+except FileNotFoundError as e:
+    pass
+
+try:
+    import toml
+except ImportError:
+    # This is a failure of the test-environment.
+    import sys
+    print("Can't find module toml.", file=sys.stderr)
+    sys.exit(0)
+
+# Specific DM test
+d = main.DMgreetd("/tmp")
+d.set_autologin("d", True, default_desktop_environment)
+# .. and again (this time checks load/save)
+d.set_autologin("d", True, default_desktop_environment)
+d.set_autologin("d", True, default_desktop_environment)

snigdhaos-calamares-config/modules/displaymanager/tests/test-dm-sddm.py

@@ -0,0 +1,18 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Calamares Boilerplate
+import libcalamares
+libcalamares.globalstorage = libcalamares.GlobalStorage(None)
+libcalamares.globalstorage.insert("testing", True)
+
+# Module prep-work
+from src.modules.displaymanager import main
+default_desktop_environment = main.DesktopEnvironment("startplasma-x11", "kde-plasma.desktop")
+
+# Specific DM test
+d = main.DMsddm("/tmp")
+d.set_autologin("d", True, default_desktop_environment)
+# .. and again (this time checks load/save)
+d.set_autologin("d", True, default_desktop_environment)
+d.set_autologin("d", True, default_desktop_environment)

snigdhaos-calamares-config/modules/packages/main.py

@@ -0,0 +1,819 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# === This file is part of Calamares - <https://calamares.io> ===
+#
+#   SPDX-FileCopyrightText: 2014 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+#   SPDX-FileCopyrightText: 2015-2017 Teo Mrnjavac <teo@kde.org>
+#   SPDX-FileCopyrightText: 2016-2017 Kyle Robbertze <kyle@aims.ac.za>
+#   SPDX-FileCopyrightText: 2017 Alf Gaida <agaida@siduction.org>
+#   SPDX-FileCopyrightText: 2018 Adriaan de Groot <groot@kde.org>
+#   SPDX-FileCopyrightText: 2018 Philip Müller <philm@manjaro.org>
+#   SPDX-License-Identifier: GPL-3.0-or-later
+#
+#   Calamares is Free Software: see the License-Identifier above.
+#
+
+import abc
+from string import Template
+import subprocess
+
+import libcalamares
+from libcalamares.utils import check_target_env_call, target_env_call
+from libcalamares.utils import gettext_path, gettext_languages
+
+import gettext
+_translation = gettext.translation("calamares-python",
+                                   localedir=gettext_path(),
+                                   languages=gettext_languages(),
+                                   fallback=True)
+_ = _translation.gettext
+_n = _translation.ngettext
+
+
+total_packages = 0  # For the entire job
+completed_packages = 0  # Done so far for this job
+group_packages = 0  # One group of packages from an -install or -remove entry
+
+# A PM object may set this to a string (take care of translations!)
+# to override the string produced by pretty_status_message()
+custom_status_message = None
+
+INSTALL = object()
+REMOVE = object()
+mode_packages = None  # Changes to INSTALL or REMOVE
+
+
+def _change_mode(mode):
+    global mode_packages
+    mode_packages = mode
+    libcalamares.job.setprogress(completed_packages * 1.0 / total_packages)
+
+
+def pretty_name():
+    return _("Install packages.")
+
+
+def pretty_status_message():
+    if custom_status_message is not None:
+        return custom_status_message
+    if not group_packages:
+        if (total_packages > 0):
+            # Outside the context of an operation
+            s = _("Processing packages (%(count)d / %(total)d)")
+        else:
+            s = _("Install packages.")
+
+    elif mode_packages is INSTALL:
+        s = _n("Installing one package.",
+               "Installing %(num)d packages.", group_packages)
+    elif mode_packages is REMOVE:
+        s = _n("Removing one package.",
+               "Removing %(num)d packages.", group_packages)
+    else:
+        # No mode, generic description
+        s = _("Install packages.")
+
+    return s % {"num": group_packages,
+                "count": completed_packages,
+                "total": total_packages}
+
+
+class PackageManager(metaclass=abc.ABCMeta):
+    """
+    Package manager base class. A subclass implements package management
+    for a specific backend, and must have a class property `backend`
+    with the string identifier for that backend.
+
+    Subclasses are collected below to populate the list of possible
+    backends.
+    """
+    backend = None
+
+    @abc.abstractmethod
+    def install(self, pkgs, from_local=False):
+        """
+        Install a list of packages (named) into the system.
+        Although this handles lists, in practice it is called
+        with one package at a time.
+
+        @param pkgs: list[str]
+            list of package names
+        @param from_local: bool
+            if True, then these are local packages (on disk) and the
+            pkgs names are paths.
+        """
+        pass
+
+    @abc.abstractmethod
+    def remove(self, pkgs):
+        """
+        Removes packages.
+
+        @param pkgs: list[str]
+            list of package names
+        """
+        pass
+
+    @abc.abstractmethod
+    def update_db(self):
+        pass
+
+    def run(self, script):
+        if script != "":
+            check_target_env_call(script.split(" "))
+
+    def install_package(self, packagedata, from_local=False):
+        """
+        Install a package from a single entry in the install list.
+        This can be either a single package name, or an object
+        with pre- and post-scripts. If @p packagedata is a dict,
+        it is assumed to follow the documented structure.
+
+        @param packagedata: str|dict
+        @param from_local: bool
+            see install.from_local
+        """
+        if isinstance(packagedata, str):
+            self.install([packagedata], from_local=from_local)
+        else:
+            self.run(packagedata["pre-script"])
+            self.install([packagedata["package"]], from_local=from_local)
+            self.run(packagedata["post-script"])
+
+    def remove_package(self, packagedata):
+        """
+        Remove a package from a single entry in the remove list.
+        This can be either a single package name, or an object
+        with pre- and post-scripts. If @p packagedata is a dict,
+        it is assumed to follow the documented structure.
+
+        @param packagedata: str|dict
+        """
+        if isinstance(packagedata, str):
+            self.remove([packagedata])
+        else:
+            self.run(packagedata["pre-script"])
+            self.remove([packagedata["package"]])
+            self.run(packagedata["post-script"])
+
+    def operation_install(self, package_list, from_local=False):
+        """
+        Installs the list of packages named in @p package_list .
+        These can be strings -- plain package names -- or
+        structures (with a pre- and post-install step).
+
+        This operation is called for "critical" packages,
+        which are expected to succeed, or fail, all together.
+        However, if there are packages with pre- or post-scripts,
+        then packages are installed one-by-one instead.
+
+        NOTE: package managers may reimplement this method
+        NOTE: exceptions are expected to leave this method, to indicate
+              failure of the installation.
+        """
+        if all([isinstance(x, str) for x in package_list]):
+            self.install(package_list, from_local=from_local)
+        else:
+            for package in package_list:
+                self.install_package(package, from_local=from_local)
+
+    def operation_try_install(self, package_list):
+        """
+        Installs the list of packages named in @p package_list .
+        These can be strings -- plain package names -- or
+        structures (with a pre- and post-install step).
+
+        This operation is called for "non-critical" packages,
+        which can succeed or fail without affecting the overall installation.
+        Packages are installed one-by-one to support package managers
+        that do not have a "install as much as you can" mode.
+
+        NOTE: package managers may reimplement this method
+        NOTE: no package-installation exceptions should be raised
+        """
+        # we make a separate package manager call for each package so a
+        # single failing package won't stop all of them
+        for package in package_list:
+            try:
+                self.install_package(package)
+            except subprocess.CalledProcessError:
+                libcalamares.utils.warning("Could not install package %s" % package)
+
+    def operation_remove(self, package_list):
+        """
+        Removes the list of packages named in @p package_list .
+        These can be strings -- plain package names -- or
+        structures (with a pre- and post-install step).
+
+        This operation is called for "critical" packages, which are
+        expected to succeed or fail all together.
+        However, if there are packages with pre- or post-scripts,
+        then packages are removed one-by-one instead.
+
+        NOTE: package managers may reimplement this method
+        NOTE: exceptions should be raised to indicate failure
+        """
+        if all([isinstance(x, str) for x in package_list]):
+            self.remove(package_list)
+        else:
+            for package in package_list:
+                self.remove_package(package)
+
+    def operation_try_remove(self, package_list):
+        """
+        Same relation as try_install has to install, except it removes
+        packages instead. Packages are removed one-by-one.
+
+        NOTE: package managers may reimplement this method
+        NOTE: no package-installation exceptions should be raised
+        """
+        for package in package_list:
+            try:
+                self.remove_package(package)
+            except subprocess.CalledProcessError:
+                libcalamares.utils.warning("Could not remove package %s" % package)
+
+### PACKAGE MANAGER IMPLEMENTATIONS
+#
+# Keep these alphabetical (presumably both by class name and backend name),
+# even the Dummy implementation.
+#
+
+class PMApk(PackageManager):
+    backend = "apk"
+
+    def install(self, pkgs, from_local=False):
+        for pkg in pkgs:
+            check_target_env_call(["apk", "add", pkg])
+
+    def remove(self, pkgs):
+        for pkg in pkgs:
+            check_target_env_call(["apk", "del", pkg])
+
+    def update_db(self):
+        check_target_env_call(["apk", "update"])
+
+    def update_system(self):
+        check_target_env_call(["apk", "upgrade", "--available"])
+
+
+class PMApt(PackageManager):
+    backend = "apt"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["apt-get", "-q", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["apt-get", "--purge", "-q", "-y",
+                               "remove"] + pkgs)
+        check_target_env_call(["apt-get", "--purge", "-q", "-y",
+                               "autoremove"])
+
+    def update_db(self):
+        check_target_env_call(["apt-get", "update"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+class PMDnf(PackageManager):
+    """
+    This is "legacy" DNF, called DNF-4 even though the
+    executable is dnf-3 in modern Fedora. Executable dnf
+    is a symlink to dnf-3 in systems that use it.
+    """
+    backend = "dnf"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["dnf-3", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        # ignore the error code for now because dnf thinks removing a
+        # nonexistent package is an error
+        target_env_call(["dnf-3", "--disablerepo=*", "-C", "-y",
+                         "remove"] + pkgs)
+
+    def update_db(self):
+        # Doesn't need updates
+        pass
+
+    def update_system(self):
+        check_target_env_call(["dnf-3", "-y", "upgrade"])
+
+
+class PMDnf5(PackageManager):
+    """
+    This is "modern" DNF, DNF-5 which is for Fedora 41 (presumably)
+    and later. Executable dnf is a symlink to dnf5 in systems that use it.
+    """
+    backend = "dnf5"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["dnf5", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        # ignore the error code for now because dnf thinks removing a
+        # nonexistent package is an error
+        target_env_call(["dnf5", "--disablerepo=*", "-C", "-y",
+                         "remove"] + pkgs)
+
+    def update_db(self):
+        # Doesn't need updates
+        pass
+
+    def update_system(self):
+        check_target_env_call(["dnf5", "-y", "upgrade"])
+
+
+class PMDummy(PackageManager):
+    backend = "dummy"
+
+    def install(self, pkgs, from_local=False):
+        from time import sleep
+        libcalamares.utils.debug("Dummy backend: Installing " + str(pkgs))
+        sleep(3)
+
+    def remove(self, pkgs):
+        from time import sleep
+        libcalamares.utils.debug("Dummy backend: Removing " + str(pkgs))
+        sleep(3)
+
+    def update_db(self):
+        libcalamares.utils.debug("Dummy backend: Updating DB")
+
+    def update_system(self):
+        libcalamares.utils.debug("Dummy backend: Updating System")
+
+    def run(self, script):
+        libcalamares.utils.debug("Dummy backend: Running script '" + str(script) + "'")
+
+
+class PMEntropy(PackageManager):
+    backend = "entropy"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["equo", "i"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["equo", "rm"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["equo", "update"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+class PMFlatpak(PackageManager):
+    backend = "flatpak"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["flatpak", "install", "--assumeyes"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["flatpak", "uninstall", "--noninteractive"] + pkgs)
+
+    def update_db(self):
+        pass
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+class PMLuet(PackageManager):
+    backend = "luet"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["luet", "install", "-y"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["luet", "uninstall", "-y"] + pkgs)
+
+    def update_db(self):
+          # Luet checks for DB update everytime its ran.
+        pass
+
+    def update_system(self):
+        check_target_env_call(["luet", "upgrade", "-y"])
+
+
+class PMPackageKit(PackageManager):
+    backend = "packagekit"
+
+    def install(self, pkgs, from_local=False):
+        for pkg in pkgs:
+            check_target_env_call(["pkcon", "-py", "install", pkg])
+
+    def remove(self, pkgs):
+        for pkg in pkgs:
+            check_target_env_call(["pkcon", "-py", "remove", pkg])
+
+    def update_db(self):
+        check_target_env_call(["pkcon", "refresh"])
+
+    def update_system(self):
+        check_target_env_call(["pkcon", "-py", "update"])
+
+
+class PMPacman(PackageManager):
+    backend = "pacman"
+
+    def __init__(self):
+        import re
+        progress_match = re.compile("^\\((\\d+)/(\\d+)\\)")
+
+        def line_cb(line):
+            if line.startswith(":: "):
+                self.in_package_changes = "package" in line or "hooks" in line
+            else:
+                if self.in_package_changes and line.endswith("...\n"):
+                    # Update the message, untranslated; do not change the
+                    # progress percentage, since there may be more "installing..."
+                    # lines in the output for the group, than packages listed
+                    # explicitly. We don't know how to calculate proper progress.
+                    global custom_status_message
+                    custom_status_message = "pacman: " + line.strip()
+                    libcalamares.job.setprogress(self.progress_fraction)
+            libcalamares.utils.debug(line)
+
+        self.in_package_changes = False
+        self.line_cb = line_cb
+
+        pacman = libcalamares.job.configuration.get("pacman", None)
+        if pacman is None:
+            pacman = dict()
+        if type(pacman) is not dict:
+            libcalamares.utils.warning("Job configuration *pacman* will be ignored.")
+            pacman = dict()
+        self.pacman_num_retries = pacman.get("num_retries", 0)
+        self.pacman_disable_timeout = pacman.get("disable_download_timeout", False)
+        self.pacman_needed_only = pacman.get("needed_only", False)
+
+    def reset_progress(self):
+        self.in_package_changes = False
+        # These are globals
+        self.progress_fraction = (completed_packages * 1.0 / total_packages)
+
+    def run_pacman(self, command, callback=False):
+        """
+        Call pacman in a loop until it is successful or the number of retries is exceeded
+        :param command: The pacman command to run
+        :param callback: An optional boolean that indicates if this pacman run should use the callback
+        :return:
+        """
+
+        pacman_count = 0
+        while pacman_count <= self.pacman_num_retries:
+            pacman_count += 1
+            try:
+                if False: # callback:
+                    libcalamares.utils.target_env_process_output(command, self.line_cb)
+                else:
+                    libcalamares.utils.target_env_process_output(command)
+
+                return
+            except subprocess.CalledProcessError:
+                if pacman_count <= self.pacman_num_retries:
+                    pass
+                else:
+                    raise
+
+    def install(self, pkgs, from_local=False):
+        command = ["pacman"]
+
+        if from_local:
+            command.append("-U")
+        else:
+            command.append("-S")
+
+        # Don't ask for user intervention, take the default action
+        command.append("--noconfirm")
+
+        # Don't report download progress for each file
+        command.append("--noprogressbar")
+
+        if self.pacman_needed_only is True:
+            command.append("--needed")
+            command.append("--ask=4")
+
+        if self.pacman_disable_timeout is True:
+            command.append("--disable-download-timeout")
+
+        command += pkgs
+
+        self.reset_progress()
+        self.run_pacman(command, True)
+
+    def remove(self, pkgs):
+        self.reset_progress()
+        self.run_pacman(["pacman", "-Rs", "--noconfirm"] + pkgs, True)
+
+    def update_db(self):
+        self.run_pacman(["pacman", "-Sy"])
+
+    def update_system(self):
+        self.run_pacman(["pacman", "-S", "archlinux-keyring", "--noconfirm"])
+        command = ["pacman", "-Su", "--noconfirm"]
+        if self.pacman_disable_timeout is True:
+            command.append("--disable-download-timeout")
+
+        self.run_pacman(command)
+
+
+class PMPamac(PackageManager):
+    backend = "pamac"
+
+    def del_db_lock(self, lock="/var/lib/pacman/db.lck"):
+        # In case some error or crash, the database will be locked,
+        # resulting in remaining packages not being installed.
+        check_target_env_call(["rm", "-f", lock])
+
+    def install(self, pkgs, from_local=False):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "install", "--no-confirm"] + pkgs)
+
+    def remove(self, pkgs):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "remove", "--no-confirm"] + pkgs)
+
+    def update_db(self):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "update", "--no-confirm"])
+
+    def update_system(self):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "upgrade", "--no-confirm"])
+
+
+class PMPisi(PackageManager):
+    backend = "pisi"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["pisi", "install" "-y"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["pisi", "remove", "-y"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["pisi", "update-repo"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+class PMPortage(PackageManager):
+    backend = "portage"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["emerge", "-v"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["emerge", "-C"] + pkgs)
+        check_target_env_call(["emerge", "--depclean", "-q"])
+
+    def update_db(self):
+        check_target_env_call(["emerge", "--sync"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+class PMXbps(PackageManager):
+    backend = "xbps"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["xbps-install", "-Sy"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["xbps-remove", "-Ry", "--noconfirm"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["xbps-install", "-S"])
+
+    def update_system(self):
+        check_target_env_call(["xbps", "-Suy"])
+
+
+class PMYum(PackageManager):
+    backend = "yum"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["yum", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["yum", "--disablerepo=*", "-C", "-y",
+                               "remove"] + pkgs)
+
+    def update_db(self):
+        # Doesn't need updates
+        pass
+
+    def update_system(self):
+        check_target_env_call(["yum", "-y", "upgrade"])
+
+
+class PMZypp(PackageManager):
+    backend = "zypp"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["zypper", "--non-interactive",
+                               "--quiet-install", "install",
+                               "--auto-agree-with-licenses",
+                               "install"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["zypper", "--non-interactive",
+                               "remove"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["zypper", "--non-interactive", "update"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+# Collect all the subclasses of PackageManager defined above,
+# and index them based on the backend property of each class.
+backend_managers = [
+    (c.backend, c)
+    for c in globals().values()
+    if type(c) is abc.ABCMeta and issubclass(c, PackageManager) and c.backend]
+
+
+def subst_locale(plist):
+    """
+    Returns a locale-aware list of packages, based on @p plist.
+    Package names that contain LOCALE are localized with the
+    BCP47 name of the chosen system locale; if the system
+    locale is 'en' (e.g. English, US) then these localized
+    packages are dropped from the list.
+
+    @param plist: list[str|dict]
+        Candidate packages to install.
+    @return: list[str|dict]
+    """
+    locale = libcalamares.globalstorage.value("locale")
+    if not locale:
+        # It is possible to skip the locale-setting entirely.
+        # Then pretend it is "en", so that {LOCALE}-decorated
+        # package names are removed from the list.
+        locale = "en"
+
+    ret = []
+    for packagedata in plist:
+        if isinstance(packagedata, str):
+            packagename = packagedata
+        else:
+            packagename = packagedata["package"]
+
+        # Update packagename: substitute LOCALE, and drop packages
+        # if locale is en and LOCALE is in the package name.
+        if locale != "en":
+            packagename = Template(packagename).safe_substitute(LOCALE=locale)
+        elif 'LOCALE' in packagename:
+            packagename = None
+
+        if packagename is not None:
+            # Put it back in packagedata
+            if isinstance(packagedata, str):
+                packagedata = packagename
+            else:
+                packagedata["package"] = packagename
+
+            ret.append(packagedata)
+
+    return ret
+
+
+def run_operations(pkgman, entry):
+    """
+    Call package manager with suitable parameters for the given
+    package actions.
+
+    :param pkgman: PackageManager
+        This is the manager that does the actual work.
+    :param entry: dict
+        Keys are the actions -- e.g. "install" -- to take, and the values
+        are the (list of) packages to apply the action to. The actions are
+        not iterated in a specific order, so it is recommended to use only
+        one action per dictionary. The list of packages may be package
+        names (strings) or package information dictionaries with pre-
+        and post-scripts.
+    """
+    global group_packages, completed_packages, mode_packages
+
+    for key in entry.keys():
+        package_list = subst_locale(entry[key])
+        group_packages = len(package_list)
+        if key == "install":
+            _change_mode(INSTALL)
+            pkgman.operation_install(package_list)
+        elif key == "try_install":
+            _change_mode(INSTALL)
+            pkgman.operation_try_install(package_list)
+        elif key == "remove":
+            _change_mode(REMOVE)
+            pkgman.operation_remove(package_list)
+        elif key == "try_remove":
+            _change_mode(REMOVE)
+            pkgman.operation_try_remove(package_list)
+        elif key == "localInstall":
+            _change_mode(INSTALL)
+            pkgman.operation_install(package_list, from_local=True)
+        elif key == "source":
+            libcalamares.utils.debug("Package-list from {!s}".format(entry[key]))
+        else:
+            libcalamares.utils.warning("Unknown package-operation key {!s}".format(key))
+        completed_packages += len(package_list)
+        libcalamares.job.setprogress(completed_packages * 1.0 / total_packages)
+        libcalamares.utils.debug("Pretty name: {!s}, setting progress..".format(pretty_name()))
+
+    group_packages = 0
+    _change_mode(None)
+
+
+def run():
+    """
+    Calls routine with detected package manager to install locale packages
+    or remove drivers not needed on the installed system.
+
+    :return:
+    """
+    global mode_packages, total_packages, completed_packages, group_packages
+
+    backend = libcalamares.job.configuration.get("backend")
+
+    for identifier, impl in backend_managers:
+        if identifier == backend:
+            pkgman = impl()
+            break
+    else:
+        return "Bad backend", "backend=\"{}\"".format(backend)
+
+    skip_this = libcalamares.job.configuration.get("skip_if_no_internet", False)
+    if skip_this and not libcalamares.globalstorage.value("hasInternet"):
+        libcalamares.utils.warning( "Package installation has been skipped: no internet" )
+        return None
+
+    update_db = libcalamares.job.configuration.get("update_db", False)
+    if update_db and libcalamares.globalstorage.value("hasInternet"):
+        try:
+            pkgman.update_db()
+        except subprocess.CalledProcessError as e:
+            libcalamares.utils.warning(str(e))
+            libcalamares.utils.debug("stdout:" + str(e.stdout))
+            libcalamares.utils.debug("stderr:" + str(e.stderr))
+            return (_("Package Manager error"),
+                    _("The package manager could not prepare updates. The command <pre>{!s}</pre> returned error code {!s}.")
+                    .format(e.cmd, e.returncode))
+
+    update_system = libcalamares.job.configuration.get("update_system", False)
+    if update_system and libcalamares.globalstorage.value("hasInternet"):
+        try:
+            pkgman.update_system()
+        except subprocess.CalledProcessError as e:
+            libcalamares.utils.warning(str(e))
+            libcalamares.utils.debug("stdout:" + str(e.stdout))
+            libcalamares.utils.debug("stderr:" + str(e.stderr))
+            return (_("Package Manager error"),
+                    _("The package manager could not update the system. The command <pre>{!s}</pre> returned error code {!s}.")
+                    .format(e.cmd, e.returncode))
+
+    operations = libcalamares.job.configuration.get("operations", [])
+    if libcalamares.globalstorage.contains("packageOperations"):
+        operations += libcalamares.globalstorage.value("packageOperations")
+
+    mode_packages = None
+    total_packages = 0
+    completed_packages = 0
+    for op in operations:
+        for packagelist in op.values():
+            total_packages += len(subst_locale(packagelist))
+
+    if not total_packages:
+        # Avoids potential divide-by-zero in progress reporting
+        return None
+
+    for entry in operations:
+        group_packages = 0
+        libcalamares.utils.debug(pretty_name())
+        try:
+            run_operations(pkgman, entry)
+        except subprocess.CalledProcessError as e:
+            libcalamares.utils.warning(str(e))
+            libcalamares.utils.debug("stdout:" + str(e.stdout))
+            libcalamares.utils.debug("stderr:" + str(e.stderr))
+            return (_("Package Manager error"),
+                    _("The package manager could not make changes to the installed system. The command <pre>{!s}</pre> returned error code {!s}.")
+                    .format(e.cmd, e.returncode))
+
+    mode_packages = None
+
+    libcalamares.job.setprogress(1.0)
+
+    return None

snigdhaos-calamares-config/modules/packages/module.desc

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+---
+type:       "job"
+name:       "packages"
+interface:  "python"
+script:     "main.py"

snigdhaos-calamares-config/modules/packages/packages.schema.yaml

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
+# SPDX-License-Identifier: GPL-3.0-or-later
+---
+$schema: https://json-schema.org/schema#
+$id: https://calamares.io/schemas/packages
+additionalProperties: false
+type: object
+properties:
+    backend:
+        type: string
+        enum:
+            - apk
+            - apt
+            - dnf
+            - dnf5
+            - entropy
+            - luet
+            - packagekit
+            - pacman
+            - pamac
+            - portage
+            - yum
+            - zypp
+            - dummy
+
+    update_db: { type: boolean, default: true }
+    update_system: { type: boolean, default: false }
+    skip_if_no_internet: { type: boolean, default: false }
+
+    pacman:
+        additionalProperties: false
+        type: object
+        properties:
+            num_retries: { type: integer, default: 0 }
+            disable_download_timeout: { type: boolean, default: false }
+            needed_only: { type: boolean, default: false }
+
+    operations:
+        type: array
+        items:
+            additionalProperties: false
+            type: object
+            properties:
+                # TODO: these are either-string-or-struct items,
+                #       need their own little schema.
+                install: { type: array }
+                remove: { type: array }
+                try_install: { type: array }
+                try_remove: { type: array }
+                localInstall: { type: array }
+                source: { type: string }
+
+
+required: [ backend ]

snigdhaos-calamares-config/modules/packages/tests/1.global

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+rootMountPoint: /tmp

snigdhaos-calamares-config/modules/packages/tests/2.job

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+backend: dummy
+operations:
+  - install:
+    - pre-script: touch /tmp/foo
+      package: vi
+      post-script: rm /tmp/foo
+    - wget
+    - binutils
+  - remove:
+    - vi
+    - wget

snigdhaos-calamares-config/modules/packages/tests/CMakeTests.txt

@@ -0,0 +1,46 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# We have tests to load (some) of the package-managers specifically, to
+# test their configuration code and implementation. Those tests conventionally
+# live in Python files here in the tests/ directory. Add them.
+
+# Pacman (Arch) tests
+set(_pm pacman)
+add_test(
+    NAME configure-packages-${_pm}
+    COMMAND env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-pm-${_pm}.py
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+add_test(
+    NAME configure-packages-${_pm}-ops-1
+    COMMAND
+        env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-pm-${_pm}.py ${CMAKE_CURRENT_LIST_DIR}/pm-pacman-1.yaml
+        4 1 1
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+add_test(
+    NAME configure-packages-${_pm}-ops-2
+    COMMAND
+        env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-pm-${_pm}.py ${CMAKE_CURRENT_LIST_DIR}/pm-pacman-2.yaml
+        3 0 0
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+
+if(BUILD_TESTING AND BUILD_SCHEMA_TESTING AND Python_Interpreter_FOUND)
+    set(_module packages)
+    set(_schema_file "${CMAKE_CURRENT_SOURCE_DIR}/${_module}/${_module}.schema.yaml")
+    message(STATUS "Schema ${_schema_file}")
+    foreach(_cf pm-pacman-1.yaml pm-pacman-2.yaml)
+        set(_conf_file "${CMAKE_CURRENT_SOURCE_DIR}/${_module}/tests/${_cf}")
+        if(EXISTS "${_schema_file}" AND EXISTS "${_conf_file}")
+            add_test(
+                NAME validate-packages-${_cf}
+                COMMAND
+                    ${Python_EXECUTABLE} "${CMAKE_SOURCE_DIR}/ci/configvalidator.py" "${_schema_file}" "${_conf_file}"
+            )
+        else()
+            message(FATAL_ERROR "Missing ${_conf_file}")
+        endif()
+    endforeach()
+endif()

snigdhaos-calamares-config/modules/packages/tests/pm-pacman-1.yaml

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+backend: pacman
+operations: []
+
+pacman:
+    num_retries: 4
+    disable_download_timeout: true
+    needed_only: true
+

snigdhaos-calamares-config/modules/packages/tests/pm-pacman-2.yaml

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+backend: pacman
+operations: []
+
+# Leave some things unspecified
+pacman:
+    num_retries: 3
+

snigdhaos-calamares-config/modules/packages/tests/test-pm-pacman.py

@@ -0,0 +1,36 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Calamares Boilerplate
+import libcalamares
+libcalamares.globalstorage = libcalamares.GlobalStorage(None)
+libcalamares.globalstorage.insert("testing", True)
+
+# Module prep-work
+from src.modules.packages import main
+
+# .. we don't have a job in this test, so fake one
+class Job(object):
+    def __init__(self, filename):
+        self.configuration = libcalamares.utils.load_yaml(filename) if filename is not None else dict()
+
+import sys
+if len(sys.argv) > 4:
+    filename = sys.argv[1]
+    retry = int(sys.argv[2])
+    timeout = bool(int(sys.argv[3]))
+    needed = bool(int(sys.argv[4]))
+else:
+    filename = None
+    retry = 0
+    timeout = False
+    needed = False
+
+libcalamares.utils.warning("Expecting {!s} retry={!s} timeout={!s} needed={!s}".format(filename, retry, timeout, needed))
+
+# Specific PM test
+libcalamares.job = Job(filename)
+p = main.PMPacman()
+assert p.pacman_num_retries == retry, "{!r} vs {!r}".format(p.pacman_num_retries, retry)
+assert p.pacman_disable_timeout == timeout, "{!r} vs {!r}".format(p.pacman_disable_timeout, timeout)
+assert p.pacman_needed_only == needed, "{!r} vs {!r}".format(p.pacman_needed_only, needed)

snigdhaos-calamares-config/modules/ucode/main.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# === This file is part of Calamares - <http://github.com/calamares> ===
+#
+#   Copyright 2014 - 2019, Philip Müller <philm@manjaro.org>
+#   Copyright 2016, Artoo <artoo@manjaro.org>
+#
+#   Calamares is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Calamares is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Calamares. If not, see <http://www.gnu.org/licenses/>.
+
+import libcalamares
+import subprocess
+
+from shutil import copy2
+from distutils.dir_util import copy_tree
+from os.path import join, exists
+from libcalamares.utils import target_env_call
+
+
+class ConfigController:
+    def __init__(self):
+        self.__root = libcalamares.globalstorage.value("rootMountPoint")
+        self.__keyrings = libcalamares.job.configuration.get('keyrings', [])
+
+    @property
+    def root(self):
+        return self.__root
+
+    @property
+    def keyrings(self):
+        return self.__keyrings
+
+    def init_keyring(self):
+        target_env_call(["pacman-key", "--init"])
+
+    def populate_keyring(self):
+        target_env_call(["pacman-key", "--populate"] + self.keyrings)
+
+    def terminate(self, proc):
+        target_env_call(['killall', '-9', proc])
+
+    def copy_file(self, file):
+        if exists("/" + file):
+            copy2("/" + file, join(self.root, file))
+
+    def copy_folder(self, source, target):
+        if exists("/" + source):
+            copy_tree("/" + source, join(self.root, target))
+
+    def remove_pkg(self, pkg, path):
+        if exists(join(self.root, path)):
+            target_env_call(['pacman', '-R', '--noconfirm', pkg])
+
+    def umount(self, mp):
+        subprocess.call(["umount", "-l", join(self.root, mp)])
+
+    def mount(self, mp):
+        subprocess.call(["mount", "-B", "/" + mp, join(self.root, mp)])
+
+    def rmdir(self, dir):
+        subprocess.call(["rm", "-Rf", join(self.root, dir)])
+
+    def mkdir(self, dir):
+        subprocess.call(["mkdir", "-p", join(self.root, dir)])
+
+    def run(self):
+
+        # ucode
+        cpu_ucode = subprocess.getoutput("hwinfo --cpu | grep Vendor: -m1 | cut -d\'\"\' -f2")
+        if cpu_ucode == "AuthenticAMD":
+            #target_env_call(["pacman", "-S", "amd-ucode", "--noconfirm"])
+            target_env_call(["pacman", "-R", "intel-ucode", "--noconfirm"])
+        elif cpu_ucode == "GenuineIntel":
+            #target_env_call(["pacman", "-S", "intel-ucode", "--noconfirm"])
+            target_env_call(["pacman", "-R", "amd-ucode", "--noconfirm"])
+
+        if exists(join(self.root, "usr/bin/snapper")):
+            target_env_call(["snapper", "-c", "root", "--no-dbus", "create-config", "/"])
+            target_env_call(["btrfs", "subvolume", "create", "/.snapshots"])
+            target_env_call(["chmod", "a+rx", "/.snapshots"])
+            target_env_call(["chown", ":users", "/.snapshots"])
+
+def run():
+    """ Post installation configurations  """
+
+    config = ConfigController()
+
+    return config.run()

snigdhaos-calamares-config/modules/ucode/module.desc

@@ -0,0 +1,6 @@
+# Syntax is YAML 1.2
+---
+type:       "job"
+name:       "ucode"
+interface:  "python"
+script:     "main.py"   #assumed relative to the current directory