# This Dockerfile is used to build and run monitor-gating on Openshift

  FROM fedora:31

  RUN dnf -y install python3-requests bodhi-client fedpkg fedpkg-stage \

      python3-toml git python3-koji python3-fedora-messaging cracklib-dicts \

  COPY . /opt/code

      && chgrp -R 0 /opt/code \

      && chmod -R g=u /opt/code \

      && chgrp -R 0 /.ssh \

      && chmod -R g=u /.ssh \

      && chgrp -R 0 /.fedora \

  USER 1000

  WORKDIR /

    fi

  fi

  ln -s /opt/ssh/id_rsa /.ssh/id_rsa || true

  if [ -z ${PRODUCTION+x} ]; then

  # Staging info

  ssh-keyscan pkgs.fedoraproject.org >> /.ssh/known_hosts

  fi

  python3 /opt/code/runner.py /opt/config/runner.cfg

  def get_cli_args(args):

      parser = argparse.ArgumentParser(

      )

      parser.add_argument(

      )

      return parser.parse_args(args)

      try:

          output = subprocess.check_output(command, stderr=subprocess.PIPE)

      except subprocess.CalledProcessError as e:

          _log.error("stdout:\n-------\n{}".format(e.stdout))

          _log.error("stderr:\n-------\n{}".format(e.stderr))

          pass

      return output

      conf = toml.load(args.conf)

      if conf.get("kb_principal") and conf.get("kb_keytab_file"):

          cmd = ["kinit", conf["kb_principal"], "-kt", conf["kb_keytab_file"]]

          run_command(cmd)

      # list side-tags:

      output = run_command(cmd)

      if not output:

      # Remove all the side-tags but the last one (which is the latest one), which

      # we keep in case there is a run ongoing

      for line in output[:-1]:

          print("Removing side-tag: %s" % side_tag)

          output = run_command(cmd)

  if __name__ == "__main__":

  import toml

  _log = logging.getLogger(__name__)

      return parser.parse_args(args)

      """ Main method used by this script. """

      start = datetime.datetime.utcnow()

      args = get_arguments(args)

      conf = toml.load(args.conf)

      with tempfile.TemporaryDirectory(prefix="ci-test-") as folder:

          print(f"Working in {folder}\n")

          # Bump the release on both packages:

          nevrs, side_tag_name = utils.clone_and_bump(

          )

          nevrs, _ = utils.clone_and_bump(

          )

          # Chain-build the packages

          utils.chain_build_packages(

              conf["fedpkg"],

              )

      utils.finalize(start)

  if __name__ == "__main__":

  import sched

  import sys

  import time

  import uuid

  import fedora_messaging.api

  import fedora_messaging.exceptions

  import toml

  s = sched.scheduler(time.time, time.sleep)

  conf = toml.load

          print(f"Fedora Messaging broker rejected message {msg.id}: {err}")

      except fedora_messaging.exceptions.ConnectionException as err:

          print(f"Error sending message {msg.id}: {err}")

      except Exception as err:

          print(f"Error sending fedora-messaging message: {err}")

  def schedule(conf):

          run_command(cmd)

      delay = conf["delay"]

      print("Tests started:", datetime.datetime.utcnow(), flush=True)

      runid = f"{datetime.datetime.utcnow().year}-{uuid.uuid4()}"

      try:

          single_args = conf["workflow_single_gating_args"].split()

          notify(

              topic=f"single-build.start",

          )

          if "[FAILED]" not in output_text:

              result = "succeeded"

          else:

              result = "failed"

          notify(

              topic=f"single-build.end.{result}",

              message={

                  "output_text": output_text,

                  "result": result,

                  "runid": runid,

              },

          )

          # Multi Build Gating

          multi_args = conf["workflow_multi_gating_args"].split()

          notify(

              topic=f"multi-build.start",

          )

          if "[FAILED]" not in output_text:

              result = "succeeded"

          else:

              result = "failed"

          notify(

              topic=f"multi-build.end.{result}",

              message={

                  "output_text": output_text,

                  "result": result,

                  "runid": runid,

              },

          )

      except Exception as err:

          print(f"Tests failed with: {err}", flush=True)

          print(sys.exc_info()[0])

      now = datetime.datetime.utcnow().strftime("%H:%M:%S")

          print(

              f"{now} Next run in: {delay_when_failing} seconds because of "

              flush=True,

          )

          s.enter(delay_when_failing, 1, schedule, argument=(conf,))

          s.enter(delay, 1, schedule, argument=(conf,))

      try:

      except KeyboardInterrupt:

          from code import InteractiveConsole

              "ENTERING THE DEBUG CONSOLE:\n s is the scheduler\n ^d to quit",

              "LEAVING THE DEBUG CONSOLE",

          )

  import toml

  _log = logging.getLogger(__name__)

              )

              gitfolder = os.path.join(folder, name)

              utils.switch_branch(conf["fedpkg"], branch, folder=gitfolder)

              utils.commit_changes("Bump release", folder=gitfolder)

              nevr = utils.get_nevr(conf["fedpkg"], folder=gitfolder)

              print(f"   Upcoming build : {nevr}")

              topic=f"org.centos.{conf['_ci_env']}.ci.koji-build.test.running",

              nevr=nevr,

          )

          # Check at the CI pipeline has completed

          utils.lookup_results_datagrepper(

              base_url=conf["datagrepper"],

              topic=f"org.centos.{conf['_ci_env']}.ci.koji-build.test.error",

              nevr=nevr,

              duration=30,

          )

          # Check the tag of the build

              name="resultsdb",

              topic=f"org.fedoraproject.{conf['_env']}.resultsdb.result.new",

              nevr=nevr,

          )

          # Check that greenwave reacted to resultsdb's new results

              name="greenwave",

              topic=f"org.fedoraproject.{conf['_env']}.greenwave.decision.update",

              nevr=nevr,

          )

          # Check the tag of the build -- build is blocked but should be signed

              )

      utils.finalize(start)

  if __name__ == "__main__":

  import os

  import subprocess

  import time

  import requests

  _log = logging.getLogger(__name__)

      """Lists blocking issues we track in the fedora-infrastructure project.

      """

      if not tags:

          print(f"No tags to filter blocking issues by, returning empty.")

          return []

      issues = []

      try:

      except Exception as e:

      return issues

      def __init__(self):

          """ Instanciate the object. """

          self.logs = []

      def print_user(self, content, success=None):

          """ Prints the specified content to the user.

                  [command, "--user", username, "clone", f"{namespace}/{name}"],

                  cwd=folder,

              )

          except MonitoringException:

              self.print_user(info_log, success=False)

      def add_remote(self, name, url, folder):

          """ Add the specified remote to the git repo in the folder with the

              run_command(["git", "remote", "add", name, url], cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def switch_branch(self, command, name, folder):

              run_command([command, "switch-branch", f"{name}"], cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

          """ Bump the release of the spec file the specified git repo.

          """

          info_log = f"Bumping release of: {name}.spec"

          self.print_user(info_log)

          try:

          except MonitoringException:

              self.print_user(info_log, success=False)

      def commit_changes(self, commit_log, folder):

              run_command(["git", "commit", "-asm", commit_log], cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def push_changes(self, folder, target, branch, force=False):

              run_command(cmd, cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def pull_changes(self, folder, target, branch):

              run_command(cmd, cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def open_pullrequest(self, base_url, username, namespace, name, branch, token):

          info_log = f"Creating PR from forks/{username}/{namespace}/{name}"

          self.print_user(info_log)

          url = "/".join(

          )

          data = {

              "branch_to": branch,

              success = False

              pr_id = None

              pr_uid = None

          else:

              output = req.json()

              pr_id = str(output["id"])

              self.print_user(info_log, success=True)

              return nevr.strip().decode("utf-8")

          except MonitoringException:

              self.print_user(info_log, success=False)

      def build_package(self, command, folder, target=None):

              run_command(command, cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def chain_build_packages(self, command, packages, folder, target=None):

              run_command(command, cwd=folder)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def get_build_tags(self, koji_url, nevr, expected_ends):

              "koji",

          ]

          if koji_url:

          command.extend(["call", "listTags", nevr])

          success = False

                  break

          info_log = f"Retrieving koji tags: {tags}"

          self.print_user(info_log, success=success)

      def create_update(

              run_command(command)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def get_update_id(self, nevr, url):

              if (datetime.datetime.utcnow() - start).seconds > (15 * 60):

                  success = False

                  info_log = f"Update for {nevr} not created within 15 minutes"

                  break

          end = datetime.datetime.utcnow()

          info_log += f" - ran for: {(end - start_lookup).seconds}s"

          self.print_user(info_log, success=success)

      def lookup_ci_resultsdb(self, nevr, name, url):

          """ Check the CI results in the specified resultsdb for results about

          end = datetime.datetime.utcnow()

          info_log += f" - ran for: {(end - start).seconds}s"

          self.print_user(info_log, success=success)

      def waive_update(self, command, updateid, prod=True, username=None, password=None):

          """ Waive all the tests results for the specified update using bodhi's

              run_command(command)

              self.print_user(info_log, success=True)

          except MonitoringException:

              self.print_user(info_log, success=False)

      def get_pr_flag(

                      break

          self.print_user(info_log, success=success)

      def merge_pr(self, base_url, username, namespace, name, pr_id, token):

          """ Merge the specified PR

              success = True

          self.print_user(info_log, success=success)

      def finalize(self, start):

          """ End data returned. """

              self.print_user(info_log, success=True)

          except (MonitoringException, Exception) as err:

              print(err)

              self.print_user(info_log, success=False)

          return side_tag_name

      def clone_and_bump(

      ):

          """Clone the repo, bump the release, commit and push."""

          namespace = conf["namespace"]

          if new_side_tag:

              side_tag_name = self.create_side_tag(conf["fedpkg"], folder=gitfolder)

              target = side_tag_name

          self.commit_changes("Bump release", folder=gitfolder)

          nevr = self.get_nevr(conf["fedpkg"], folder=gitfolder)

          nevrs[name] = nevr

          print(f"   Upcoming build : {nevr}")

          return (nevrs, target)

  def run_command(command, cwd=None):

      """ Run the specified command in a specific working directory if one