_here = os.path.dirname(__file__)

  config_files = {

      },

      },

  }

                  self[k] = v

      """Load stored configuration.

      This function loads default, system-wide, and if specified, additional

      # Load default files.

      try:

      except FileNotFoundError as e:

          raise RuntimeError(

              f"Default configuration file {config_files['default']['configuration']} not found."

          ) from e

      try:

      except FileNotFoundError as e:

          raise RuntimeError(

              f"Default email overrides file {config_files['default']['email_overrides']} not found."

      # Attempt to load system-wide files.

      try:

      except FileNotFoundError:

          system_config = {}

      try:

      except FileNotFoundError:

          system_email_overrides = {}

      email_overrides.update(system_email_overrides)

      email_overrides.update(addl_email_overrides)

          # Fill environments with default data.

          env_values = copy.deepcopy(config)

          # Values specified in the environments should take precedence.

          env_values.update(env)

  import requests

  repomd_xml_namespace = {

  }

  log = logging.getLogger(__name__)

  def download_db(name, repomd_url, archive):

      response = requests.get(repomd_url, verify=True)

          stream.write(response.content)

  def decompress_db(name, archive, location):

          import lzma

          with contextlib.closing(lzma.LZMAFile(archive)) as stream_xz:

              data = stream_xz.read()

              stream.write(data)

          import tarfile

          with tarfile.open(archive) as tar:

              tar.extractall(path=location)

          import gzip

                  out.write(inp.read())

          import bz2

              bzar = bz2.BZ2File(archive)

              out.write(bzar.read())

              bzar.close()

  def needs_update(local_file, remote_sha, sha_type):

      Return True if our local file needs to be updated.

      if not os.path.isfile(local_file):

          # If we have never downloaded this before, then obviously it has

          return True

      # Old epel5 doesn't even know which sha it is using...

      hashobj = getattr(hashlib, sha_type)()

          hashobj.update(f.read())

      local_sha = hashobj.hexdigest()

  def get_primary_xml(destfolder, url, name):

      the provided name.

      response = requests.get(repomd_url, verify=True)

      if not bool(response):

          return

      try:

          root = etree.fromstring(response.text)

      except ParseError:

          return

      data_nodes = list(root.findall('repo:data[@type="primary"]', repomd_xml_namespace))

      if not data_nodes:

          return

      elif len(data_nodes) > 1:

          log.debug("More than one primary.xml could be found in %s", url)

      primary_node = data_nodes[0]

          return

          return

      hash_digest = cksuminfo_node.text

      # First, determine if the file has changed by comparing hash

      db = "distgit-bugzilla-sync-primary.xml"

      # Have we downloaded this before?  Did it change?

      destfile = os.path.join(destfolder, db)

      if not needs_update(destfile, hash_digest, hash_type):

      else:

          # If it has changed, then download it and move it into place.

          archive = os.path.join(destfolder, filename)

      start = time.time()

      primary_xml = get_primary_xml(

      )

      root = None

              root = elem

              continue

              if name is not None and summary is not None:

                  summaries[name] = summary

              # remove package child from root element to keep memory consumption low

  #         Author(s): Ralph Bean <rbean@redhat.com

  #         Author(s): Patrick Uiterwijk <puiterwijk@redhat.com>

  #

  sync information from the Pagure into bugzilla

  This ... script takes information about package onwership and imports it

  into bugzilla.

  import argparse

  import collections

  import requests

  from requests.adapters import HTTPAdapter

  from urllib3.util import Retry

  from . import package_summaries

  from .config import config, email_overrides, load_configuration

  cache = dogpile.cache.make_region().configure(

  )

          status_forcelist=(500, 502, 504),

      )

      adapter = HTTPAdapter(max_retries=retry)

      return session

      want to know about it, but we don't want it to kill the whole program.  So

      catch its error, log it, but proceed.

      """

      def wrapper(*additional):

          try:

              full = initial + additional

          except Exception:

              traceback.print_exc()

              return None

      wrapper.__name__ = fn.__name__

      wrapper.__doc__ = fn.__doc__

      return wrapper

  class DataChangedError(Exception):

      pass

  def segment(iterable, chunk, fill=None):

      args = [iter(iterable)] * chunk

      return itertools.zip_longest(*args, fillvalue=fill)

  class BugzillaProxy:

          self.bz_xmlrpc_server = bz_server

          self.username = username

          self.password = password

          self.server = Bugzilla(

          self.product_cache = {}

          self.user_cache = {}

          # Connect to the fedora account system

          self.fas = AccountSystem(

          self.config = config

          if not pre_cache_users:

              return

              print("Pre-caching FAS users and their Bugzilla email addresses.")

          try:

              self.user_cache = self.fas.people_by_key(

          except fedora.client.ServerError:

              # Sometimes, building the user cache up front fails with a timeout.

              # It's ok, we build the cache as-needed later in the script.

      def build_product_cache(self, pagure_projects):

          """ Cache the bugzilla info about each package in each product.

          """

          def _query_component(query, num_attempts=5):

              for i in range(num_attempts):

                  try:

                      break

                  except Exception as e:

                      if i >= num_attempts - 1:

                          raise

                          print(f"    ERROR {e}")

                          print("    - Query failed, going to try again in 20 seconds")

                      # Wait 20 seconds and try again

                      time.sleep(20)

              return raw_data

              # Old API -- in python-bugzilla.  But with current server, this

              # gives ProxyError

              for collection, product in self.config["products"].items():

              # Way that's undocumented in the partner-bugzilla api but works

              # currently

              for collection, product in self.config["products"].items():

                  # restrict the list of info returned to only the packages of

                  # interest

                  pkglist = [

                      # Format that bugzilla will understand.  Strip None's that

                      # segment() pads out the final data segment() with

                      query = [

                          for p in pkg_segment

                          if p is not None

                      ]

                          print(

                              f"  - Querying product `{bz_product_name}`, "

                      raw_data = _query_component(query)

                          # Reformat data to be the same as what's returned from

                          # getcomponentsdetails

                          product_info = {

                          }

                  self.product_cache[collection] = product_info_by_pkg

      def invert_user_cache(self):

          that the bugzilla_email is the key and the username the value.

          """

          for username in self.user_cache:

              self.inverted_user_cache[bz_email] = username

      def _get_bugzilla_email(self, username):

          First looks in a cache for a username => bugzilla email.  If not found,

          reloads the cache from fas and tries again.

          try:

          except KeyError:

                  group = self.fas.group_by_name(username[1:])

                  bz_email = group.mailing_list

                  if bz_email is None:

                      return

              else:

                  person = self.fas.person_by_username(username)

                  if bz_email is None:

                      return

              bz_email = bz_email.lower()

              self.inverted_user_cache[bz_email] = username

          bz_email = email_overrides.get(bz_email, bz_email)

          return bz_email

      def update_open_bugs(self, new_poc, prev_poc, product, name, print_fas_names=False):

          :arg new_poc: email of the new point of contact.

          :arg prev_poc: Username of the previous point of contact

          :arg product: The product of the package to change in bugzilla

          :arg name: Name of the package to change the owner.

          :kwarg print_fas_names: Boolean specifying wether to print email or FAS names

              (if these could be found).

          bz_query = {}

          # Update only maintained releases

          def _query_bz(query, num_attempts=5):

              for i in range(num_attempts):

                  except Exception as e:

                      if i >= num_attempts - 1:

                          raise

                          print(f"    ERROR {e}")

                          print("    - Query failed, going to try again in 20 seconds")

                      # Wait 20 seconds and try again

                          if old_poc in self.inverted_user_cache:

                              old_poc = self.inverted_user_cache[old_poc]

                          else:

                          if new_poc in self.inverted_user_cache:

                              new_poc = self.inverted_user_cache[new_poc]

                          else:

                      print(

                      )

                  if not self.config["dryrun"]:

                      try:

                          bug.setassignee(

                              assigned_to=new_poc,

                          )

                      except xmlrpc.client.Fault as e:

                          # Output something useful in args

                          e.args = (new_poc, e.faultCode, e.faultString)

                          raise

                      except xmlrpc.client.ProtocolError as e:

                          raise

          # Turn the cclist into something usable by bugzilla

          initial_cc_emails = []

          initial_cc_emails_lower = []

                      f"({collection}/{package})"

                  )

                  if self.config["verbose"]:

          # Add owner to the cclist so comaintainers taking over a bug don't

          # have to do this manually

              e.args = (e.faultCode, e.faultString)

              raise

          except xmlrpc.client.ProtocolError as e:

              raise

          # Set the qacontact_email and name

          if qacontact:

              qacontact_email = self._get_bugzilla_email(qacontact)

          else:

              data = {}

              # Check for changes to the owner, qacontact, or description

              else:

                      if cc_member.lower() not in initial_cc_emails_lower:

                          break

              if data:

                  # Changes occurred.  Submit a request to change via xmlrpc

                  if self.config["verbose"]:

                          if data.get(key) is not None:

                              old_value = product[pkg_key][key]

                              if isinstance(new_value, list):

                                  new_value = sorted(new_value)

                                      new_value = owner

                                      new_value = qacontact

                                  else:

                                      new_value = sorted(initial_cc_fasnames)

                                  from_fas_names = []

                                  for email in product[pkg_key][key]:

                                      if email in self.inverted_user_cache:

                                      elif email == default_qa_contact_email:

                                          from_fas_names.append(default_qa_contact)

                                  if from_fas_names:

                                      if len(from_fas_names) < len(product[pkg_key][key]):

                                          from_fas_names.append(f"And {x} more")

                                      old_value = f"from `{from_fas_names}`"

                                  else:

                                      old_value = ""

                              else:

                  owner_changed = "initialowner" in data

                  # FIXME: initialowner has been made mandatory for some

                  # reason.  Asking dkl why.

                  def edit_component(data, num_attempts=5):

                      for i in range(num_attempts):

                              self.server.editcomponent(data)

                              break

                          except Exception as e:

                                      print(f"    ERROR {e}")

                                  raise

                              if i >= num_attempts - 1:

                                  raise

                                  print(f"    ERROR {e}")

                              # Wait 20 seconds and try again

                              time.sleep(20)

                          e.args = (data, e.faultCode, e.faultString)

                          raise

                      except xmlrpc.client.ProtocolError as e:

                          raise

                  if owner_changed:

                      self.update_open_bugs(

                          new_poc=owner_email,

                          name=package,

                          product=bz_product_name,

                          print_fas_names=print_fas_names,

                      print(f"[NOCHANGE] {package}/{bz_product_name}")

          else:

              if retired:

                      print(f"[NOADD] {bz_product_name}/{package} (is retired)")

                  return

              # Add component

              data = {

              }

              if initial_cc_emails:

              if self.config["verbose"]: