Cleanup preserved lib locking in portage.

pym/portage/dbapi/vartree.py

 # Copyright 1998-2011 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 __all__ = [
         "vardbapi", "vartree", "dblink"] + \
         ["write_contents", "tar_contents"]
 
 import portage
 portage.proxy.lazyimport.lazyimport(globals(),
         'portage.checksum:_perform_md5_merge@perform_md5',
@@ skipping 130 matching lines @@
                         "repository", "RESTRICT" , "SLOT", "USE", "DEFINED_PHASES",
                         "REQUIRED_USE"])
                 self._aux_cache_obj = None
                 self._aux_cache_filename = os.path.join(self._eroot,
                         CACHE_PATH, "vdb_metadata.pickle")
                 self._counter_path = os.path.join(self._eroot,
                         CACHE_PATH, "counter")
 
                 self._plib_registry = None
                 if _ENABLE_PRESERVE_LIBS:
-                        try:
-                                self._plib_registry = PreservedLibsRegistry(self.root,
-                                        os.path.join(self._eroot, PRIVATE_PATH,
-                                        "preserved_libs_registry"))
-                        except PermissionDenied:
-                                # apparently this user isn't allowed to access PRIVATE_PATH
-                                pass
+                        self._plib_registry = PreservedLibsRegistry(self.root,
+                                os.path.join(self._eroot, PRIVATE_PATH,
+                                "preserved_libs_registry"))
 
                 self._linkmap = None
                 if _ENABLE_DYN_LINK_MAP:
                         self._linkmap = LinkageMap(self)
                 self._owners = self._owners_db(self)
 
         def getpath(self, mykey, filename=None):
                 # This is an optimized hotspot, so don't use unicode-wrapped
                 # os module and don't use os.path.join().
                 rValue = self._eroot + VDB_PATH + _os.sep + mykey
@@ skipping 1262 matching lines @@
 
                         pkgfiles[path] = data
 
                 if errors:
                         writemsg(_("!!! Parse error in '%s'\n") % contents_file, noiselevel=-1)
                         for pos, e in errors:
                                 writemsg(_("!!!   line %d: %s\n") % (pos, e), noiselevel=-1)
                 self.contentscache = pkgfiles
                 return pkgfiles
 
+        def _prune_plib_registry(self, others_in_slot=[]):
+                # remove preserved libraries that don't have any consumers left
+                plib_registry = self.vartree.dbapi._plib_registry
+                if plib_registry:
+                        plib_registry.lock()
+                        try:
+                                plib_registry.load()
+
+                                # Skip this if another package in the same slot has just been
+                                # merged on top of this package, since the other package has
+                                # already called LinkageMap.rebuild() and passed it's NEEDED file
+                                # in as an argument.
+                                if not others_in_slot:
+                                        self._linkmap_rebuild(exclude_pkgs=(self.mycpv,))
+
+                                cpv_lib_map = self._find_unused_preserved_libs()
+                                if cpv_lib_map:
+                                        self._remove_preserved_libs(cpv_lib_map)
+                                        for cpv, removed in cpv_lib_map.items():
+                                                if not self.vartree.dbapi.cpv_exists(cpv):
+                                                        for dblnk in others_in_slot:
+                                                                if dblnk.mycpv == cpv:
+                                                                        # This one just got merged so it doesn't
+                                                                        # register with cpv_exists() yet.
+                                                                        self.vartree.dbapi.removeFromContents(
+                                                                                dblnk, removed)
+                                                                        break
+                                                        continue
+                                                self.vartree.dbapi.removeFromContents(cpv, removed)
+                                plib_registry.unregister(self.mycpv, self.settings["SLOT"],
+                                        self.vartree.dbapi.cpv_counter(self.mycpv))
+                                plib_registry.store()
+                        finally:
+                                plib_registry.unlock()
+
         def unmerge(self, pkgfiles=None, trimworld=None, cleanup=True,
                 ldpath_mtimes=None, others_in_slot=None):
                 """
                 Calls prerm
                 Unmerges a given package (CPV)
                 calls postrm
                 calls cleanrm
                 calls env_update
                 
                 @param pkgfiles: files to unmerge (generally self.getcontents() )
@@ skipping 117 matching lines @@
 
                                 # XXX: Decide how to handle failures here.
                                 if retval != os.EX_OK:
                                         failures += 1
                                         showMessage(_("!!! FAILED prerm: %s\n") % retval,
                                                 level=logging.ERROR, noiselevel=-1)
 
                         self._unmerge_pkgfiles(pkgfiles, others_in_slot)
                         self._clear_contents_cache()
 
-                        # Remove the registration of preserved libs for this pkg instance
-                        plib_registry = self.vartree.dbapi._plib_registry
-                        if plib_registry is None:
-                                # preserve-libs is entirely disabled
-                                pass
-                        else:
-                                plib_registry.unregister(self.mycpv, self.settings["SLOT"],
-                                        self.vartree.dbapi.cpv_counter(self.mycpv))
-
                         if myebuildpath:
                                 ebuild_phase = "postrm"
                                 phase = EbuildPhase(background=background,
                                         phase=ebuild_phase, scheduler=scheduler,
                                         settings=self.settings)
                                 phase.start()
                                 retval = phase.wait()
 
                                 # XXX: Decide how to handle failures here.
                                 if retval != os.EX_OK:
                                         failures += 1
                                         showMessage(_("!!! FAILED postrm: %s\n") % retval,
                                                 level=logging.ERROR, noiselevel=-1)
 
-                        # Skip this if another package in the same slot has just been
-                        # merged on top of this package, since the other package has
-                        # already called LinkageMap.rebuild() and passed it's NEEDED file
-                        # in as an argument.
-                        if not others_in_slot:
-                                self._linkmap_rebuild(exclude_pkgs=(self.mycpv,))
-
-                        # remove preserved libraries that don't have any consumers left
-                        cpv_lib_map = self._find_unused_preserved_libs()
-                        if cpv_lib_map:
-                                self._remove_preserved_libs(cpv_lib_map)
-                                for cpv, removed in cpv_lib_map.items():
-                                        if not self.vartree.dbapi.cpv_exists(cpv):
-                                                for dblnk in others_in_slot:
-                                                        if dblnk.mycpv == cpv:
-                                                                # This one just got merged so it doesn't
-                                                                # register with cpv_exists() yet.
-                                                                self.vartree.dbapi.removeFromContents(
-                                                                        dblnk, removed)
-                                                                break
-                                                continue
-                                        self.vartree.dbapi.removeFromContents(cpv, removed)
-                        else:
-                                # Prune any preserved libs that may have
-                                # been unmerged with this package.
-                                if plib_registry is None:
-                                        # preserve-libs is entirely disabled
-                                        pass
-                                else:
-                                        plib_registry.pruneNonExisting()
-
+                        self._prune_plib_registry(others_in_slot)
                 finally:
                         self.vartree.dbapi._bump_mtime(self.mycpv)
                         if builddir_lock:
                                 try:
                                         if myebuildpath:
                                                 if retval != os.EX_OK:
                                                         msg_lines = []
                                                         msg = _("The '%(ebuild_phase)s' "
                                                         "phase of the '%(cpv)s' package "
                                                         "has failed with exit value %(retval)s.") % \
@@ skipping 1687 matching lines @@
                         showMessage(colorize("WARN", _("WARNING:"))
                                 + _(" AUTOCLEAN is disabled.  This can cause serious"
                                 " problems due to overlapping packages.\n"),
                                 level=logging.WARN, noiselevel=-1)
 
                 # We hold both directory locks.
                 self.dbdir = self.dbpkgdir
                 self.delete()
                 _movefile(self.dbtmpdir, self.dbpkgdir, mysettings=self.settings)
 
-                # keep track of the libs we preserved
-                if self.vartree.dbapi._plib_registry is not None and \
-                        preserve_paths:
-                        self.vartree.dbapi._plib_registry.register(self.mycpv,
-                                slot, counter, sorted(preserve_paths))
-
                 # Check for file collisions with blocking packages
                 # and remove any colliding files from their CONTENTS
                 # since they now belong to this package.
                 self._clear_contents_cache()
                 contents = self.getcontents()
                 destroot_len = len(destroot) - 1
                 for blocker in blockers:
                         self.vartree.dbapi.removeFromContents(blocker, iter(contents),
                                 relative_paths=False)
 
-                # Unregister any preserved libs that this package has overwritten
-                # and update the contents of the packages that owned them.
                 plib_registry = self.vartree.dbapi._plib_registry
-                if plib_registry is None:
-                        # preserve-libs is entirely disabled
-                        pass
-                else:
-                        plib_dict = plib_registry.getPreservedLibs()
-                        for cpv, paths in plib_collisions.items():
-                                if cpv not in plib_dict:
-                                        continue
-                                if cpv == self.mycpv:
-                                        continue
-                                try:
-                                        slot, counter = self.vartree.dbapi.aux_get(
-                                                cpv, ["SLOT", "COUNTER"])
-                                except KeyError:
-                                        continue
-                                remaining = [f for f in plib_dict[cpv] if f not in paths]
-                                plib_registry.register(cpv, slot, counter, remaining)
-                                self.vartree.dbapi.removeFromContents(cpv, paths)
+                if plib_registry:
+                        plib_registry.lock()
+                        try:
+                                plib_registry.load()
+
+                                if preserve_paths:
+                                        # keep track of the libs we preserved
+                                        plib_registry.register(self.mycpv, slot, counter,
+                                                sorted(preserve_paths))
+
+                                # Unregister any preserved libs that this package has overwritten
+                                # and update the contents of the packages that owned them.
+                                plib_dict = plib_registry.getPreservedLibs()
+                                for cpv, paths in plib_collisions.items():
+                                        if cpv not in plib_dict:
+                                                continue
+                                        if cpv == self.mycpv:
+                                                continue
+                                        try:
+                                                slot, counter = self.vartree.dbapi.aux_get(
+                                                        cpv, ["SLOT", "COUNTER"])
+                                        except KeyError:
+                                                continue
+                                        remaining = [f for f in plib_dict[cpv] if f not in paths]
+                                        plib_registry.register(cpv, slot, counter, remaining)
+                                        self.vartree.dbapi.removeFromContents(cpv, paths)
+
+                                plib_registry.store()
+                        finally:
+                                plib_registry.unlock()
 
                 self.vartree.dbapi._add(self)
                 contents = self.getcontents()
 
                 #do postinst script
                 self.settings["PORTAGE_UPDATE_ENV"] = \
                         os.path.join(self.dbpkgdir, "environment.bz2")
                 self.settings.backup_changes("PORTAGE_UPDATE_ENV")
                 try:
                         if scheduler is None:
@@ skipping 18 matching lines @@
                                 downgrade = True
 
                 #update environment settings, library paths. DO NOT change symlinks.
                 env_update(makelinks=(not downgrade),
                         target_root=self.settings['ROOT'], prev_mtimes=prev_mtimes,
                         contents=contents, env=self.settings.environ(),
                         writemsg_level=self._display_merge)
 
                 # For gcc upgrades, preserved libs have to be removed after the
                 # the library path has been updated.
-                self._linkmap_rebuild()
-                cpv_lib_map = self._find_unused_preserved_libs()
-                if cpv_lib_map:
-                        self._remove_preserved_libs(cpv_lib_map)
-                        for cpv, removed in cpv_lib_map.items():
-                                if not self.vartree.dbapi.cpv_exists(cpv):
-                                        continue
-                                self.vartree.dbapi.removeFromContents(cpv, removed)
+                self._prune_plib_registry()
 
                 return os.EX_OK
 
         def _new_backup_path(self, p):
                 """
                 The works for any type path, such as a regular file, symlink,
                 or directory. The parent directory is assumed to exist.
                 The returned filename is of the form p + '.backup.' + x, where
                 x guarantees that the returned path does not exist yet.
                 """
@@ skipping 401 matching lines @@
         def merge(self, mergeroot, inforoot, myroot=None, myebuild=None, cleanup=0,
                 mydbapi=None, prev_mtimes=None):
                 """
                 @param myroot: ignored, self._eroot is used instead
                 """
                 myroot = None
                 retval = -1
                 self.lockdb()
                 self.vartree.dbapi._bump_mtime(self.mycpv)
                 try:
-                        plib_registry = self.vartree.dbapi._plib_registry
-                        if plib_registry is None:
-                                # preserve-libs is entirely disabled
-                                pass
-                        else:
-                                plib_registry.load()
-                                plib_registry.pruneNonExisting()
-
                         retval = self.treewalk(mergeroot, myroot, inforoot, myebuild,
                                 cleanup=cleanup, mydbapi=mydbapi, prev_mtimes=prev_mtimes)
 
                         # If PORTAGE_BUILDDIR doesn't exist, then it probably means
                         # fail-clean is enabled, and the success/die hooks have
                         # already been called by _emerge.EbuildPhase (via
                         # self._scheduler.dblinkEbuildPhase) prior to cleaning.
                         if os.path.isdir(self.settings['PORTAGE_BUILDDIR']):
 
                                 if retval == os.EX_OK:
@@ skipping 134 matching lines @@
         """
         myroot = None
         if settings is None:
                 raise TypeError("settings argument is required")
         mylink = dblink(cat, pkg, settings=settings, treetype="vartree",
                 vartree=vartree, scheduler=scheduler)
         vartree = mylink.vartree
         try:
                 mylink.lockdb()
                 if mylink.exists():
-                        plib_registry = vartree.dbapi._plib_registry
-                        if plib_registry is None:
-                                # preserve-libs is entirely disabled
-                                pass
-                        else:
-                                plib_registry.load()
-                                plib_registry.pruneNonExisting()
                         retval = mylink.unmerge(ldpath_mtimes=ldpath_mtimes)
                         if retval == os.EX_OK:
                                 mylink.delete()
                         return retval
                 return os.EX_OK
         finally:
                 if vartree.dbapi._linkmap is None:
                         # preserve-libs is entirely disabled
                         pass
                 else:
@@ skipping 96 matching lines @@
                                         encoding=object.__getattribute__(os, '_encoding'),
                                         errors='strict'), 'rb')
                                 try:
                                         tar.addfile(tarinfo, f)
                                 finally:
                                         f.close()
                 else:
                         tar.addfile(tarinfo)
                 if onProgress:
                         onProgress(maxval, curval)