1 files changed, 82 insertions, 4 deletions

diff --git a/src/sbin/bcfg2-yum-helper b/src/sbin/bcfg2-yum-helper
index 4ef531d39..161aa3e50 100755
--- a/src/sbin/bcfg2-yum-helper
+++ b/src/sbin/bcfg2-yum-helper
@@ -10,6 +10,8 @@ import sys
 import yum
 import logging
 import Bcfg2.Logger
+from Bcfg2.Compat import wraps
+from lockfile import FileLock, LockTimeout
 from optparse import OptionParser
 try:
     import json
@@ -42,8 +44,8 @@ def pkgtup_to_string(package):
     return ''.join(str(e) for e in rv)
 
 
-class DepSolver(object):
-    """ Yum dependency solver """
+class YumHelper(object):
+    """ Yum helper base object """
 
     def __init__(self, cfgfile, verbose=1):
         self.cfgfile = cfgfile
@@ -57,6 +59,16 @@ class DepSolver(object):
             self.yumbase._getConfig(cfgfile, debuglevel=verbose)
         # pylint: enable=E1121,W0212
         self.logger = logging.getLogger(self.__class__.__name__)
+
+
+class DepSolver(YumHelper):
+    """ Yum dependency solver.  This is used for operations that only
+    read from the yum cache, and thus operates in cacheonly mode. """
+
+    def __init__(self, cfgfile, verbose=1):
+        YumHelper.__init__(self, cfgfile, verbose=verbose)
+        # internally, yum uses an integer, not a boolean, for conf.cache
+        self.yumbase.conf.cache = 1
         self._groups = None
 
     def get_groups(self):
@@ -181,6 +193,45 @@ class DepSolver(object):
             packages.add(txmbr.pkgtup)
         return list(packages), list(unknown)
 
+
+def acquire_lock(func):
+    """ decorator for CacheManager methods that gets and release a
+    lock while the method runs """
+    @wraps(func)
+    def inner(self, *args, **kwargs):
+        """ Get and release a lock while running the function this
+        wraps. """
+        self.logger.debug("Acquiring lock at %s" % self.lockfile)
+        while not self.lock.i_am_locking():
+            try:
+                self.lock.acquire(timeout=60)  # wait up to 60 seconds
+            except LockTimeout:
+                self.lock.break_lock()
+                self.lock.acquire()
+        try:
+            func(self, *args, **kwargs)
+        finally:
+            self.lock.release()
+            self.logger.debug("Released lock at %s" % self.lockfile)
+
+    return inner
+
+
+class CacheManager(YumHelper):
+    """ Yum cache manager.  Unlike :class:`DepSolver`, this can write
+    to the yum cache, and so is used for operations that muck with the
+    cache.  (Technically, :func:`CacheManager.clean_cache` could be in
+    either DepSolver or CacheManager, but for consistency I've put it
+    here.) """
+
+    def __init__(self, cfgfile, verbose=1):
+        YumHelper.__init__(self, cfgfile, verbose=verbose)
+        self.lockfile = \
+            os.path.join(os.path.dirname(self.yumbase.conf.config_file_path),
+                         "lock")
+        self.lock = FileLock(self.lockfile)
+
+    @acquire_lock
     def clean_cache(self):
         """ clean the yum cache """
         for mdtype in ["Headers", "Packages", "Sqlite", "Metadata",
@@ -193,6 +244,21 @@ class DepSolver(object):
             if not msg.startswith("0 "):
                 self.logger.info(msg)
 
+    @acquire_lock
+    def populate_cache(self):
+        """ populate the yum cache """
+        for repo in self.yumbase.repos.findRepos('*'):
+            repo.metadata_expire = 0
+            repo.mdpolicy = "group:all"
+        self.yumbase.doRepoSetup()
+        self.yumbase.repos.doSetup()
+        for repo in self.yumbase.repos.listEnabled():
+            # this populates the cache as a side effect
+            repo.repoXML  # pylint: disable=W0104
+        self.yumbase.repos.populateSack(mdtype='metadata', cacheonly=1)
+        self.yumbase.repos.populateSack(mdtype='filelists', cacheonly=1)
+        self.yumbase.repos.populateSack(mdtype='otherdata', cacheonly=1)
+
 
 def main():
     parser = OptionParser()
@@ -223,17 +289,28 @@ def main():
 
     # pylint: disable=W0702
     rv = 0
-    depsolver = DepSolver(options.config, options.verbose)
     if cmd == "clean":
+        cachemgr = CacheManager(options.config, options.verbose)
         try:
-            depsolver.clean_cache()
+            cachemgr.clean_cache()
             print(json.dumps(True))
         except:
             logger.error("Unexpected error cleaning cache: %s" %
                          sys.exc_info()[1], exc_info=1)
             print(json.dumps(False))
             rv = 2
+    elif cmd == "makecache":
+        cachemgr = CacheManager(options.config, options.verbose)
+        try:
+            # this code copied from yumcommands.py
+            cachemgr.populate_cache()
+            print json.dumps(True)
+        except yum.Errors.YumBaseError:
+            logger.error("Unexpected error creating cache: %s" %
+                         sys.exc_info()[1], exc_info=1)
+            print json.dumps(False)
     elif cmd == "complete":
+        depsolver = DepSolver(options.config, options.verbose)
         try:
             data = json.loads(sys.stdin.read())
         except:
@@ -252,6 +329,7 @@ def main():
             print(json.dumps(dict(packages=[], unknown=data['packages'])))
             rv = 2
     elif cmd == "get_groups":
+        depsolver = DepSolver(options.config, options.verbose)
         try:
             data = json.loads(sys.stdin.read())
             rv = dict()