File 0085-Remove-epoch-from-version-string-if-presen... of Package salt

Overview Repositories Revisions Requests Users Attributes Meta

File 0085-Remove-epoch-from-version-string-if-present-when-ins.patch of Package salt (Revision a4f5e45d6c1d04809a6593a7f31a1457)

Currently displaying revision a4f5e45d6c1d04809a6593a7f31a1457 , Show latest

From 67a45a1befea14b8fca1aea6a214e82c5dad2175 Mon Sep 17 00:00:00 2001
From: Erik Johnson <palehose@gmail.com>
Date: Thu, 3 Mar 2016 12:52:42 -0600
Subject: [PATCH 85/85] Remove epoch from version string if present when
 installing with yum

* Remove epoch from version string if present when installing with yum

yum install does not support epoch without the arch, and we won't know
  what the arch will be when it's not provided. It could either be the OS
  architecture, or 'noarch', and we don't make that distinction in the
  pkg.list_pkgs return data.

Fixes #31619.

* Move epoch removal

The previous commit causes a failure when a package does not have a
  version specified. Caught by integration tests, yay!

* Add integration test for packages with epoch in version

This starts with cent7, but later I can add cent6 as well.

* yumpkg: Ignore epoch in version comparison for explict versions without an epoch

Also properly handle comparisions for packages with multiple versions.

Resolves #32229

* Don't attempt downgrade for kernel and its subpackages

Multiple versions are supported since their paths do not conflict.
---
 salt/modules/yumpkg.py          | 74 ++++++++++++++++++++++++++++++++---------
 tests/integration/states/pkg.py | 59 +++++++++++++++++++++++---------
 2 files changed, 103 insertions(+), 30 deletions(-)

diff --git a/salt/modules/yumpkg.py b/salt/modules/yumpkg.py
index 1df5258..e21fab0 100644
--- a/salt/modules/yumpkg.py
+++ b/salt/modules/yumpkg.py
@@ -1087,7 +1087,10 @@ def install(name=None,
             log.warning('"version" parameter will be ignored for multiple '
                         'package targets')
 
-    old = list_pkgs()
+    old = list_pkgs(versions_as_list=False)
+    # Use of __context__ means no duplicate work here, just accessing
+    # information already in __context__ from the previous call to list_pkgs()
+    old_as_list = list_pkgs(versions_as_list=True)
     targets = []
     downgrade = []
     to_reinstall = {}
@@ -1138,6 +1141,13 @@ def install(name=None,
             # not None, since the only way version_num is not None is if RPM
             # metadata parsing was successful.
             if pkg_type == 'repository':
+                if _yum() == 'yum':
+                    # yum install does not support epoch without the arch, and
+                    # we won't know what the arch will be when it's not
+                    # provided. It could either be the OS architecture, or
+                    # 'noarch', and we don't make that distinction in the
+                    # pkg.list_pkgs return data.
+                    version_num = version_num.split(':', 1)[-1]
                 arch = ''
                 try:
                     namepart, archpart = pkgname.rsplit('.', 1)
@@ -1152,20 +1162,54 @@ def install(name=None,
             else:
                 pkgstr = pkgpath
 
-            cver = old.get(pkgname, '')
-            if reinstall and cver \
-                    and salt.utils.compare_versions(ver1=version_num,
-                                                    oper='==',
-                                                    ver2=cver,
-                                                    cmp_func=version_cmp):
-                to_reinstall[pkgname] = pkgstr
-            elif not cver or salt.utils.compare_versions(ver1=version_num,
-                                                         oper='>=',
-                                                         ver2=cver,
-                                                         cmp_func=version_cmp):
-                targets.append(pkgstr)
+            # Lambda to trim the epoch from the currently-installed version if
+            # no epoch is specified in the specified version
+            norm_epoch = lambda x, y: x.split(':', 1)[-1] \
+                if ':' not in y \
+                else x
+            cver = old_as_list.get(pkgname, [])
+            if reinstall and cver:
+                for ver in cver:
+                    ver = norm_epoch(ver, version_num)
+                    if salt.utils.compare_versions(ver1=version_num,
+                                                   oper='==',
+                                                   ver2=ver,
+                                                   cmp_func=version_cmp):
+                        # This version is already installed, so we need to
+                        # reinstall.
+                        to_reinstall[pkgname] = pkgstr
+                        break
             else:
-                downgrade.append(pkgstr)
+                if not cver:
+                    targets.append(pkgstr)
+                else:
+                    for ver in cver:
+                        ver = norm_epoch(ver, version_num)
+                        if salt.utils.compare_versions(ver1=version_num,
+                                                       oper='>=',
+                                                       ver2=ver,
+                                                       cmp_func=version_cmp):
+                            targets.append(pkgstr)
+                            break
+                    else:
+                        if re.match('kernel(-.+)?', name):
+                            # kernel and its subpackages support multiple
+                            # installs as their paths do not conflict.
+                            # Performing a yum/dnf downgrade will be a no-op
+                            # so just do an install instead. It will fail if
+                            # there are other interdependencies that have
+                            # conflicts, and that's OK. We don't want to force
+                            # anything, we just want to properly handle it if
+                            # someone tries to install a kernel/kernel-devel of
+                            # a lower version than the currently-installed one.
+                            # TODO: find a better way to determine if a package
+                            # supports multiple installs.
+                            targets.append(pkgstr)
+                        else:
+                            # None of the currently-installed versions are
+                            # greater than the specified version, so this is a
+                            # downgrade.
+                            downgrade.append(pkgstr)
 
     yum_cmd = _yum()
     if targets:
@@ -1202,7 +1246,7 @@ def install(name=None,
         __salt__['cmd.run'](cmd, output_loglevel='trace')
 
     __context__.pop('pkg.list_pkgs', None)
-    new = list_pkgs()
+    new = list_pkgs(versions_as_list=False)
 
     ret = salt.utils.compare_dicts(old, new)
 
diff --git a/tests/integration/states/pkg.py b/tests/integration/states/pkg.py
index 480abb2..67e2025 100644
--- a/tests/integration/states/pkg.py
+++ b/tests/integration/states/pkg.py
@@ -45,14 +45,20 @@ _PKG_TARGETS_DOT = {
                '7': 'tomcat-el-2.2-api'}
 }
 
+# Test packages with epoch in version
+# (https://github.com/saltstack/salt/issues/31619)
+_PKG_TARGETS_EPOCH = {
+    'RedHat': {'7': 'comps-extras'},
+}
+
 
+@destructiveTest
 @requires_salt_modules('pkg.version', 'pkg.latest_version')
 class PkgTest(integration.ModuleCase,
               integration.SaltReturnAssertsMixIn):
     '''
     pkg.installed state tests
     '''
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_001_installed(self, grains=None):
@@ -80,7 +86,6 @@ class PkgTest(integration.ModuleCase,
         ret = self.run_state('pkg.removed', name=target)
         self.assertSaltTrueReturn(ret)
 
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_002_installed_with_version(self, grains=None):
@@ -122,7 +127,6 @@ class PkgTest(integration.ModuleCase,
         ret = self.run_state('pkg.removed', name=target)
         self.assertSaltTrueReturn(ret)
 
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_003_installed_multipkg(self, grains=None):
@@ -148,7 +152,6 @@ class PkgTest(integration.ModuleCase,
         ret = self.run_state('pkg.removed', name=None, pkgs=pkg_targets)
         self.assertSaltTrueReturn(ret)
 
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_004_installed_multipkg_with_version(self, grains=None):
@@ -166,7 +169,7 @@ class PkgTest(integration.ModuleCase,
         # Make sure that we have targets that match the os_family. If this
         # fails then the _PKG_TARGETS dict above needs to have an entry added,
         # with two packages that are not installed before these tests are run
-        self.assertTrue(pkg_targets)
+        self.assertTrue(bool(pkg_targets))
 
         if os_family == 'Arch':
             for idx in range(13):
@@ -182,7 +185,7 @@ class PkgTest(integration.ModuleCase,
         # If this assert fails, we need to find new targets, this test needs to
         # be able to test successful installation of packages, so these
         # packages need to not be installed before we run the states below
-        self.assertTrue(version)
+        self.assertTrue(bool(version))
 
         pkgs = [{pkg_targets[0]: version}, pkg_targets[1]]
 
@@ -191,7 +194,6 @@ class PkgTest(integration.ModuleCase,
         ret = self.run_state('pkg.removed', name=None, pkgs=pkg_targets)
         self.assertSaltTrueReturn(ret)
 
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_005_installed_32bit(self, grains=None):
@@ -216,14 +218,13 @@ class PkgTest(integration.ModuleCase,
             # needs to be able to test successful installation of packages, so
             # the target needs to not be installed before we run the states
             # below
-            self.assertFalse(version)
+            self.assertFalse(bool(version))
 
             ret = self.run_state('pkg.installed', name=target)
             self.assertSaltTrueReturn(ret)
             ret = self.run_state('pkg.removed', name=target)
             self.assertSaltTrueReturn(ret)
 
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_006_installed_32bit_with_version(self, grains=None):
@@ -257,14 +258,13 @@ class PkgTest(integration.ModuleCase,
             # needs to be able to test successful installation of the package, so
             # the target needs to not be installed before we run the states
             # below
-            self.assertTrue(version)
+            self.assertTrue(bool(version))
 
             ret = self.run_state('pkg.installed', name=target, version=version)
             self.assertSaltTrueReturn(ret)
             ret = self.run_state('pkg.removed', name=target)
             self.assertSaltTrueReturn(ret)
 
-    @destructiveTest
     @skipIf(salt.utils.is_windows(), 'minion is windows')
     @requires_system_grains
     def test_pkg_with_dot_in_pkgname(self, grains=None):
@@ -276,13 +276,42 @@ class PkgTest(integration.ModuleCase,
         '''
         os_family = grains.get('os_family', '')
         os_version = grains.get('osmajorrelease', [''])[0]
-        if os_family in _PKG_TARGETS_DOT:
-            target = _PKG_TARGETS_DOT.get(os_family, '').get(os_version, '')
-        else:
-            target = None
+        target = _PKG_TARGETS_DOT.get(os_family, {}).get(os_version)
         if target:
+            version = self.run_function('pkg.latest_version', [target])
+            # If this assert fails, we need to find a new target. This test
+            # needs to be able to test successful installation of the package, so
+            # the target needs to not be installed before we run the
+            # pkg.installed state below
+            self.assertTrue(bool(version))
             ret = self.run_state('pkg.installed', name=target)
             self.assertSaltTrueReturn(ret)
+            ret = self.run_state('pkg.removed', name=target)
+            self.assertSaltTrueReturn(ret)
+
+    @skipIf(salt.utils.is_windows(), 'minion is windows')
+    @requires_system_grains
+    def test_pkg_with_epoch_in_version(self, grains=None):
+        '''
+        This tests for the regression found in the following issue:
+        https://github.com/saltstack/salt/issues/8614
+
+        This is a destructive test as it installs a package
+        '''
+        os_family = grains.get('os_family', '')
+        os_version = grains.get('osmajorrelease', [''])[0]
+        target = _PKG_TARGETS_EPOCH.get(os_family, {}).get(os_version)
+        if target:
+            version = self.run_function('pkg.latest_version', [target])
+            # If this assert fails, we need to find a new target. This test
+            # needs to be able to test successful installation of the package, so
+            # the target needs to not be installed before we run the
+            # pkg.installed state below
+            self.assertTrue(bool(version))
+            ret = self.run_state('pkg.installed', name=target, version=version)
+            self.assertSaltTrueReturn(ret)
+            ret = self.run_state('pkg.removed', name=target)
+            self.assertSaltTrueReturn(ret)
 
 
 if __name__ == '__main__':
-- 
2.10.1

Places

File 0085-Remove-epoch-from-version-string-if-present-when-ins.patch of Package salt (Revision a4f5e45d6c1d04809a6593a7f31a1457)

Places