diff --git a/cli.py b/cli.py

index 8f50541..f93a706 100644

--- a/cli.py

+++ b/cli.py

@@ -894,10 +894,12 @@ class YumBaseCli(yum.YumBase, output.YumOutput):

             hdrcode, hdrresults = self.cleanHeaders()

             xmlcode, xmlresults = self.cleanMetadata()

             dbcode, dbresults = self.cleanSqlite()

+            rpmcode, rpmresults = self.cleanRpmDB()

             self.plugins.run('clean')

-            code = hdrcode + pkgcode + xmlcode + dbcode

-            results = hdrresults + pkgresults + xmlresults + dbresults

+            code = hdrcode + pkgcode + xmlcode + dbcode + rpmdb

+            results = (hdrresults + pkgresults + xmlresults + dbresults +

+                       rpmresults)

             for msg in results:

                 self.logger.debug(msg)

             return code, []

@@ -917,6 +919,9 @@ class YumBaseCli(yum.YumBase, output.YumOutput):

         if 'expire-cache' in userlist or 'metadata' in userlist:

             self.logger.debug(_('Cleaning up expire-cache metadata'))

             expccode, expcresults = self.cleanExpireCache()

+        if 'rpmdb' in userlist:

+            self.logger.debug(_('Cleaning up cached rpmdb data'))

+            expccode, expcresults = self.cleanRpmDB()

         if 'plugins' in userlist:

             self.logger.debug(_('Cleaning up plugins'))

             self.plugins.run('clean')

diff --git a/docs/yum.8 b/docs/yum.8

index 4158453..9472a82 100644

--- a/docs/yum.8

+++ b/docs/yum.8

@@ -35,7 +35,7 @@ gnome\-packagekit application\&.

 .br 

 .I \fR * provides  | whatprovides feature1 [feature2] [\&.\&.\&.]

 .br  

-.I \fR * clean [ packages | headers | metadata | dbcache | all ]

+.I \fR * clean [ packages | metadata | expire-cache | rpmdb | plugins | all ]

 .br

 .I \fR * makecache

 .br

@@ -424,7 +424,8 @@ Eliminate the local data saying when the metadata and mirrorlists were downloade

 Eliminate any cached packages from the system.  Note that packages are not automatically deleted after they are downloaded.

 .IP "\fByum clean headers\fP"

-Eliminate all of the header files which yum uses for dependency resolution.

+Eliminate all of the header files, which old versions of yum used for

+dependency resolution.

 .IP "\fByum clean metadata\fP"

 Eliminate all of the files which yum uses to determine the remote

@@ -433,11 +434,22 @@ metadata the next time it is run.

 .IP "\fByum clean dbcache\fP"

 Eliminate the sqlite cache used for faster access to metadata.

-Using this option will force yum to recreate the cache the next time

-it is run.

+Using this option will force yum to download the sqlite metadata the next time

+it is run, or recreate the sqlite metadata if using an older repo.

+

+.IP "\fByum clean dbcache\fP"

+Eliminate the sqlite cache used for faster access to metadata.

+Using this option will force yum to download the sqlite metadata the next time

+it is run, or recreate the sqlite metadata if using an older repo.

+

+.IP "\fByum clean rpmdb\fP"

+Eliminate any cached data from the local rpmdb.

+

+.IP "\fByum clean plugins\fP"

+Tell any enabled plugins to eliminate their cached data.

 .IP "\fByum clean all\fP"

-Runs \fByum clean packages\fP and \fByum clean headers\fP, \fByum clean metadata\fP and \fByum clean dbcache\fP as above.

+Does all of the above.

 .PP

 .SH "MISC"

diff --git a/test/rpmdb-cache.py b/test/rpmdb-cache.py

new file mode 100755

index 0000000..7768a93

--- /dev/null

+++ b/test/rpmdb-cache.py

@@ -0,0 +1,87 @@

+#! /usr/bin/python -tt

+

+import sys

+import yum

+

+__provides_of_requires_exact__ = False

+

+yb1 = yum.YumBase()

+yb1.conf.cache = True

+yb2 = yum.YumBase()

+yb2.conf.cache = True

+

+if len(sys.argv) > 1 and sys.argv[1].lower() == 'full':

+    print "Doing full test"

+    __provides_of_requires_exact__ = True

+

+assert hasattr(yb1.rpmdb, '__cache_rpmdb__')

+yb1.rpmdb.__cache_rpmdb__ = False

+yb2.setCacheDir()

+

+# Version

+ver1 = yb1.rpmdb.simpleVersion(main_only=True)[0]

+ver2 = yb2.rpmdb.simpleVersion(main_only=True)[0]

+if ver1 != ver2:

+    print >>sys.stderr, "Error: Version mismatch:", ver1, ver2

+

+# Conflicts

+cpkgs1 = yb1.rpmdb.returnConflictPackages()

+cpkgs2 = yb2.rpmdb.returnConflictPackages()

+if len(cpkgs1) != len(cpkgs2):

+    print >>sys.stderr, "Error: Conflict len mismatch:", len(cpkgs1),len(cpkgs2)

+for pkg in cpkgs1:

+    if pkg not in cpkgs2:

+        print >>sys.stderr, "Error: Conflict cache missing", pkg

+for pkg in cpkgs2:

+    if pkg not in cpkgs1:

+        print >>sys.stderr, "Error: Conflict cache extra", pkg

+

+# File Requires

+frd1, blah, fpd1 = yb1.rpmdb.fileRequiresData()

+frd2, blah, fpd2 = yb2.rpmdb.fileRequiresData()

+if len(frd1) != len(frd2):

+    print >>sys.stderr, "Error: FileReq len mismatch:", len(frd1), len(frd2)

+for pkgtup in frd1:

+    if pkgtup not in frd2:

+        print >>sys.stderr, "Error: FileReq cache missing", pkgtup

+        continue

+    if len(set(frd1[pkgtup])) != len(set(frd2[pkgtup])):

+        print >>sys.stderr, ("Error: FileReq[%s] len mismatch:" % (pkgtup,),

+                             len(frd1[pkgtup]), len(frd2[pkgtup]))

+    for name in frd1[pkgtup]:

+        if name not in frd2[pkgtup]:

+            print >>sys.stderr, ("Error: FileReq[%s] cache missing" % (pkgtup,),

+                                 name)

+for pkgtup in frd2:

+    if pkgtup not in frd1:

+        print >>sys.stderr, "Error: FileReq cache extra", pkgtup

+        continue

+    for name in frd2[pkgtup]:

+        if name not in frd1[pkgtup]:

+            print >>sys.stderr, ("Error: FileReq[%s] cache extra" % (pkgtup,),

+                                 name)

+

+# File Provides (of requires) -- not exact

+if len(fpd1) != len(fpd2):

+    print >>sys.stderr, "Error: FileProv len mismatch:", len(fpd1), len(fpd2)

+for name in fpd1:

+    if name not in fpd2:

+        print >>sys.stderr, "Error: FileProv cache missing", name

+        continue

+

+    if not __provides_of_requires_exact__:

+        continue # We might be missing some providers

+

+    if len(fpd1[name]) != len(fpd2[name]):

+        print >>sys.stderr, ("Error: FileProv[%s] len mismatch:" % (pkgtup,),

+                             len(fpd1[name]), len(fpd2[name]))

+    for pkgtup in fpd1[name]:

+        if pkgtup not in fpd2[name]:

+            print >>sys.stderr,"Error: FileProv[%s] cache missing" % name,pkgtup

+for name in fpd2:

+    if name not in fpd1:

+        print >>sys.stderr, "Error: FileProv cache extra", name

+        continue

+    for pkgtup in fpd2[name]:

+        if pkgtup not in fpd1[name]:

+            print >>sys.stderr,"Error: FileProv[%s] cache extra" % name,pkgtup

diff --git a/test/testbase.py b/test/testbase.py

index 3edfe57..c7a1ffe 100644

--- a/test/testbase.py

+++ b/test/testbase.py

@@ -14,6 +14,7 @@ from yum import packages

 from yum import packageSack

 from yum.constants import TS_INSTALL_STATES, TS_REMOVE_STATES

 from cli import YumBaseCli

+from yum.rpmsack import RPMDBPackageSack as _rpmdbsack

 import inspect

 from rpmUtils import arch

@@ -233,6 +234,50 @@ class FakeRpmDb(packageSack.PackageSack):

     def __init__(self):

         packageSack.PackageSack.__init__(self)

+    # Need to mock out rpmdb caching... copy&paste. Gack.

+    def returnConflictPackages(self):

+        ret = []

+        for pkg in self.returnPackages():

+            if len(pkg.conflicts):

+                ret.append(pkg)

+        return ret

+    def fileRequiresData(self):

+        installedFileRequires = {}

+        installedUnresolvedFileRequires = set()

+        resolved = set()

+        for pkg in self.returnPackages():

+            for name, flag, evr in pkg.requires:

+                if not name.startswith('/'):

+                    continue

+                installedFileRequires.setdefault(pkg.pkgtup, []).append(name)

+                if name not in resolved:

+                    dep = self.getProvides(name, flag, evr)

+                    resolved.add(name)

+                    if not dep:

+                        installedUnresolvedFileRequires.add(name)

+

+        fileRequires = set()

+        for fnames in installedFileRequires.itervalues():

+            fileRequires.update(fnames)

+        installedFileProviders = {}

+        for fname in fileRequires:

+            pkgtups = [pkg.pkgtup for pkg in self.getProvides(fname)]

+            installedFileProviders[fname] = pkgtups

+

+        ret =  (installedFileRequires, installedUnresolvedFileRequires,

+                installedFileProviders)

+

+        return ret

+    def transactionCacheFileRequires(self, installedFileRequires,

+                                     installedUnresolvedFileRequires,

+                                     installedFileProvides,

+                                     problems):

+        return

+    def transactionCacheConflictPackages(self, pkgs):

+        return

+    def transactionResultVersion(self, rpmdbv):

+        return

+

     def getProvides(self, name, flags=None, version=(None, None, None)):

         """return dict { packages -> list of matching provides }"""

         self._checkIndexes(failure='build')

diff --git a/yum/__init__.py b/yum/__init__.py

index 2aaa66a..affa92b 100644

--- a/yum/__init__.py

+++ b/yum/__init__.py

@@ -469,7 +469,8 @@ class YumBase(depsolve.Depsolve):

             self.verbose_logger.log(logginglevels.DEBUG_4,

                                     _('Reading Local RPMDB'))

             self._rpmdb = rpmsack.RPMDBPackageSack(root=self.conf.installroot,

-                                                   releasever=self.yumvar['releasever'])

+                                                   releasever=self.yumvar['releasever'],

+                                                   cachedir=self.conf.cachedir)

             self.verbose_logger.debug('rpmdb time: %0.3f' % (time.time() - rpmdb_st))

         return self._rpmdb

@@ -1072,6 +1073,13 @@ class YumBase(depsolve.Depsolve):

         if self.conf.history_record:

             self.history.beg(rpmdbv, using_pkgs, list(self.tsInfo))

+        #  Just before we update the transaction, update what we think the

+        # rpmdb will look like. This needs to be done before the run, so that if

+        # "something" happens and the rpmdb is different from what we think it

+        # will be we store what we thought, not what happened (so it'll be an

+        # invalid cache).

+        self.rpmdb.transactionResultVersion(self.tsInfo.futureRpmDBVersion())

+

         errors = self.ts.run(cb.callback, '')

         # ts.run() exit codes are, hmm, "creative": None means all ok, empty 

         # list means some errors happened in the transaction and non-empty 

@@ -1699,6 +1707,11 @@ class YumBase(depsolve.Depsolve):

         exts = ['cachecookie', 'mirrorlist.txt']

         return self._cleanFiles(exts, 'cachedir', 'metadata')

+    def cleanRpmDB(self):

+        cachedir = self.conf.cachedir + "/rpmdb-cache/"

+        filelist = misc.getFileList(cachedir, '', [])

+        return self._cleanFilelist('rpmdb', filelist)

+

     def _cleanFiles(self, exts, pathattr, filetype):

         filelist = []

         removed = 0

@@ -1707,7 +1720,9 @@ class YumBase(depsolve.Depsolve):

                 path = getattr(repo, pathattr)

                 if os.path.exists(path) and os.path.isdir(path):

                     filelist = misc.getFileList(path, ext, filelist)

+        self._cleanFilelist(filetype, filelist)

+    def _cleanFilelist(self, filetype, filelist):

         for item in filelist:

             try:

                 misc.unlink_f(item)

@@ -4163,7 +4178,9 @@ class YumBase(depsolve.Depsolve):

         if cachedir is None:

             return False # Tried, but failed, to get a "user" cachedir

-        self.repos.setCacheDir(cachedir + varReplace(suffix, self.yumvar))

+        cachedir += varReplace(suffix, self.yumvar)

+        self.repos.setCacheDir(cachedir)

+        self.rpmdb.setCacheDir(cachedir)

         return True # We got a new cache dir

diff --git a/yum/depsolve.py b/yum/depsolve.py

index 7871e98..b5953c2 100644

--- a/yum/depsolve.py

+++ b/yum/depsolve.py

@@ -918,31 +918,27 @@ class Depsolve(object):

     def _checkFileRequires(self):

         fileRequires = set()

+        nfileRequires = set() # These need to be looked up in the rpmdb.

         reverselookup = {}

         ret = []

         # generate list of file requirement in rpmdb

         if self.installedFileRequires is None:

-            self.installedFileRequires = {}

-            self.installedUnresolvedFileRequires = set()

-            resolved = set()

-            for pkg in self.rpmdb.returnPackages():

-                for name, flag, evr in pkg.requires:

-                    if not name.startswith('/'):

-                        continue

-                    self.installedFileRequires.setdefault(pkg, []).append(name)

-                    if name not in resolved:

-                        dep = self.rpmdb.getProvides(name, flag, evr)

-                        resolved.add(name)

-                        if not dep:

-                            self.installedUnresolvedFileRequires.add(name)

+            self.installedFileRequires, \

+              self.installedUnresolvedFileRequires, \

+              self.installedFileProviders = self.rpmdb.fileRequiresData()

         # get file requirements from packages not deleted

-        for po, files in self.installedFileRequires.iteritems():

-            if not self._tsInfo.getMembersWithState(po.pkgtup, output_states=TS_REMOVE_STATES):

+        todel = []

+        for pkgtup, files in self.installedFileRequires.iteritems():

+            if self._tsInfo.getMembersWithState(pkgtup, output_states=TS_REMOVE_STATES):

+                todel.append(pkgtup)

+            else:

                 fileRequires.update(files)

                 for filename in files:

-                    reverselookup.setdefault(filename, []).append(po)

+                    reverselookup.setdefault(filename, []).append(pkgtup)

+        for pkgtup in todel:

+            del self.installedFileRequires[pkgtup]

         fileRequires -= self.installedUnresolvedFileRequires

@@ -950,6 +946,8 @@ class Depsolve(object):

         for txmbr in self._tsInfo.getMembersWithState(output_states=TS_INSTALL_STATES):

             for name, flag, evr in txmbr.po.requires:

                 if name.startswith('/'):

+                    pt = txmbr.po.pkgtup

+                    self.installedFileRequires.setdefault(pt, []).append(name)

                     # check if file requires was already unresolved in update

                     if name in self.installedUnresolvedFileRequires:

                         already_broken = False

@@ -959,23 +957,75 @@ class Depsolve(object):

                                 break

                         if already_broken:

                             continue

+                    if name not in fileRequires:

+                        nfileRequires.add(name)

                     fileRequires.add(name)

-                    reverselookup.setdefault(name, []).append(txmbr.po)

+                    reverselookup.setdefault(name, []).append(txmbr.po.pkgtup)

+

+        todel = []

+        for fname in self.installedFileProviders:

+            niFP_fname = []

+            for pkgtup in self.installedFileProviders[fname]:

+                if self._tsInfo.getMembersWithState(pkgtup, output_states=TS_REMOVE_STATES):

+                    continue

+                niFP_fname.append(pkgtup)

+

+            if not niFP_fname:

+                todel.append(fname)

+                continue

+

+            self.installedFileProviders[fname] = niFP_fname

+        for fname in todel:

+            del self.installedFileProviders[fname]

         # check the file requires

+        iFP = self.installedFileProviders

         for filename in fileRequires:

-            if not self.tsInfo.getOldProvides(filename) and not self.tsInfo.getNewProvides(filename):

-                for po in reverselookup[filename]:

-                    ret.append( (po, (filename, 0, '')) )

+            # In theory we need this to be:

+            #

+            # nprov, filename in iFP (or new), oprov

+            #

+            # ...this keeps the cache exactly the same as the non-cached data.

+            # However that also means that we'll always need the filelists, so

+            # we do:

+            #

+            # filename in iFP (if found return), oprov (if found return),

+            # nprov

+            #

+            # ...this means we'll always get the same _result_ (as we only need

+            # to know if _something_ provides), but our cache will be off on

+            # what does/doesn't provide the file.

+            if filename in self.installedFileProviders:

+                continue

-        return ret

+            oprov = self.tsInfo.getOldProvides(filename)

+            if oprov:

+                iFP.setdefault(filename, []).extend([po.pkgtup for po in oprov])

+                continue

+

+            nprov = self.tsInfo.getNewProvides(filename)

+            if nprov:

+                iFP.setdefault(filename, []).extend([po.pkgtup for po in nprov])

+                continue 

+

+            for pkgtup in reverselookup[filename]:

+                po = self.getInstalledPackageObject(pkgtup)

+                ret.append( (po, (filename, 0, '')) )

+        self.rpmdb.transactionCacheFileRequires(self.installedFileRequires, 

+                                        self.installedUnresolvedFileRequires,

+                                        self.installedFileProviders,

+                                        ret)

+

+        return ret

     def _checkConflicts(self):

         ret = [ ]

-        for po in self.rpmdb.returnPackages():

+        cpkgs = []

+        for po in self.rpmdb.returnConflictPackages():

             if self.tsInfo.getMembersWithState(po.pkgtup, output_states=TS_REMOVE_STATES):

                 continue

+            cpkgs.append(po)

             for conflict in po.returnPrco('conflicts'):

                 (r, f, v) = conflict

                 for conflicting_po in self.tsInfo.getNewProvides(r, f, v):

@@ -985,16 +1035,20 @@ class Depsolve(object):

                                  conflicting_po) )

         for txmbr in self.tsInfo.getMembersWithState(output_states=TS_INSTALL_STATES):

             po = txmbr.po

+            done = False

             for conflict in txmbr.po.returnPrco('conflicts'):

+                if not done:

+                    cpkgs.append(txmbr.po)

+                    done = True

                 (r, f, v) = conflict

                 for conflicting_po in self.tsInfo.getProvides(r, f, v):

                     if conflicting_po.pkgtup[0] == po.pkgtup[0] and conflicting_po.pkgtup[2:] == po.pkgtup[2:]:

                         continue

                     ret.append( (po, self._prco_req_nfv2req(r, f, v),

                                  conflicting_po) )

+        self.rpmdb.transactionCacheConflictPackages(cpkgs)

         return ret

-

     def isPackageInstalled(self, pkgname):

         lst = self.tsInfo.matchNaevr(name = pkgname)

         for txmbr in lst:

diff --git a/yum/rpmsack.py b/yum/rpmsack.py

index 151e33e..a5f4042 100644

--- a/yum/rpmsack.py

+++ b/yum/rpmsack.py

@@ -97,7 +97,10 @@ class RPMDBPackageSack(PackageSackBase):

                            rpm.RPMTAG_OBSOLETEFLAGS)

             }

-    def __init__(self, root='/', releasever=None):

+    # Do we want to cache rpmdb data in a file, for later use?

+    __cache_rpmdb__ = True

+

+    def __init__(self, root='/', releasever=None, cachedir=None):

         self.root = root

         self._idx2pkg = {}

         self._name2pkg = {}

@@ -107,6 +110,13 @@ class RPMDBPackageSack(PackageSackBase):

         self._get_pro_cache = {}

         self._get_req_cache  = {}

         self._loaded_gpg_keys = False

+        if cachedir is None:

+            cachedir = misc.getCacheDir()

+        self.setCacheDir(cachedir)

+        self._have_cached_rpmdbv_data = None

+        self._cached_conflicts_data = None

+        # Store the result of what happens, if a transaction completes.

+        self._trans_cache_store = {}

         self.ts = None

         self.releasever = releasever

         self.auto_close = False # this forces a self.ts.close() after

@@ -153,6 +163,13 @@ class RPMDBPackageSack(PackageSackBase):

             'conflicts' : { },

             'obsoletes' : { },

             }

+        self._have_cached_rpmdbv_data = None

+        self._cached_conflicts_data = None

+

+    def setCacheDir(self, cachedir):

+        """ Sets the internal cachedir value for the rpmdb, to be the

+            "rpmdb-cache" directory from this parent. """

+        self._cachedir = cachedir + "/rpmdb-cache/"

     def readOnlyTS(self):

         if not self.ts:

@@ -367,6 +384,103 @@ class RPMDBPackageSack(PackageSackBase):

             pkgobjlist = pkgobjlist[0] + pkgobjlist[1]

         return pkgobjlist

+    def _uncached_returnConflictPackages(self):

+        if self._cached_conflicts_data is None:

+            ret = []

+            for pkg in self.returnPackages():

+                if len(pkg.conflicts):

+                    ret.append(pkg)

+            self._cached_conflicts_data = ret

+        return self._cached_conflicts_data

+

+    def _write_conflicts_new(self, pkgs, rpmdbv):

+        if not os.access(self._cachedir, os.W_OK):

+            return

+

+        conflicts_fname = self._cachedir + '/conflicts'

+        fo = open(conflicts_fname + '.tmp', 'w')

+        fo.write("%s\n" % rpmdbv)

+        fo.write("%u\n" % len(pkgs))

+        for pkg in sorted(pkgs):

+            for var in pkg.pkgtup:

+                fo.write("%s\n" % var)

+        fo.close()

+        os.rename(conflicts_fname + '.tmp', conflicts_fname)

+

+    def _write_conflicts(self, pkgs):

+        rpmdbv = self.simpleVersion(main_only=True)[0]

+        self._write_conflicts_new(pkgs, rpmdbv)

+

+    def _read_conflicts(self):

+        if not self.__cache_rpmdb__:

+            return None

+

+        def _read_str(fo):

+            return fo.readline()[:-1]

+

+        conflict_fname = self._cachedir + '/conflicts'

+        if not os.path.exists(conflict_fname):

+            return None

+

+        fo = open(conflict_fname)

+        frpmdbv = fo.readline()

+        rpmdbv = self.simpleVersion(main_only=True)[0]

+        if not frpmdbv or rpmdbv != frpmdbv[:-1]:

+            return None

+

+        ret = []

+        try:

+            # Read the conflicts...

+            pkgtups_num = int(_read_str(fo))

+            while pkgtups_num > 0:

+                pkgtups_num -= 1

+

+                # n, a, e, v, r

+                pkgtup = (_read_str(fo), _read_str(fo),

+                          _read_str(fo), _read_str(fo), _read_str(fo))

+                int(pkgtup[2]) # Check epoch is valid

+                ret.extend(self.searchPkgTuple(pkgtup))

+            if fo.readline() != '': # Should be EOF

+                return None

+        except ValueError:

+            return None

+

+        self._cached_conflicts_data = ret

+        return self._cached_conflicts_data

+

+    def transactionCacheConflictPackages(self, pkgs):

+        if self.__cache_rpmdb__:

+            self._trans_cache_store['conflicts'] = pkgs

+

+    def returnConflictPackages(self):

+        """ Return a list of packages that have conflicts. """

+        pkgs = self._read_conflicts()

+        if pkgs is None:

+            pkgs = self._uncached_returnConflictPackages()

+            if self.__cache_rpmdb__:

+                self._write_conflicts(pkgs)

+

+        return pkgs

+

+    def transactionResultVersion(self, rpmdbv):

+        """ We are going to do a transaction, and the parameter will be the

+            rpmdb version when we finish. The idea being we can update all

+            our rpmdb caches for that rpmdb version. """

+

+        if not self.__cache_rpmdb__:

+            self._trans_cache_store = {}

+            return

+

+        if 'conflicts' in self._trans_cache_store:

+            pkgs = self._trans_cache_store['conflicts']

+            self._write_conflicts_new(pkgs, rpmdbv)

+

+        if 'file-requires' in self._trans_cache_store:

+            data = self._trans_cache_store['file-requires']

+            self._write_file_requires(rpmdbv, data)

+

+        self._trans_cache_store = {}

+

     def returnGPGPubkeyPackages(self):

         """ Return packages of the gpg-pubkeys ... hacky. """

         ts = self.readOnlyTS()

@@ -377,6 +491,198 @@ class RPMDBPackageSack(PackageSackBase):

             ret.append(self._makePackageObject(hdr, mi.instance()))

         return ret

+    def _read_file_requires(self):

+        def _read_str(fo):

+            return fo.readline()[:-1]

+

+        assert self.__cache_rpmdb__

+        if not os.path.exists(self._cachedir + '/file-requires'):

+            return None, None

+

+        rpmdbv = self.simpleVersion(main_only=True)[0]

+        fo = open(self._cachedir + '/file-requires')

+        frpmdbv = fo.readline()

+        if not frpmdbv or rpmdbv != frpmdbv[:-1]:

+            return None, None

+

+        iFR = {}

+        iFP = {}

+        try:

+            # Read the requires...

+            pkgtups_num = int(_read_str(fo))

+            while pkgtups_num > 0:

+                pkgtups_num -= 1

+

+                # n, a, e, v, r

+                pkgtup = (_read_str(fo), _read_str(fo),

+                          _read_str(fo), _read_str(fo), _read_str(fo))

+                int(pkgtup[2]) # Check epoch is valid

+

+                files_num = int(_read_str(fo))

+                while files_num > 0:

+                    files_num -= 1

+

+                    fname = _read_str(fo)

+

+                    iFR.setdefault(pkgtup, []).append(fname)

+

+            # Read the provides...

+            files_num = int(_read_str(fo))

+            while files_num > 0:

+                files_num -= 1

+                fname = _read_str(fo)

+                pkgtups_num = int(_read_str(fo))

+                while pkgtups_num > 0:

+                    pkgtups_num -= 1

+

+                    # n, a, e, v, r

+                    pkgtup = (_read_str(fo), _read_str(fo),

+                              _read_str(fo), _read_str(fo), _read_str(fo))

+                    int(pkgtup[2]) # Check epoch is valid

+

+                    iFP.setdefault(fname, []).append(pkgtup)

+

+            if fo.readline() != '': # Should be EOF

+                return None, None

+        except ValueError:

+            return None, None

+

+        return iFR, iFP

+

+    def fileRequiresData(self):

+        """ Get a cached copy of the fileRequiresData for

+            depsolving/checkFileRequires, note the giant comment in that

+            function about how we don't keep this perfect for the providers of

+            the requires. """

+        if self.__cache_rpmdb__:

+            iFR, iFP = self._read_file_requires()

+            if iFR is not None:

+                return iFR, set(), iFP

+

+        installedFileRequires = {}

+        installedUnresolvedFileRequires = set()

+        resolved = set()

+        for pkg in self.returnPackages():

+            for name, flag, evr in pkg.requires:

+                if not name.startswith('/'):

+                    continue

+                installedFileRequires.setdefault(pkg.pkgtup, []).append(name)

+                if name not in resolved:

+                    dep = self.getProvides(name, flag, evr)

+                    resolved.add(name)

+                    if not dep:

+                        installedUnresolvedFileRequires.add(name)

+

+        fileRequires = set()

+        for fnames in installedFileRequires.itervalues():

+            fileRequires.update(fnames)

+        installedFileProviders = {}

+        for fname in fileRequires:

+            pkgtups = [pkg.pkgtup for pkg in self.getProvides(fname)]

+            installedFileProviders[fname] = pkgtups

+

+        ret =  (installedFileRequires, installedUnresolvedFileRequires,

+                installedFileProviders)

+        if self.__cache_rpmdb__:

+            rpmdbv = self.simpleVersion(main_only=True)[0]

+            self._write_file_requires(rpmdbv, ret)

+

+        return ret

+

+    def transactionCacheFileRequires(self, installedFileRequires,

+                                     installedUnresolvedFileRequires,

+                                     installedFileProvides,

+                                     problems):

+        if not self.__cache_rpmdb__:

+            return

+

+        if installedUnresolvedFileRequires or problems:

+            return

+

+        data = (installedFileRequires,

+                installedUnresolvedFileRequires,

+                installedFileProvides)

+

+        self._trans_cache_store['file-requires'] = data

+

+    def _write_file_requires(self, rpmdbversion, data):

+        if not os.access(self._cachedir, os.W_OK):

+            return

+

+        (installedFileRequires,

+         installedUnresolvedFileRequires,

+         installedFileProvides) = data

+

+        fo = open(self._cachedir + '/file-requires.tmp', 'w')

+        fo.write("%s\n" % rpmdbversion)

+

+        fo.write("%u\n" % len(installedFileRequires))

+        for pkgtup in sorted(installedFileRequires):

+            for var in pkgtup:

+                fo.write("%s\n" % var)

+            filenames = set(installedFileRequires[pkgtup])

+            fo.write("%u\n" % len(filenames))

+            for fname in sorted(filenames):

+                fo.write("%s\n" % fname)

+

+        fo.write("%u\n" % len(installedFileProvides))

+        for fname in sorted(installedFileProvides):

+            fo.write("%s\n" % fname)

+

+            pkgtups = set(installedFileProvides[fname])

+            fo.write("%u\n" % len(pkgtups))

+            for pkgtup in sorted(pkgtups):

+                for var in pkgtup:

+                    fo.write("%s\n" % var)

+        fo.close()

+        os.rename(self._cachedir + '/file-requires.tmp',

+                  self._cachedir + '/file-requires')

+

+    def _get_cached_simpleVersion_main(self):

+        """ Return the cached string of the main rpmdbv. """

+        if self._have_cached_rpmdbv_data is not None:

+            return self._have_cached_rpmdbv_data

+

+        if not self.__cache_rpmdb__:

+            return None

+

+        #  This test is "obvious" and the only thing to come out of:

+        # http://lists.rpm.org/pipermail/rpm-maint/2007-November/001719.html

+        # ...if anything gets implemented, we should change.

+        rpmdbvfname = self._cachedir + "/version"

+        rpmdbfname  = "/var/lib/rpm/Packages"

+

+        if os.path.exists(rpmdbvfname) and os.path.exists(rpmdbfname):

+            # See if rpmdb has "changed" ...

+            nmtime = os.path.getmtime(rpmdbvfname)

+            omtime = os.path.getmtime(rpmdbfname)

+            if omtime <= nmtime:

+                rpmdbv = open(rpmdbvfname).readline()[:-1]

+                self._have_cached_rpmdbv_data  = rpmdbv

+        return self._have_cached_rpmdbv_data

+

+    def _put_cached_simpleVersion_main(self, rpmdbv):

+        self._have_cached_rpmdbv_data  = str(rpmdbv)

+

+        if not self.__cache_rpmdb__:

+            return

+

+        rpmdbvfname = self._cachedir + "/version"

+        if not os.access(self._cachedir, os.W_OK):

+            if os.path.exists(self._cachedir):

+                return

+

+            try:

+                os.makedirs(self._cachedir)

+            except (IOError, OSError), e:

+                return

+

+        fo = open(rpmdbvfname + ".tmp", "w")

+        fo.write(self._have_cached_rpmdbv_data)

+        fo.write('\n')

+        fo.close()

+        os.rename(rpmdbvfname + ".tmp", rpmdbvfname)

+

     def simpleVersion(self, main_only=False, groups={}):

         """ Return a simple version for all installed packages. """

         def _up_revs(irepos, repoid, rev, pkg, csum):

@@ -387,6 +693,11 @@ class RPMDBPackageSack(PackageSackBase):

                 rpsv = irevs.setdefault(rev, PackageSackVersion())

                 rpsv.update(pkg, csum)

+        if main_only and not groups:

+            rpmdbv = self._get_cached_simpleVersion_main()

+            if rpmdbv is not None:

+                return [rpmdbv, {}]

+

         main = PackageSackVersion()

         irepos = {}

         main_grps = {}

@@ -420,6 +731,9 @@ class RPMDBPackageSack(PackageSackBase):

                 if pkg.name in groups[group]:

                     _up_revs(irepos_grps[group], repoid, rev, pkg, csum)

+        if self._have_cached_rpmdbv_data is None:

+            self._put_cached_simpleVersion_main(main)

+

         if groups:

             return [main, irepos, main_grps, irepos_grps]

         return [main, irepos]

diff --git a/yum/transactioninfo.py b/yum/transactioninfo.py

index c2fc804..c7d5b8c 100644

--- a/yum/transactioninfo.py

+++ b/yum/transactioninfo.py

@@ -26,7 +26,7 @@ to rpm.

 """

 from constants import *

-from packageSack import PackageSack

+from packageSack import PackageSack, PackageSackVersion

 from packages import YumInstalledPackage

 from sqlitesack import YumAvailablePackageSqlite

 import Errors

@@ -558,6 +558,42 @@ class TransactionData:

         result.update(self.getNewRequires(name, flag, version))

         return result

+    def futureRpmDBVersion(self):

+        """ Return a simple version for the future rpmdb. Works like

+            rpmdb.simpleVersion(main_only=True)[0], but for the state the rpmdb

+            will be in after the transaction. """

+        pkgs = self.rpmdb.returnPackages()

+        _reinstalled_pkgtups = {}

+        for txmbr in self.getMembersWithState(None, TS_INSTALL_STATES):

+            # reinstalls have to use their "new" checksum data, in case it's

+            # different.

+            if hasattr(txmbr, 'reinstall') and txmbr.reinstall:

+                _reinstalled_pkgtups[txmbr.po.pkgtup] = txmbr.po

+            pkgs.append(txmbr.po)

+

+        main = PackageSackVersion()

+        for pkg in sorted(pkgs):

+            if pkg.repoid != 'installed':

+                # Paste from PackageSackBase.simpleVersion()

+                csum = pkg.returnIdSum()

+                main.update(pkg, csum)

+                continue

+

+            # Installed pkg, see if it's about to die

+            if self.getMembersWithState(pkg.pkgtup, TS_REMOVE_STATES):

+                continue

+            # ...or die and be risen again (Zombie!)

+            if pkg.pkgtup in _reinstalled_pkgtups:

+                continue

+

+            # Paste from rpmdb.simpleVersion()

+            ydbi = pkg.yumdb_info

+            csum = None

+            if 'checksum_type' in ydbi and 'checksum_data' in ydbi:

+                csum = (ydbi.checksum_type, ydbi.checksum_data)

+            main.update(pkg, csum)

+        return main