Remove enable_repo from osmorphing for oracle linux

Author: fabi200123

coriolis/osmorphing/oracle.py

@@ -1,8 +1,6 @@
 # Copyright 2016 Cloudbase Solutions Srl
 # All Rights Reserved.
 
-import uuid
-
 from coriolis.osmorphing.osdetect import oracle as oracle_detect
 from coriolis.osmorphing import redhat
 
@@ -19,35 +17,3 @@ def check_os_supported(cls, detected_os_info):
             return False
         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

coriolis/osmorphing/redhat.py

@@ -205,57 +205,6 @@ 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 = []
-
-        reposdir_path = 'etc/yum.repos.d'
-
-        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
-
-    def _get_repos_to_enable(self):
-        return []
-
     def pre_packages_install(self, package_names):
         super(BaseRedHatMorphingTools, self).pre_packages_install(
             package_names)
@@ -272,8 +221,7 @@ 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)
+        self._yum_install(package_names)
 
     def uninstall_packages(self, package_names):
         self._yum_uninstall(package_names)

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))
-        ])

coriolis/tests/osmorphing/test_redhat.py

@@ -25,7 +25,6 @@ def setUp(self):
             'friendly_release_name': mock.sentinel.friendly_release_name,
         }
         self.package_names = ['package1', 'package2']
-        self.enable_repos = ['repo1', 'repo2']
         self.event_manager = mock.MagicMock()
         self.morphing_tools = redhat.BaseRedHatMorphingTools(
             mock.sentinel.conn, mock.sentinel.os_root_dir,
@@ -325,11 +324,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 +337,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 +381,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 +421,10 @@ 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, '_get_repos_to_enable')
-    def test_install_packages(self, mock_get_repos_to_enable,
-                              mock_yum_install):
+    def test_install_packages(self, 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_yum_install.assert_called_once_with(self.package_names)
 
     @mock.patch.object(redhat.BaseRedHatMorphingTools, '_yum_uninstall')
     def test_uninstall_packages(self, mock_yum_uninstall):