Remove enable_repo from osmorphing for all redhat based OSes

fabi200123 · fabi200123 · commit fc37decb35b2 · 2026-02-03T17:29:59.000+02:00
diff --git a/coriolis/osmorphing/amazon.py b/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,18 @@ 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 using yum-config-manager for Amazon Linux."""
+        if not repo_names:
+            return
+
+        for repo in repo_names:
+            cmd = 'yum-config-manager --enable %s' % repo
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using yum-config-manager",
+                         repo)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")
diff --git a/coriolis/osmorphing/centos.py b/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,18 @@ 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 using yum-config-manager for CentOS."""
+        if not repo_names:
+            return
+
+        for repo in repo_names:
+            cmd = 'yum-config-manager --enable %s' % repo
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using yum-config-manager",
+                         repo)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")
diff --git a/coriolis/osmorphing/oracle.py b/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,17 @@ 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)
-        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
+    def enable_repos(self, repo_names):
+        """Enable repositories using yum-config-manager for Oracle Linux."""
+        if not repo_names:
+            return
+
+        for repo in repo_names:
+            cmd = 'yum-config-manager --enable %s' % repo
+            try:
+                self._exec_cmd_chroot(cmd)
+                LOG.info("Enabled repository '%s' using yum-config-manager",
+                         repo)
+            except exception.CoriolisException:
+                LOG.warning(f"Failed to enable repository {repo}. "
+                            f"Error was: {utils.get_exception_details()}")
diff --git a/coriolis/osmorphing/redhat.py b/coriolis/osmorphing/redhat.py
@@ -179,11 +179,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(
@@ -205,56 +207,28 @@ def _yum_clean_all(self):
         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).decode()
-            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 []
+        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(
@@ -272,8 +246,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)
diff --git a/coriolis/tests/osmorphing/test_oracle.py b/coriolis/tests/osmorphing/test_oracle.py
@@ -3,10 +3,8 @@
 
 from unittest import mock
 
-from coriolis.osmorphing import base
 from coriolis.osmorphing import oracle
 from coriolis.osmorphing.osdetect import oracle as oracle_detect
-from coriolis.osmorphing import redhat
 from coriolis.tests import test_base
 
 
@@ -40,53 +38,3 @@ def test_check_os_not_supported(self):
             self.detected_os_info)
 
         self.assertFalse(result)
-
-    @mock.patch.object(base.BaseLinuxOSMorphingTools, '_exec_cmd_chroot')
-    @mock.patch.object(redhat.BaseRedHatMorphingTools, '_find_yum_repos')
-    @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_install')
-    def test__get_oracle_repos(self, mock_yum_install, mock_find_yum_repos,
-                               mock_exec_cmd_chroot):
-        self.oracle_morphing_tools._version = '10'
-
-        result = self.oracle_morphing_tools._get_oracle_repos()
-
-        self.assertEqual(result, mock_find_yum_repos.return_value)
-
-        mock_find_yum_repos.assert_has_calls([
-            mock.call(["ol10_baseos_latest"]),
-            mock.call([
-                "ol10_baseos_latest",
-                "ol10_appstream",
-                "ol10_addons",
-                "ol10_UEKR8"
-            ]),
-        ])
-        mock_yum_install.assert_called_once_with(
-            ['oraclelinux-release-el10'], mock_find_yum_repos.return_value)
-        mock_exec_cmd_chroot.assert_not_called()
-
-    @mock.patch.object(base.BaseLinuxOSMorphingTools, '_exec_cmd_chroot')
-    @mock.patch.object(redhat.BaseRedHatMorphingTools, '_find_yum_repos')
-    @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_install')
-    @mock.patch.object(oracle.uuid, 'uuid4')
-    def test__get_oracle_repos_major_version_lt_8(
-            self, mock_uuid4, mock_yum_install, mock_find_yum_repos,
-            mock_exec_cmd_chroot):
-        result = self.oracle_morphing_tools._get_oracle_repos()
-
-        self.assertEqual(result, mock_find_yum_repos.return_value)
-
-        mock_find_yum_repos.assert_called_once_with([
-            "ol6_software_collections",
-            "ol6_addons",
-            "ol6_UEKR",
-            "ol6_latest"
-        ])
-        mock_yum_install.assert_not_called()
-        mock_exec_cmd_chroot.assert_has_calls([
-            mock.call(
-                "curl -L http://public-yum.oracle.com/public-yum-ol6.repo "
-                "-o /etc/yum.repos.d/%s.repo" % mock_uuid4.return_value),
-            mock.call('sed -i "s/^enabled=1$/enabled=0/g" %s' % (
-                "/etc/yum.repos.d/%s.repo" % mock_uuid4.return_value))
-        ])
diff --git a/coriolis/tests/osmorphing/test_redhat.py b/coriolis/tests/osmorphing/test_redhat.py
@@ -325,11 +325,10 @@ def test_get_installed_packages_none(self, mock_exec_cmd_chroot):
 
     @mock.patch.object(base.BaseLinuxOSMorphingTools, '_exec_cmd_chroot')
     def test__yum_install(self, mock_exec_cmd_chroot):
-        self.morphing_tools._yum_install(self.package_names, self.enable_repos)
+        self.morphing_tools._yum_install(self.package_names)
 
         mock_exec_cmd_chroot.assert_called_once_with(
-            "yum install package1 package2 -y "
-            "--enablerepo=repo1 --enablerepo=repo2"
+            "yum install package1 package2 -y"
         )
 
     @mock.patch.object(base.BaseLinuxOSMorphingTools, '_exec_cmd_chroot')
@@ -339,7 +338,7 @@ def test__yum_install_with_exception(self, mock_exec_cmd_chroot):
         self.assertRaises(
             exception.FailedPackageInstallationException,
             self.morphing_tools._yum_install,
-            self.package_names, self.enable_repos
+            self.package_names
         )
 
     @mock.patch.object(base.BaseLinuxOSMorphingTools, '_exec_cmd_chroot')
@@ -383,33 +382,6 @@ def test__yum_clean_all_path_not_exists(self, mock_test_path,
 
         mock_exec_cmd_chroot.assert_called_once_with("yum clean all")
 
-    @mock.patch.object(base.BaseLinuxOSMorphingTools, '_list_dir')
-    @mock.patch.object(base.BaseLinuxOSMorphingTools, '_read_file_sudo')
-    def test__find_yum_repos_found(self, mock_read_file_sudo, mock_list_dir):
-        mock_list_dir.return_value = ['file1.repo', 'file2.repo']
-        mock_read_file_sudo.return_value = b'[repo1]\n[repo2]'
-        repos_to_enable = ['repo1']
-
-        result = self.morphing_tools._find_yum_repos(repos_to_enable)
-
-        mock_read_file_sudo.assert_has_calls([
-            mock.call('etc/yum.repos.d/file1.repo'),
-            mock.call('etc/yum.repos.d/file2.repo')
-        ])
-
-        self.assertEqual(result, ['repo1'])
-
-    @mock.patch.object(base.BaseLinuxOSMorphingTools, '_list_dir')
-    @mock.patch.object(base.BaseLinuxOSMorphingTools, '_read_file_sudo')
-    def test__find_yum_repos_not_found(self, mock_read_file_sudo,
-                                       mock_list_dir):
-        mock_list_dir.return_value = ['file1.repo', 'file2.repo']
-        mock_read_file_sudo.return_value = b'[repo1]\n[repo2]'
-        repos_to_enable = ['repo3']
-
-        with self.assertLogs('coriolis.osmorphing.redhat', level=logging.WARN):
-            self.morphing_tools._find_yum_repos(repos_to_enable)
-
     @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_install')
     @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_clean_all')
     @mock.patch.object(base.BaseLinuxOSMorphingTools, 'pre_packages_install')
@@ -450,14 +422,16 @@ def test_post_packages_install(
         mock_post_packages_install.assert_called_once_with(self.package_names)
 
     @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_install')
+    @mock.patch.object(redhat.BaseRedHatMorphingTools, 'enable_repos')
     @mock.patch.object(redhat.BaseRedHatMorphingTools, '_get_repos_to_enable')
     def test_install_packages(self, mock_get_repos_to_enable,
-                              mock_yum_install):
+                              mock_enable_repos, mock_yum_install):
         self.morphing_tools.install_packages(self.package_names)
 
         mock_get_repos_to_enable.assert_called_once()
-        mock_yum_install.assert_called_once_with(
-            self.package_names, mock_get_repos_to_enable.return_value)
+        mock_enable_repos.assert_called_once_with(
+            mock_get_repos_to_enable.return_value)
+        mock_yum_install.assert_called_once_with(self.package_names)
 
     @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_uninstall')
     def test_uninstall_packages(self, mock_yum_uninstall):
