self.components = ["spawner", "terminator", "vmm", "build_dispatcher",

                             "action_dispatcher", "backend", "actions", "worker",

      def setup_logging(self):

  import pwd

  import time

  import argparse

  import json

  import multiprocessing

  from copr.exceptions import CoprException

  from copr.exceptions import CoprRequestException

  from copr_backend.helpers import uses_devel_repo, get_persistent_status, get_auto_prune_status

  from copr_backend.frontend import FrontendClient

  from copr_backend.createrepo import createrepo

  DEF_DAYS = 14

  MAX_PROCESS = 50

      dir_names = [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]

      return dir_names, map(lambda x: os.path.join(path, x), dir_names)

  def runcmd(cmd):

      """

      Run given command in a subprocess

      """

      process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding="utf-8")

      (stdout, stderr) = process.communicate()

      if process.returncode != 0:

          raise Exception("Got non-zero return code ({0}) from prunerepo with stderr: {1}".format(process.returncode, stderr))

      return stdout

      try:

          createrepo(path=chroot_path, username=username,

                     projectname=projectname)

          clean_copr(chroot_path, prune_days, verbose=True)

  class Pruner(object):

      def __init__(self, opts, cmdline_opts=None):

          self.opts = opts

          self.prune_days = getattr(self.opts, "prune_days", DEF_DAYS)

          self.chroots = {}

          self.mtime_optimization = True

          self.max_processes = getattr(self.opts, "max_prune_processes", MAX_PROCESS)

          self.pool = multiprocessing.Pool(processes=self.max_processes)

          if cmdline_opts:

              self.mtime_optimization = not cmdline_opts.no_mtime_optimization

      def run(self):

          response = self.frontend_client.get("chroots-prunerepo-status")

          self.chroots = json.loads(response.content)

          results_dir = self.opts.destdir

          user_dir_names, user_dirs = list_subdir(results_dir)

          for username, subpath in zip(user_dir_names, user_dirs):

              for projectdir, project_path in zip(*list_subdir(subpath)):

                  self.prune_project(project_path, username, projectdir)

          chroots_to_prune = []

          for chroot, active in self.chroots.items():

              if not active:

                  chroots_to_prune.append(chroot)

          self.pool.close()

          self.pool.join()

      def prune_project(self, project_path, username, projectdir):

          projectname = projectdir.split(':', 1)[0]

          try:

              if uses_devel_repo(self.opts.frontend_base_url, username, projectname):

                  return

              if get_persistent_status(self.opts.frontend_base_url, username, projectname):

                  return

              if not get_auto_prune_status(self.opts.frontend_base_url, username, projectname):

                  return

          except (CoprException, CoprRequestException) as exception:

              return

          for sub_dir_name in os.listdir(project_path):

                  continue

              if sub_dir_name not in self.chroots:

                  continue

              if self.mtime_optimization:

                  # error, I/O problems...) we rather wait 10 more days till we

                  # really start to ignore the directory.

                  if touched_before > int(self.prune_days) + 10:

                      continue

  def clean_copr(path, days=DEF_DAYS, verbose=True):

      """

      Remove whole copr build dirs if they no longer contain a RPM file

      """

      for dir_name in os.listdir(path):

          dir_path = os.path.abspath(os.path.join(path, dir_name))

              continue

          if verbose:

          shutil.rmtree(dir_path)

          # also remove the associated log in the main dir

      Remove file given its absolute path

      """

      if verbose:

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

          os.remove(path)

      return any([f for f in files if f.endswith(".rpm") and not f.endswith(srpm_ex)])

  def main():

      args = parser.parse_args()

      config_file = os.environ.get("BACKEND_CONFIG", "/etc/copr/copr-be.conf")

      try:

          pruner.run()

      except Exception as e:

  if __name__ == "__main__":

      if pwd.getpwuid(os.getuid())[0] != "copr":

          print("This script should be executed under the `copr` user")

          sys.exit(1)

      else:

          main()