Update enable_repo from osmorphing for all redhat based OSes

Author: fabi200123

coriolis/osmorphing/amazon.py

@@ -1,12 +1,18 @@
 # Copyright 2023 Cloudbase Solutions Srl
 # All Rights Reserved.
 
+from oslo_log import log as logging
+
+from coriolis import exception
 from coriolis.osmorphing.osdetect import amazon as amazon_detect
 from coriolis.osmorphing import redhat
+from coriolis import utils
 
 
 AMAZON_DISTRO_NAME_IDENTIFIER = amazon_detect.AMAZON_DISTRO_NAME
 
+LOG = logging.getLogger(__name__)
+
 
 class BaseAmazonLinuxOSMorphingTools(redhat.BaseRedHatMorphingTools):
 
@@ -19,3 +25,39 @@ def check_os_supported(cls, detected_os_info):
             return False
         return cls._version_supported_util(
             detected_os_info['release_version'], minimum=2)
+
+    def enable_repos(self, repo_names):
+        """Enable repositories for Amazon Linux.
+
+        Uses yum-config-manager for Amazon Linux 2,
+        dnf config-manager for Amazon Linux 2023 and later.
+        """
+        if not repo_names:
+            return
+
+        # Determine package manager based on version
+        # Amazon Linux 2 has version "2", AL2023 has version "2023"
+        try:
+            major_version = int(str(self._version).split('.')[0])
+        except (ValueError, AttributeError):
+            # Fallback to yum if version parsing fails
+            major_version = 2
+
+        if major_version >= 2023:
+            # Amazon Linux 2023+ uses dnf
+            config_manager = 'dnf config-manager'
+            enable_flag = '--set-enabled %s'
+        else:
+            # Amazon Linux 2 and earlier use yum
+            config_manager = 'yum-config-manager'
+            enable_flag = '--enable %s'
+
+        for repo in repo_names:
+            cmd = '%s %s' % (config_manager, enable_flag % repo)
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using %s",
+                         repo, config_manager)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")

coriolis/osmorphing/centos.py

@@ -1,14 +1,19 @@
 # Copyright 2020 Cloudbase Solutions Srl
 # All Rights Reserved.
 
+from oslo_log import log as logging
 
+from coriolis import exception
 from coriolis.osmorphing.osdetect import centos as centos_detect
 from coriolis.osmorphing import redhat
+from coriolis import utils
 
 
 CENTOS_DISTRO_IDENTIFIER = centos_detect.CENTOS_DISTRO_IDENTIFIER
 CENTOS_STREAM_DISTRO_IDENTIFIER = centos_detect.CENTOS_STREAM_DISTRO_IDENTIFIER
 
+LOG = logging.getLogger(__name__)
+
 
 class BaseCentOSMorphingTools(redhat.BaseRedHatMorphingTools):
 
@@ -22,3 +27,33 @@ def check_os_supported(cls, detected_os_info):
             return False
         return cls._version_supported_util(
             detected_os_info['release_version'], minimum=6)
+
+    def enable_repos(self, repo_names):
+        """Enable repositories for CentOS.
+
+        Uses yum-config-manager for CentOS 7 and earlier,
+        dnf config-manager for CentOS 8 and later.
+        """
+        if not repo_names:
+            return
+
+        # Determine package manager based on version
+        major_version = int(str(self._version).split('.')[0])
+        if major_version >= 8:
+            # CentOS 8+ uses dnf
+            config_manager = 'dnf config-manager'
+            enable_flag = '--set-enabled %s'
+        else:
+            # CentOS 7 and earlier use yum
+            config_manager = 'yum-config-manager'
+            enable_flag = '--enable %s'
+
+        for repo in repo_names:
+            cmd = '%s %s' % (config_manager, enable_flag % repo)
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using %s",
+                         repo, config_manager)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")

coriolis/osmorphing/oracle.py

@@ -1,14 +1,18 @@
 # Copyright 2016 Cloudbase Solutions Srl
 # All Rights Reserved.
 
-import uuid
+from oslo_log import log as logging
 
+from coriolis import exception
 from coriolis.osmorphing.osdetect import oracle as oracle_detect
 from coriolis.osmorphing import redhat
+from coriolis import utils
 
 
 ORACLE_DISTRO_IDENTIFIER = oracle_detect.ORACLE_DISTRO_IDENTIFIER
 
+LOG = logging.getLogger(__name__)
+
 
 class BaseOracleMorphingTools(redhat.BaseRedHatMorphingTools):
 
@@ -20,34 +24,32 @@ def check_os_supported(cls, detected_os_info):
         return cls._version_supported_util(
             detected_os_info['release_version'], minimum=6)
 
-    def _get_oracle_repos(self):
-        repos = []
-        major_version = int(self._version.split(".")[0])
-        uekr_version = int(major_version) - 2
-        if major_version < 8:
-            repo_file_path = (
-                '/etc/yum.repos.d/%s.repo' % str(uuid.uuid4()))
-            self._exec_cmd_chroot(
-                "curl -L http://public-yum.oracle.com/public-yum-ol%s.repo "
-                "-o %s" % (major_version, repo_file_path))
-            # During OSMorphing, we temporarily enable needed package repos,
-            # so we make sure we disable all downloaded repos here.
-            self._exec_cmd_chroot(
-                'sed -i "s/^enabled=1$/enabled=0/g" %s' % repo_file_path)
-
-            repos_to_enable = ["ol%s_software_collections" % major_version,
-                               "ol%s_addons" % major_version,
-                               "ol%s_UEKR" % major_version,
-                               "ol%s_latest" % major_version]
-            repos = self._find_yum_repos(repos_to_enable)
+    def enable_repos(self, repo_names):
+        """Enable repositories for Oracle Linux.
+
+        Uses yum-config-manager for OL7 and earlier,
+        dnf config-manager for OL8 and later.
+        """
+        if not repo_names:
+            return
+
+        # Determine package manager based on version
+        major_version = int(str(self._version).split('.')[0])
+        if major_version >= 8:
+            # OL8+ uses dnf
+            config_manager = 'dnf config-manager'
+            enable_flag = '--set-enabled %s'
         else:
-            self._yum_install(
-                ['oraclelinux-release-el%s' % major_version],
-                self._find_yum_repos(['ol%s_baseos_latest' % major_version]))
-            repos_to_enable = ["ol%s_baseos_latest" % major_version,
-                               "ol%s_appstream" % major_version,
-                               "ol%d_addons" % major_version,
-                               "ol%s_UEKR%s" % (major_version, uekr_version)]
-            repos = self._find_yum_repos(repos_to_enable)
-
-        return repos
+            # OL7 and earlier use yum
+            config_manager = 'yum-config-manager'
+            enable_flag = '--enable %s'
+
+        for repo in repo_names:
+            cmd = '%s %s' % (config_manager, enable_flag % repo)
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using %s",
+                         repo, config_manager)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")

coriolis/osmorphing/redhat.py

@@ -185,11 +185,13 @@ def get_installed_packages(self):
             LOG.trace(utils.get_exception_details())
             self.installed_packages = []
 
-    def _yum_install(self, package_names, enable_repos=[]):
+    def _yum_install(self, package_names):
         try:
-            yum_cmd = 'yum install %s -y%s' % (
+            yum_cmd = 'yum install %s -y %s %s' % (
                 " ".join(package_names),
-                "".join([" --enablerepo=%s" % r for r in enable_repos]))
+                "--setopt=strict=1",
+                "--setopt=skip_missing_names_on_install=0"
+            )
             self._exec_cmd_chroot(yum_cmd)
         except exception.CoriolisException as err:
             raise exception.FailedPackageInstallationException(
@@ -207,60 +209,40 @@ def _yum_uninstall(self, package_names):
                 error=str(err)) from err
 
     def _yum_clean_all(self):
-        self._exec_cmd_chroot("yum clean all")
+        try:
+            self._exec_cmd_chroot("yum clean all")
+        except exception.CoriolisException:
+            # On systems with no enabled repos, yum clean fails with
+            # "There are no enabled repos". This is non-fatal since
+            # there is nothing to clean.
+            LOG.warning("yum clean all failed (e.g. no enabled repos), "
+                        "continuing. Error: %s", utils.get_exception_details())
         if self._test_path('var/cache/yum'):
             self._exec_cmd_chroot("rm -rf /var/cache/yum")
 
-    def _find_yum_repos(self, repos_to_enable=[]):
-        """
-        Looks for required repositories passed as `repos_to_enable` in
-        /etc/yum.repos.d and returns the found repository names, so they can
-        be temporarily enabled when installing packages using yum.
-
-        Yum only looks for repos in files with '.repo' extension, anything
-        else gets ignored, therefore this method should filter files by that
-        extension.
-
-        Also, yum repository names might be different in some guest releases,
-        but still be similar. Therefore, repo name substrings should ideally be
-        passed in `repos_to_enable`. For example, we might be looking for repo
-        name 'ol7_latest', but the guest has it named as 'public_ol7_latest' in
-        the repo file.
-        """
-        found_repos = []
+    def _get_repos_to_enable(self):
+        return []
 
-        reposdir_path = 'etc/yum.repos.d'
+    def enable_repos(self, repo_names):
+        """Enable repositories using subscription-manager for
+        Red Hat Enterprise Linux.
 
-        repofiles = [
-            f for f in self._list_dir(reposdir_path) if f.endswith('.repo')]
-        installed_repos = []
-        for file in repofiles:
-            path = os.path.join(reposdir_path, file)
-            try:
-                content = self._read_file_sudo(path)
-            except Exception as e:
-                LOG.warning(
-                    "Could not read yum repository file %s: %s", path, e)
-                continue
-            for line in content.splitlines():
-                m = re.match(r'^\[(.+)\]$', line)
-                if m:
-                    installed_repos.append(m.group(1))
-
-        for repo in repos_to_enable:
-            available_repos = [ir for ir in installed_repos if repo in ir]
-            available_repos.sort(key=len)
-            if available_repos:
-                found_repos.append(available_repos[0])
-            else:
-                LOG.warn(
-                    "Could not find yum repository while searching for "
-                    "repositories to enable: %s.", repo)
-
-        return found_repos
+        This method should be overridden by subclasses that use different
+        repository management tools.
+        """
+        if not repo_names:
+            return
 
-    def _get_repos_to_enable(self):
-        return []
+        # RHEL uses subscription-manager for all versions
+        for repo in repo_names:
+            cmd = 'subscription-manager repos --enable=%s' % repo
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using subscription-manager",
+                         repo)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")
 
     def pre_packages_install(self, package_names):
         super(BaseRedHatMorphingTools, self).pre_packages_install(
@@ -278,8 +260,9 @@ def post_packages_install(self, package_names):
             package_names)
 
     def install_packages(self, package_names):
-        enable_repos = self._get_repos_to_enable()
-        self._yum_install(package_names, enable_repos)
+        repos_to_enable = self._get_repos_to_enable()
+        self.enable_repos(repos_to_enable)
+        self._yum_install(package_names)
 
     def uninstall_packages(self, package_names):
         self._yum_uninstall(package_names)

coriolis/osmorphing/rocky.py

@@ -1,12 +1,18 @@
 # Copyright 2023 Cloudbase Solutions Srl
 # All Rights Reserved.
 
+from oslo_log import log as logging
+
+from coriolis import exception
 from coriolis.osmorphing import centos
 from coriolis.osmorphing.osdetect import rocky as rocky_osdetect
+from coriolis import utils
 
 
 ROCKY_LINUX_DISTRO_IDENTIFIER = rocky_osdetect.ROCKY_LINUX_DISTRO_IDENTIFIER
 
+LOG = logging.getLogger(__name__)
+
 
 class BaseRockyLinuxMorphingTools(centos.BaseCentOSMorphingTools):
 
@@ -19,3 +25,23 @@ def check_os_supported(cls, detected_os_info):
             return False
         return cls._version_supported_util(
             detected_os_info['release_version'], minimum=8)
+
+    def enable_repos(self, repo_names):
+        """Enable repositories for Rocky Linux.
+
+        Uses dnf config-manager for all Rocky Linux versions (8+).
+        """
+        if not repo_names:
+            return
+
+        # Rocky Linux only exists as version 8+, always uses dnf
+        config_manager = 'dnf config-manager'
+        for repo in repo_names:
+            cmd = '%s --set-enabled %s' % (config_manager, repo)
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using %s",
+                         repo, config_manager)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")