[yum-commits] Branch 'yum-3_2_X' - 4 commits - test/operationstests.py test/simpleobsoletestests.py yum/__init__.py

James Antill james at osuosl.org
Wed Jul 8 21:17:43 UTC 2009


 test/operationstests.py      |    6 -
 test/simpleobsoletestests.py |  130 ++++++++++++++++++++++++++++++++++++++++++-
 yum/__init__.py              |   46 ++++++++++-----
 3 files changed, 164 insertions(+), 18 deletions(-)

New commits:
commit 9bef1a0436e11e54b6999745ce72d4e211a2f5a7
Author: James Antill <james at and.org>
Date:   Wed Jul 8 17:17:13 2009 -0400

    Fix update of obsoleted pkg. just as install does, testRLDaplMessWeirdUp1 fix

diff --git a/yum/__init__.py b/yum/__init__.py
index 961516c..221d4d7 100644
--- a/yum/__init__.py
+++ b/yum/__init__.py
@@ -2484,6 +2484,14 @@ class YumBase(depsolve.Depsolve):
 
         return returnlist
 
+    # FIXME: This doesn't really work, as it assumes one obsoleter for each pkg
+    # when we can have:
+    # 1 pkg obsoleted by multiple pkgs _and_
+    # 1 pkg obsoleting multiple pkgs
+    # ...and we need to detect loops, and get the arches "right" and do this
+    # for chains. Atm. I hate obsoletes, and I can't get it to work better,
+    # easily ... so screw it, don't create huge chains of obsoletes with some
+    # loops in there too ... or I'll have to hurt you.
     def _pkg2obspkg(self, po):
         """ Given a package return the package it's obsoleted by and so
             we should install instead. Or None if there isn't one. """
@@ -2727,7 +2735,7 @@ class YumBase(depsolve.Depsolve):
                 else:
                     self.verbose_logger.warning(_('Package %s is obsoleted by %s, trying to install %s instead'),
                         po.name, obsoleting_pkg.name, obsoleting_pkg)               
-                    self.install(po=obsoleting_pkg)
+                    tx_return.extend(self.install(po=obsoleting_pkg))
                 continue
             
             # make sure it's not already installed
@@ -2776,7 +2784,7 @@ class YumBase(depsolve.Depsolve):
             else:
                 txmbr = self.tsInfo.addInstall(po)
                 tx_return.append(txmbr)
-        
+
         return tx_return
 
     def _check_new_update_provides(self, opkg, npkg):
@@ -2785,6 +2793,7 @@ class YumBase(depsolve.Depsolve):
             too, to the latest version. """
         oprovs = set(opkg.returnPrco('provides'))
         nprovs = set(npkg.returnPrco('provides'))
+        tx_return = []
         for prov in oprovs.difference(nprovs):
             reqs = self.tsInfo.getRequires(*prov)
             for pkg in reqs:
@@ -2792,10 +2801,11 @@ class YumBase(depsolve.Depsolve):
                     if not npkg.inPrcoRange('provides', req):
                         naTup = (pkg.name, pkg.arch)
                         for pkg in self.pkgSack.returnNewestByNameArch(naTup):
-                            self.update(po=pkg)
+                            tx_return.extend(self.update(po=pkg))
                         break
+        return tx_return
 
-    def _newer_update_in_trans(self, pkgtup, available_pkg):
+    def _newer_update_in_trans(self, pkgtup, available_pkg, tx_return):
         """ We return True if there is a newer package already in the
             transaction. If there is an older one, we remove it (and update any
             deps. that aren't satisfied by the newer pkg) and return False so
@@ -2809,8 +2819,9 @@ class YumBase(depsolve.Depsolve):
                 else:
                     for ntxmbr in self.tsInfo.getMembers(po.pkgtup):
                         self.tsInfo.remove(ntxmbr.po.pkgtup)
-                        self._check_new_update_provides(ntxmbr.po,
-                                                        available_pkg)
+                        txs = self._check_new_update_provides(ntxmbr.po,
+                                                              available_pkg)
+                        tx_return.extend(txs)
             if count:
                 found = True
             else:
@@ -2984,11 +2995,20 @@ class YumBase(depsolve.Depsolve):
                     tx_return.append(txmbr)
                         
         for available_pkg in availpkgs:
+            #  Make sure we're not installing a package which is obsoleted by
+            # something else in the repo. Unless there is a obsoletion loop,
+            # at which point ignore everything.
+            obsoleting_pkg = self._test_loop(available_pkg, self._pkg2obspkg)
+            if obsoleting_pkg is not None:
+                self.verbose_logger.log(logginglevels.DEBUG_2, _('Not Updating Package that is obsoleted: %s'), available_pkg)
+                tx_return.extend(self.install(po=obsoleting_pkg))
+                continue
             for updated in self.up.updating_dict.get(available_pkg.pkgtup, []):
                 if self.tsInfo.isObsoleted(updated):
                     self.verbose_logger.log(logginglevels.DEBUG_2, _('Not Updating Package that is already obsoleted: %s.%s %s:%s-%s'), 
                                             updated)
-                elif self._newer_update_in_trans(updated, available_pkg):
+                elif self._newer_update_in_trans(updated, available_pkg,
+                                                 tx_return):
                     self.verbose_logger.log(logginglevels.DEBUG_2, _('Not Updating Package that is already updated: %s.%s %s:%s-%s'), 
                                             updated)
                 
@@ -3014,7 +3034,8 @@ class YumBase(depsolve.Depsolve):
                 if self.tsInfo.isObsoleted(ipkg.pkgtup):
                     self.verbose_logger.log(logginglevels.DEBUG_2, _('Not Updating Package that is already obsoleted: %s.%s %s:%s-%s'), 
                                             ipkg.pkgtup)
-                elif self._newer_update_in_trans(ipkg.pkgtup, available_pkg):
+                elif self._newer_update_in_trans(ipkg.pkgtup, available_pkg,
+                                                 tx_return):
                     self.verbose_logger.log(logginglevels.DEBUG_2, _('Not Updating Package that is already updated: %s.%s %s:%s-%s'), 
                                             ipkg.pkgtup)
                 elif ipkg.verLT(available_pkg):
@@ -3022,12 +3043,6 @@ class YumBase(depsolve.Depsolve):
                     if requiringPo:
                         txmbr.setAsDep(requiringPo)
                     tx_return.append(txmbr)
-                
-                #else:
-                    #magically make allowdowngrade work here
-                    # yum --allow-downgrade update something-specific here
-                    # could work but we will need to be careful with it
-                    # maybe a downgrade command is necessary
 
         return tx_return
         
commit bd0678537ece51d819bc1a1c9a631f1748d0c07d
Author: James Antill <james at and.org>
Date:   Wed Jul 8 14:49:06 2009 -0400

    Add update varients of the weird install tests

diff --git a/test/simpleobsoletestests.py b/test/simpleobsoletestests.py
index 88d8060..e5f6770 100644
--- a/test/simpleobsoletestests.py
+++ b/test/simpleobsoletestests.py
@@ -436,7 +436,9 @@ class SimpleObsoletesTests(OperationsTests):
         res, msg = self.runOperation(['update'],
                                      [rp1], [aop1, aop2])
         self.assert_(res=='err', msg)
-        # self.assertResult((aop1,aop2))
+        # FIXME: This is really what should happen, but just sucking works too
+        # self.assert_(res=='ok', msg)
+        # self.assertResult((aop1,))
 
     def _helperRLDaplMess(self):
         rp1 = FakePackage('dapl',       '1.2.1', '7', arch='i386')
@@ -519,20 +521,20 @@ class SimpleObsoletesTests(OperationsTests):
         self.assertResult(ret)
 
     # Now we get a bit weird, as we have obsoletes fighting with updates
-    def testRLDaplMessWeird1(self):
+    def testRLDaplMessWeirdInst1(self):
         rps, aps, ret, all = self._helperRLDaplMess()
         res, msg = self.runOperation(['install', 'dapl-1.2.1.1-7'], rps, aps)
 
         self.assert_(res=='ok', msg)
         self.assertResult(ret)
-    def testRLDaplMessWeird2(self):
+    def testRLDaplMessWeirdInst2(self):
         rps, aps, ret, all = self._helperRLDaplMess()
         res, msg = self.runOperation(['install', 'dapl-2.0.15',
                                       'dapl-devel-2.0.15'], rps, aps)
 
         self.assert_(res=='ok', msg)
         self.assertResult((all['arp3'], all['arp4']))
-    def testRLDaplMessWeird3(self):
+    def testRLDaplMessWeirdInst3(self):
         rps, aps, ret, all = self._helperRLDaplMess()
         res, msg = self.runOperation(['install', 'dapl-2.0.15'], rps, aps)
 
@@ -541,6 +543,28 @@ class SimpleObsoletesTests(OperationsTests):
         self.assertResult((all['arp3'], all['aoop1'], all['aoop2']))
         # FIXME: Optimally we'd get:
         # self.assertResult((all['arp3'], all['arp4']))
+    def testRLDaplMessWeirdUp1(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['update', 'dapl-1.2.1.1-7'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+    def testRLDaplMessWeirdUp2(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['update', 'dapl-2.0.15',
+                                      'dapl-devel-2.0.15'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult((all['arp3'], all['arp4']))
+    def testRLDaplMessWeirdUp3(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['update', 'dapl-2.0.15'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        # This will almost certainly fail, but it's pretty weird:
+        self.assertResult((all['arp3'], all['aoop1'], all['aoop2']))
+        # FIXME: Optimally we'd get:
+        # self.assertResult((all['arp3'], all['arp4']))
 
 
 class GitMetapackageObsoletesTests(OperationsTests):
commit 3a31dac2f07fb84d8acb010ced93c784413af7d3
Author: James Antill <james at and.org>
Date:   Wed Jul 8 13:23:06 2009 -0400

    Fix the obsoletes chain problem, as shown by dapl in EL4

diff --git a/test/operationstests.py b/test/operationstests.py
index df52f9a..18f4b84 100644
--- a/test/operationstests.py
+++ b/test/operationstests.py
@@ -68,7 +68,7 @@ class ComplicatedObsoletesTests(OperationsTests):
         p = self.pkgs
         res, msg = self.runOperation(['update'], [p.installed], [p.obsoletes, p.obsoletes2])
         self.assert_(res=='ok', msg)
-        if new_behavior:
+        if True or new_behavior:
             self.assertResult((p.obsoletes2,))
         else:
             self.assertResult((p.obsoletes,))
@@ -85,7 +85,7 @@ class ComplicatedObsoletesTests(OperationsTests):
         if new_behavior:
             self.assertResult((p.obsoletecircle,))
         else:
-            self.assertResult((p.obsoletes,))
+            self.assertResult((p.obsoletes2,))
     def testObsoleteCircleNext(self):
         p = self.pkgs
         res, msg = self.runOperation(['update'], [p.obsoletes], [p.obsoletecircle, p.obsoletes, p.obsoletes2])
@@ -109,7 +109,7 @@ class ComplicatedObsoletesTests(OperationsTests):
         if new_behavior:
             self.assertResult((p.obsoletecircle,))
         else:
-            self.assertResult((p.obsoletes,))
+            self.assertResult((p.obsoletes2,))
     # continue endlessly
     
 class KernelTests(OperationsTests):
diff --git a/yum/__init__.py b/yum/__init__.py
index 2f9723b..961516c 100644
--- a/yum/__init__.py
+++ b/yum/__init__.py
@@ -2842,6 +2842,9 @@ class YumBase(depsolve.Depsolve):
 
             for (obsoleting, installed) in obsoletes:
                 obsoleting_pkg = self.getPackageObject(obsoleting)
+                topkg = self._test_loop(obsoleting_pkg, self._pkg2obspkg)
+                if topkg is not None:
+                    obsoleting_pkg = topkg
                 installed_pkg =  self.rpmdb.searchPkgTuple(installed)[0]
                 txmbr = self.tsInfo.addObsoleting(obsoleting_pkg, installed_pkg)
                 self.tsInfo.addObsoleted(installed_pkg, obsoleting_pkg)
commit 00a1e6df182ef4b9ee40988ba54d87ce1402b3b2
Author: James Antill <james at and.org>
Date:   Wed Jul 8 10:31:18 2009 -0400

    Add testcase for EL4 dapl issue

diff --git a/test/simpleobsoletestests.py b/test/simpleobsoletestests.py
index 4fdf67c..88d8060 100644
--- a/test/simpleobsoletestests.py
+++ b/test/simpleobsoletestests.py
@@ -438,6 +438,110 @@ class SimpleObsoletesTests(OperationsTests):
         self.assert_(res=='err', msg)
         # self.assertResult((aop1,aop2))
 
+    def _helperRLDaplMess(self):
+        rp1 = FakePackage('dapl',       '1.2.1', '7', arch='i386')
+        rp2 = FakePackage('dapl-devel', '1.2.1', '7', arch='i386')
+        rp2.addRequires('dapl', 'EQ', ('0', '1.2.1', '7'))
+
+        arp1 = FakePackage('dapl',       '1.2.1.1', '7', arch='i386')
+        arp2 = FakePackage('dapl-devel', '1.2.1.1', '7', arch='i386')
+        arp2.addRequires('dapl', 'EQ', ('0', '1.2.1.1', '7'))
+        arp3 = FakePackage('dapl',       '2.0.15', '1.el4', arch='i386')
+        arp4 = FakePackage('dapl-devel', '2.0.15', '1.el4', arch='i386')
+        arp4.addRequires('dapl', 'EQ', ('0', '2.0.15', '1.el4'))
+
+        aop1 = FakePackage('compat-dapl-1.2.5', '2.0.7', '2.el4', arch='i386')
+        aop1.addObsoletes('dapl', 'LE', (None, '1.2.1.1', None))
+        aop2 = FakePackage('compat-dapl-devel-1.2.5', '2.0.7', '2.el4',
+                           arch='i386')
+        aop2.addObsoletes('dapl-devel', 'LE', (None, '1.2.1.1', None))
+        aop2.addRequires('dapl', 'EQ', ('0', '2.0.7', '2.el4'))
+
+        aoop1 = FakePackage('compat-dapl', '2.0.15', '1.el4', arch='i386')
+        aoop1.addObsoletes('dapl', 'LE', (None, '1.2.1.1', None))
+        aoop1.addObsoletes('compat-dapl-1.2.5', None, (None, None, None))
+        aoop2 = FakePackage('compat-dapl-devel', '2.0.15', '1.el4', arch='i386')
+        aoop2.addObsoletes('dapl-devel', 'LE', (None, '1.2.1.1', None))
+        aoop2.addObsoletes('compat-dapl-devel-1.2.5', None, (None, None, None))
+        aoop2.addRequires('compat-dapl', 'EQ', ('0', '2.0.15', '1.el4'))
+
+        return [rp1, rp2], [arp1, arp2, arp3, arp4,
+                            aop1, aop2, aoop1, aoop2], [aoop1, aoop2], locals()
+
+    def testRLDaplMess1(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['update'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    def testRLDaplMess2(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['update', 'dapl'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    def testRLDaplMess3(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['update', 'dapl-devel'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    def testRLDaplMess4(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'compat-dapl'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    def testRLDaplMess5(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'compat-dapl-devel'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    def testRLDaplMess6(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'compat-dapl-1.2.5'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    def testRLDaplMess7(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'compat-dapl-devel-1.2.5'],
+                                     rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+
+    # Now we get a bit weird, as we have obsoletes fighting with updates
+    def testRLDaplMessWeird1(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'dapl-1.2.1.1-7'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult(ret)
+    def testRLDaplMessWeird2(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'dapl-2.0.15',
+                                      'dapl-devel-2.0.15'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        self.assertResult((all['arp3'], all['arp4']))
+    def testRLDaplMessWeird3(self):
+        rps, aps, ret, all = self._helperRLDaplMess()
+        res, msg = self.runOperation(['install', 'dapl-2.0.15'], rps, aps)
+
+        self.assert_(res=='ok', msg)
+        # This will almost certainly fail, but it's pretty weird:
+        self.assertResult((all['arp3'], all['aoop1'], all['aoop2']))
+        # FIXME: Optimally we'd get:
+        # self.assertResult((all['arp3'], all['arp4']))
+
 
 class GitMetapackageObsoletesTests(OperationsTests):
 


More information about the Yum-commits mailing list