diff --git a/.gitignore b/.gitignore index d249537..94987e8 100644 --- a/.gitignore +++ b/.gitignore @@ -468,3 +468,8 @@ /anaconda-43.32.tar.bz2 /anaconda-43.33.tar.bz2 /anaconda-43.34.tar.bz2 +/anaconda-43.36.tar.bz2 +/anaconda-43.37.tar.bz2 +/anaconda-43.39.tar.bz2 +/anaconda-43.41.tar.bz2 +/anaconda-43.44.tar.bz2 diff --git a/.packit.yml b/.packit.yml index 79ff62e..b3f40ff 100644 --- a/.packit.yml +++ b/.packit.yml @@ -46,30 +46,38 @@ actions: - 'bash -c "ls -1 anaconda-*.tar.bz2"' jobs: + # Propose downstream (Fedora) - job: propose_downstream trigger: release packages: [anaconda-fedora] dist_git_branches: - main + - f43 + # Tests on PR (Fedora) - job: tests trigger: pull_request packages: [anaconda-fedora] targets: - fedora-rawhide + - fedora-43 + # COPR builds on PR (Fedora) - job: copr_build trigger: pull_request packages: [anaconda-fedora] targets: - fedora-rawhide + - fedora-43 - fedora-eln + # COPR builds on commit (Fedora): single job with multiple targets (add ELN on main) - job: copr_build trigger: commit packages: [anaconda-fedora] targets: - fedora-rawhide + - fedora-43 - fedora-eln branch: main owner: "@rhinstaller" diff --git a/0001-RebootData-don-t-allow-action-to-be-None.patch b/0001-RebootData-don-t-allow-action-to-be-None.patch new file mode 100644 index 0000000..233d91a --- /dev/null +++ b/0001-RebootData-don-t-allow-action-to-be-None.patch @@ -0,0 +1,66 @@ +From c7dce0445423e7386fdc6998a6a8de50a7a39bca Mon Sep 17 00:00:00 2001 +From: Adam Williamson +Date: Thu, 9 Oct 2025 10:07:01 -0700 +Subject: [PATCH] RebootData: don't allow action to be None + +Silverblue installs (and probably others where the kickstart data +does not explicitly specify a reboot action) crash, because +the `RebootData` instance's `action` winds up as `None`, since +this is the default value of `self.action` in +`pykickstart.commands.reboot.F23_Reboot`. Trying to translate +this to a DBus structure with `RebootData.to_structure` fails, +because DBus has no concept of `None`. + +To avoid this, let's have the setter convert `None` to `-1`, the +same value we use as a default when initializing the instance. + +Signed-off-by: Adam Williamson +--- + pyanaconda/modules/common/structures/reboot.py | 5 ++++- + .../modules/runtime/test_module_runtime.py | 10 ++++++++++ + 2 files changed, 14 insertions(+), 1 deletion(-) + +diff --git a/pyanaconda/modules/common/structures/reboot.py b/pyanaconda/modules/common/structures/reboot.py +index fd2673b169..cadbfbd01f 100644 +--- a/pyanaconda/modules/common/structures/reboot.py ++++ b/pyanaconda/modules/common/structures/reboot.py +@@ -46,7 +46,10 @@ class RebootData(DBusData): + return self._action + + @action.setter +- def action(self, value: Int): ++ def action(self, value: Int | None): ++ if value is None: ++ # dbus cannot handle None ++ value = -1 + self._action = value + + @property +diff --git a/tests/unit_tests/pyanaconda_tests/modules/runtime/test_module_runtime.py b/tests/unit_tests/pyanaconda_tests/modules/runtime/test_module_runtime.py +index 22286e59c1..83d3a123ef 100644 +--- a/tests/unit_tests/pyanaconda_tests/modules/runtime/test_module_runtime.py ++++ b/tests/unit_tests/pyanaconda_tests/modules/runtime/test_module_runtime.py +@@ -18,6 +18,7 @@ + import unittest + from textwrap import dedent + ++from pyanaconda.modules.common.structures.reboot import RebootData + from pyanaconda.modules.runtime.runtime import RuntimeService + from pyanaconda.modules.runtime.runtime_interface import RuntimeInterface + from tests.unit_tests.pyanaconda_tests import check_kickstart_interface +@@ -166,3 +167,12 @@ class RuntimeInterfaceTestCase(unittest.TestCase): + ks_in = "halt --eject\n" + ks_out = "# Halt after installation\nhalt --eject\n" + self._test_kickstart(ks_in, ks_out) ++ ++ def test_process_kickstart_with_no_payload(self): ++ """Test all values are ints when reading empty kickstart.""" ++ self.interface.ReadKickstart("") ++ assert isinstance(self.module.reboot.action, int) ++ assert isinstance(self.module.reboot.eject, int) ++ assert isinstance(self.module.reboot.kexec, int) ++ # and check we can to_structure it ++ RebootData.to_structure(self.module.reboot) +-- +2.51.0 + diff --git a/0001-pyanaconda-localization-Indicate-ASCII-support-in-ge.patch b/0001-pyanaconda-localization-Indicate-ASCII-support-in-ge.patch new file mode 100644 index 0000000..28344bb --- /dev/null +++ b/0001-pyanaconda-localization-Indicate-ASCII-support-in-ge.patch @@ -0,0 +1,139 @@ +From c6118f65fe3583e1c15c383a8a9c6f5c1989fb22 Mon Sep 17 00:00:00 2001 +From: Adam Williamson +Date: Thu, 9 Oct 2025 16:51:15 -0700 +Subject: [PATCH] pyanaconda: localization: Indicate ASCII support in + get_keyboard_layouts + +It is useful to know whether a given keyboard layout supports +ASCII input or not. Immediately, we want to use this in the +webUI keyboard logic, but it may be useful elsewhere too in +future, e.g. to warn the user if they use the Keyboard spoke +to create a configuration with no layout capable of ASCII input. + +Signed-off-by: Adam Williamson +--- + pyanaconda/localization.py | 11 +++++++++ + .../common/structures/keyboard_layout.py | 10 ++++++++ + .../modules/localization/localization.py | 2 ++ + .../localization/test_module_localization.py | 23 +++++++++++-------- + 4 files changed, 36 insertions(+), 10 deletions(-) + +diff --git a/pyanaconda/localization.py b/pyanaconda/localization.py +index 73415b2511..08a9343463 100644 +--- a/pyanaconda/localization.py ++++ b/pyanaconda/localization.py +@@ -489,6 +489,17 @@ def get_common_keyboard_layouts(): + return langtable.list_common_keyboards() + + ++def layout_supports_ascii(layout): ++ """Return a boolean indicating whether the xkb layout (given as ++ e.g. 'en(us)' or 'fr(oss)' or 'ru') can input ASCII characters. ++ ++ :return: True for ASCII capable, False for not ++ :rtype: bool ++ :param str layout: layout descriptor string ++ """ ++ return langtable.supports_ascii(layout) ++ ++ + def get_locale_timezones(locale): + """Function returning preferred timezones for the given locale. + +diff --git a/pyanaconda/modules/common/structures/keyboard_layout.py b/pyanaconda/modules/common/structures/keyboard_layout.py +index b5aacc764b..007e975965 100644 +--- a/pyanaconda/modules/common/structures/keyboard_layout.py ++++ b/pyanaconda/modules/common/structures/keyboard_layout.py +@@ -29,6 +29,7 @@ class KeyboardLayout(DBusData): + def __init__(self): + self._layout_id = "" + self._description = "" ++ self._supports_ascii = False + self._is_common = False + self._langs = [] + +@@ -59,6 +60,15 @@ class KeyboardLayout(DBusData): + def is_common(self, value: bool): + self._is_common = value + ++ @property ++ def supports_ascii(self) -> bool: ++ """Return whether the layout is capable of typing ASCII characters.""" ++ return self._supports_ascii ++ ++ @supports_ascii.setter ++ def supports_ascii(self, value: bool): ++ self._supports_ascii = value ++ + @property + def langs(self) -> List[Str]: + """Return the list of associated languages.""" +diff --git a/pyanaconda/modules/localization/localization.py b/pyanaconda/modules/localization/localization.py +index 346a55a1c0..4fb7333ed7 100644 +--- a/pyanaconda/modules/localization/localization.py ++++ b/pyanaconda/modules/localization/localization.py +@@ -33,6 +33,7 @@ from pyanaconda.localization import ( + get_language_id, + get_language_locales, + get_native_name, ++ layout_supports_ascii, + ) + from pyanaconda.modules.common.base import KickstartService + from pyanaconda.modules.common.constants.services import LOCALIZATION +@@ -218,6 +219,7 @@ class LocalizationService(KickstartService): + layout.description = self.get_layout_variant_description(name, with_lang=True, xlated=True) + layout.is_common = name.replace(" ", "") in common_langtable_keyboards and is_common_lang + layout.langs = info.langs ++ layout.supports_ascii = layout_supports_ascii(name.replace(" ", "")) + layouts.append(layout) + + return layouts +diff --git a/tests/unit_tests/pyanaconda_tests/modules/localization/test_module_localization.py b/tests/unit_tests/pyanaconda_tests/modules/localization/test_module_localization.py +index 7f6449d3ea..7582df2401 100644 +--- a/tests/unit_tests/pyanaconda_tests/modules/localization/test_module_localization.py ++++ b/tests/unit_tests/pyanaconda_tests/modules/localization/test_module_localization.py +@@ -228,28 +228,31 @@ class LocalizationInterfaceTestCase(unittest.TestCase): + normalized_layouts = KeyboardLayout.from_structure_list(layouts) + + layouts_expectation = [ +- ("ara (olpc)", "Arabic (OLPC)", "Arabic", False), +- ("cz", "Czech", "Czech", False), +- ("de (nodeadkeys)", "German (no dead keys)", "German", True), +- ("es", "Spanish", "Spanish; Castilian", True), +- ("fr (oss)", "French (alt.)", "French", True), +- ("gr", "Greek", "Greek, Modern (1453-); Greek", False), +- ("it", "Italian", "Italian", False), +- ("jp", "Japanese", "Japanese", True), +- ("us", "English (US)", "English", True), ++ ("ara (olpc)", "Arabic (OLPC)", "Arabic", False, True), ++ ("cz", "Czech", "Czech", False, True), ++ ("de (nodeadkeys)", "German (no dead keys)", "German", True, True), ++ ("es", "Spanish", "Spanish; Castilian", True, True), ++ ("fr (oss)", "French (alt.)", "French", True, True), ++ ("gr", "Greek", "Greek, Modern (1453-); Greek", False, False), ++ ("it", "Italian", "Italian", False, True), ++ ("jp", "Japanese", "Japanese", True, True), ++ ("us", "English (US)", "English", True, True), ++ ("ru (dos)", "Russian (DOS)", "Russian", False, False), + ] + +- for layout_id, description, lang, is_common in layouts_expectation: ++ for layout_id, description, lang, is_common, supports_ascii in layouts_expectation: + layout = KeyboardLayout() + layout.layout_id = layout_id + layout.description = description + layout.is_common = is_common ++ layout.supports_ascii = supports_ascii + layout.langs = [lang] + + gen = (normalized_layout for normalized_layout in normalized_layouts if layout.layout_id == normalized_layout.layout_id) + for normalized_layout in gen: + assert layout.description == normalized_layout.description + assert layout.is_common == normalized_layout.is_common ++ assert layout.supports_ascii == normalized_layout.supports_ascii + assert layout.langs == normalized_layout.langs + break + else: +-- +2.51.0 + diff --git a/6597.patch b/6597.patch new file mode 100644 index 0000000..04879c2 --- /dev/null +++ b/6597.patch @@ -0,0 +1,213 @@ +From db5bd04346372049f2b4f41484ca014e792e8939 Mon Sep 17 00:00:00 2001 +From: Radek Vykydal +Date: Thu, 28 Aug 2025 12:21:26 +0200 +Subject: [PATCH 1/2] Add GetFreeSpaceForSystem API + +For Gtk the GetFileSystemFreeSpace API was used to get free space on +mount points that will be used for system installaion. The API is not +usable for cockpit storage scenario which creates and formats the +devices before using in MANUAL partitioning (partitions assignment with +reformat=False) so they are handled as having existing formats for which +DeviceFormat.free function is used. DeviceFormat.free blivet API is +targeted specifically for file system shrinking, and for unshrinkable +file systems (for example XFS) returns 0. + +The GetFileSysetemFreeSpace API is used also for decisions about space +required for downloading and installation of DNF payload and devices +used for payload downloading so potentially handling some existing +partitions / formats. + +The patch is adding new API specifically used for obtaining free space +available for system installation. It explicitly assumes the file +systems are empty (freshly formatted) and therefore suitable +DeviceFormat.free_space_estimate blivet API is used to calculate the +value. Which goes in line with installer requirement for partitions used +for system installation (typically '/') to be formatted (either by +Cockpit Storage or Anaconda). + +Related: INSTALLER-4160 +--- + .../modules/storage/devicetree/model.py | 47 ++++++++++++++----- + .../modules/storage/devicetree/viewer.py | 10 ++++ + .../storage/devicetree/viewer_interface.py | 10 ++++ + .../storage/test_module_device_tree.py | 33 +++++++++++++ + 4 files changed, 89 insertions(+), 11 deletions(-) + +diff --git a/pyanaconda/modules/storage/devicetree/model.py b/pyanaconda/modules/storage/devicetree/model.py +index ade8072f981..aebe6a2117b 100644 +--- a/pyanaconda/modules/storage/devicetree/model.py ++++ b/pyanaconda/modules/storage/devicetree/model.py +@@ -150,14 +150,7 @@ def mountpoints(self): + def root_device(self): + return self.fsset.root_device + +- def get_file_system_free_space(self, mount_points=("/", "/usr")): +- """Get total file system free space on the given mount points. +- +- Calculates total free space in / and /usr, by default. +- +- :param mount_points: a list of mount points +- :return: a total size +- """ ++ def _get_mount_points_free_space(self, mount_points, calculate): + free = Size(0) + btrfs_volumes = [] + +@@ -174,12 +167,44 @@ def get_file_system_free_space(self, mount_points=("/", "/usr")): + else: + btrfs_volumes.append(device.volume) + ++ mp_size = calculate(device) ++ log.debug("Free size of mount point %s: %s", mount_point, mp_size.get_bytes()) ++ free += mp_size ++ ++ return free ++ ++ def get_file_system_free_space(self, mount_points): ++ """Get total file system free space on the given mount points. ++ ++ WARNING: For existing mount points the size available for resizing is ++ obtained. It means that for non resizeable format types it returns the ++ value 0. ++ ++ :param mount_points: a list of mount points ++ :return: a total size ++ """ ++ def calculate(device): + if device.format.exists: +- free += device.format.free ++ return device.format.free + else: +- free += device.format.free_space_estimate(device.size) ++ return device.format.free_space_estimate(device.size) + +- return free ++ return self._get_mount_points_free_space(mount_points, calculate) ++ ++ def get_free_space_for_system(self, mount_points): ++ """Get total space available for system on the given mount points. ++ ++ Counts the free space available on empty formatted devices. ++ ++ :param mount_points: a list of mount points ++ :return: a total size ++ """ ++ def calculate(device): ++ if device.format.exists: ++ log.debug("Free size calculation: %s considered as formatted", device) ++ return device.format.free_space_estimate(device.size) ++ ++ return self._get_mount_points_free_space(mount_points, calculate) + + def get_disk_free_space(self, disks=None): + """Get total free space on the given disks. +diff --git a/pyanaconda/modules/storage/devicetree/viewer.py b/pyanaconda/modules/storage/devicetree/viewer.py +index 49e9bf23028..6a11e4428b3 100644 +--- a/pyanaconda/modules/storage/devicetree/viewer.py ++++ b/pyanaconda/modules/storage/devicetree/viewer.py +@@ -458,6 +458,16 @@ def get_file_system_free_space(self, mount_points): + """ + return self.storage.get_file_system_free_space(mount_points).get_bytes() + ++ def get_free_space_for_system(self, mount_points): ++ """Get total space available for system on the given mount points. ++ ++ Counts the free space available on empty formatted devices. ++ ++ :param mount_points: a list of mount points ++ :return: a total size ++ """ ++ return self.storage.get_free_space_for_system(mount_points).get_bytes() ++ + def get_disk_free_space(self, disk_ids): + """Get total free space on the given disks. + +diff --git a/pyanaconda/modules/storage/devicetree/viewer_interface.py b/pyanaconda/modules/storage/devicetree/viewer_interface.py +index 84b6f701f21..06b94452a67 100644 +--- a/pyanaconda/modules/storage/devicetree/viewer_interface.py ++++ b/pyanaconda/modules/storage/devicetree/viewer_interface.py +@@ -155,6 +155,16 @@ def GetFileSystemFreeSpace(self, mount_points: List[Str]) -> UInt64: + """ + return self.implementation.get_file_system_free_space(mount_points) + ++ def GetFreeSpaceForSystem(self, mount_points: List[Str]) -> UInt64: ++ """Get total space available for system on the given mount points. ++ ++ Counts the free space available on empty formatted devices. ++ ++ :param mount_points: a list of mount points ++ :return: a total size ++ """ ++ return self.implementation.get_free_space_for_system(mount_points) ++ + def GetDiskFreeSpace(self, disk_ids: List[Str]) -> UInt64: + """Get total free space on the given disks. + +diff --git a/tests/unit_tests/pyanaconda_tests/modules/storage/test_module_device_tree.py b/tests/unit_tests/pyanaconda_tests/modules/storage/test_module_device_tree.py +index 6d4267e9ca6..8a612144884 100644 +--- a/tests/unit_tests/pyanaconda_tests/modules/storage/test_module_device_tree.py ++++ b/tests/unit_tests/pyanaconda_tests/modules/storage/test_module_device_tree.py +@@ -621,6 +621,39 @@ def test_get_file_system_free_space(self): + assert total_size < Size("10 GiB").get_bytes() + assert total_size > Size("8 GiB").get_bytes() + ++ def test_get_free_space_for_system(self): ++ """Test GetFreeSpaceForSystem.""" ++ self._add_device(StorageDevice( ++ "dev1", ++ fmt=get_format("ext4", mountpoint="/"), ++ size=Size("5 GiB")) ++ ) ++ ++ self._add_device(StorageDevice( ++ "dev2", ++ fmt=get_format("ext4", mountpoint="/usr"), ++ size=Size("5 GiB")) ++ ) ++ ++ # /home should not be counted in ++ self._add_device(StorageDevice( ++ "dev3", ++ fmt=get_format("ext4", mountpoint="/home"), ++ size=Size("5 GiB")) ++ ) ++ ++ total_size = self.interface.GetFreeSpaceForSystem([]) ++ assert total_size == 0 ++ ++ total_size = self.interface.GetFreeSpaceForSystem(["/", "/usr"]) ++ assert total_size < Size("10 GiB").get_bytes() ++ assert total_size > Size("8 GiB").get_bytes() ++ ++ # /var does not exist ++ total_size = self.interface.GetFreeSpaceForSystem(["/", "/var"]) ++ assert total_size < Size("6 GiB").get_bytes() ++ assert total_size > Size("4 GiB").get_bytes() ++ + @patch("blivet.formats.disklabel.DiskLabel.free", new_callable=PropertyMock) + @patch("blivet.formats.disklabel.DiskLabel.get_platform_label_types") + def test_get_disk_free_space(self, label_types, free): + +From a4480c8acbc3bd15cc8d9630751a400136ac55da Mon Sep 17 00:00:00 2001 +From: Radek Vykydal +Date: Thu, 28 Aug 2025 12:42:42 +0200 +Subject: [PATCH 2/2] Use new more suitable API for Gtk UI required space check + +Related: INSTALLER-4160 +--- + pyanaconda/ui/lib/space.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pyanaconda/ui/lib/space.py b/pyanaconda/ui/lib/space.py +index b81adcb0125..c3078908c75 100644 +--- a/pyanaconda/ui/lib/space.py ++++ b/pyanaconda/ui/lib/space.py +@@ -52,7 +52,7 @@ def __init__(self, payload): + + def _calculate_free_space(self): + """Calculate the available space.""" +- return Size(self.device_tree.GetFileSystemFreeSpace(("/", "/usr"))) ++ return Size(self.device_tree.GetFreeSpaceForSystem(("/", "/usr"))) + + def _calculate_needed_space(self): + """Calculate the needed space.""" diff --git a/README.packit b/README.packit index 3ad54d6..fb341a1 100644 --- a/README.packit +++ b/README.packit @@ -1,3 +1,3 @@ This repository is maintained by packit. https://packit.dev/ -The file was generated using packit 1.11.0. +The file was generated using packit 1.11.0.post1.dev7+gfdcdf3a32. diff --git a/anaconda.spec b/anaconda.spec index df8490a..8ef9745 100644 --- a/anaconda.spec +++ b/anaconda.spec @@ -1,7 +1,7 @@ Summary: Graphical system installer Name: anaconda -Version: 43.34 -Release: 1%{?dist} +Version: 43.44 +Release: 3%{?dist} ExcludeArch: %{ix86} License: GPL-2.0-or-later URL: http://fedoraproject.org/wiki/Anaconda @@ -13,16 +13,24 @@ URL: http://fedoraproject.org/wiki/Anaconda # make dist Source0: https://github.com/rhinstaller/%{name}/releases/download/%{name}-%{version}/%{name}-%{version}.tar.bz2 +# Fix crash on start in Silverblue (and probably other cases) +# https://github.com/rhinstaller/anaconda/pull/6691 +Patch: 0001-RebootData-don-t-allow-action-to-be-None.patch + +# https://github.com/rhinstaller/anaconda/pull/6692 +# Indicate ASCII support in get_keyboard_layouts +# This is needed for anaconda-webui to be able to make good +# choices, see: +# https://bugzilla.redhat.com/show_bug.cgi?id=2402430 +Patch: 0001-pyanaconda-localization-Indicate-ASCII-support-in-ge.patch + # Versions of required components (done so we make sure the buildrequires # match the requires versions of things). +%bcond glade %{undefined rhel} +%bcond live %[%{defined fedora} || %{defined eln}] %if ! 0%{?rhel} -%bcond_without glade -%bcond_without live %define blivetguiver 2.4.2-3 -%else -%bcond_with glade -%bcond_with live %endif %define dasbusver 1.3 %define dbusver 1.2.3 @@ -513,6 +521,59 @@ rm -rf \ %{_prefix}/libexec/anaconda/dd_* %changelog +* Tue Oct 14 2025 Adam Williamson - 43.44-3 +- Backport PR #6692 to provide keyboard layout ASCII info to anaconda-webui + +* Sun Oct 12 2025 Adam Williamson - 43.44-2 +- Backport PR #6691 to fix silverblue install crash + +* Thu Oct 09 2025 Packit - 43.44-1 +- flatpak: enable installation with CDROM source type (bciconel) +- storage: Improve NotEnoughFreeSpaceError message with specific request + details (k.koukiou) +- pyanaconda: storage: platform: Raise /boot to 2 GiB (neal) + +* Tue Sep 23 2025 Packit - 43.41-1 +- data: profiles: enable geolocation on Fedora Workstation live image + (matiwari) +- storage: fix mount point assignment of non-formatted swap partitions + (rvykydal) +- storage: include only fstab devices in fsset swap devices property (rvykydal) +- ui: tui: installation_source: show error message in the TUI screen + (k.koukiou) +- pyanaconda: dnf: clarify is_ready boolean return (k.koukiou) +- tui: make SoftwareSpoke ready once installation source succeeds or fails + (k.koukiou) +- spec: enable live in ELN (yselkowi) +- Mark unused variables with a leading underscore (a.badger) + +* Tue Sep 09 2025 Packit - 43.39-1 +- Fix setting of kernel console logging level for anaconda (rvykydal) +- Use new more suitable API for Gtk UI required space check (rvykydal) +- Add GetFreeSpaceForSystem API (rvykydal) +- docs: update CONTRIBUTING.rst with new branching approach (k.koukiou) + +* Fri Sep 05 2025 Katerina Koukiou - 43.37-2 +- Add GetFreeSpaceForSystem API (kkoukiou) + +* Mon Aug 25 2025 Packit - 43.37-1 +- Log correct boot option for iSCSI boot without iBFT (jstodola) +- Get full nevra string from dnf instead of composing it (pkratoch) +- Add release notes for RDP kickstart support (adamkankovsky) +- test: Enable kickstart RDP command in Anaconda (adamkankovsky) +- Enable kickstart RDP command in Anaconda (adamkankovsky) +- storage: devicetree: read VERSION or VERSION_CODENAME for identifying OS from + os-release (k.koukiou) + +* Tue Aug 19 2025 Packit - 43.36-1 +- packit: drive jobs from supported_releases per branch; dedupe and group + targets (k.koukiou) +- Fix pylint warnings caused by dynamic kickstart command imports (k.koukiou) +- core: kickstart: implement OS-release based version detection (k.koukiou) +- build: decouple BASE_CONTAINER from branch configuration (k.koukiou) +- workflows: remove hardcoded CONTAINER_TAG="lorax" usage (k.koukiou) +- dracut module requires generic initramfs (jstodola) + * Tue Aug 05 2025 Packit - 43.34-1 - Document Lorax template patching (mkolman) diff --git a/sources b/sources index d4bebec..944fc66 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (anaconda-43.34.tar.bz2) = 536ea598a71c7f6b5a7a233d2db14ca28206fe9fb4fc7fb906415d45f21843cbdde4c4bbd759c4713ff8fa26d8fb826a38eb062457c0bafedacc7d59ab92862b +SHA512 (anaconda-43.44.tar.bz2) = ea021b88ebd476f4263f3a2121fb93d374bdafaddba6134e141aad2c1c3287ce35e57e4172eb3a6ede79af9a34b28e4cd9e81be8520f4227ada5f3dbc30a2f17