- HEALTH_CHECK_URL = "https://repochecker.decathorpe.com/data/"

- #    health_check_data

-     HEALTH_CHECK_URL = 'https://repochecker.decathorpe.com/data/'

-     #    health_check_data

- from oraculum.utils import dashboard_helpers, pagure, koschei, health_check, bodhi, bugzilla, calendars, versions, retrace_server

-     CACHE.register('health_check_data', health_check.get_health_check_data)

- from oraculum.utils import bodhi, bugzilla, cache_utils, celery_utils, calendars, dashboard_helpers, health_check, koschei, orphans, pagure, versions, retrace_server, watchdog_utils

-             "fails_to_install": CACHE.get_refreshed_time("health_check_data"),

-         'fails_to_install': [],

- 

- @app.route('/api/v1/packager_dashboard/<user>', methods=['GET'])

- @app.route('/api/v1/packager_dashboard/package/<package>', methods=['GET'])

- def v1_route_dashboard_data(user=None, package=None):

-     if user:

-         if user == 'orphan':

-             return jsonify(CACHE.get('packager-dashboard_orphan_page'))

- 

-         # Cleanup the username to follow FAS naming restrictions

-         user = dashboard_helpers.clean_fas_username(user)

- 

-         user_packages = pagure.get_packages(user, CACHE.get('packages_owners_json'), CACHE.get('pagure_groups'))

- 

-         if len(user_packages["combined"]) > 0:

-             dashboard_helpers.update_users_access_time([user])

-             dashboard_helpers.update_packages_access_time(user_packages["combined"])

-         else:

-             # Not a packager

-             empty = {'status': 404, 'data': None, 'last_synced': None}

-             return jsonify({'static_info': empty, 'prs': empty, 'bzs': empty, 'abrt_reports': empty})

- 

-     elif package and package in CACHE.get("packages_owners_json")["rpms"].keys():

-         user_packages = {"primary": [package], "group": [], "combined": [package]}

-         dashboard_helpers.update_packages_access_time([package])

- 

-     else:

-         # Not a packager nor a package

-         empty = {'status': 404, 'data': None, 'last_synced': None}

-         return jsonify({'static_info': empty, 'prs': empty, 'bzs': empty, 'abrt_reports': empty})

- 

-     generic_data = dashboard_data_generic(user_packages["combined"])

- 

-     if generic_data["status"] == 500:

-         # Oh oh, something blew up, evacuate 🪂🪂🪂

-         empty = {'status': 500, 'data': None, 'last_synced': None}

-         return jsonify({'static_info': empty, 'prs': empty, 'bzs': empty, 'abrt_reports': empty})

- 

-     v1_compat_generic_data = {

-         'calendars': {},

-         'orphans': {},

-         'fails_to_install': {},

-         'updates': {},

-         'overrides': {},

-         'koschei': {},

-         'package_versions': {}

-     }

- 

-     # Transformation from v2 db cache to v1 data format

-     for package in generic_data["data"]:

-         for key in v1_compat_generic_data:

-             v1_compat_generic_data[key][package] = generic_data["data"][package][key]

- 

-     v1_compat_generic_data["packages"] = user_packages["combined"]

-     v1_compat_generic_data["primary_packages"] = user_packages["primary"]

-     v1_compat_generic_data["group_packages"] = user_packages["group"]

- 

-     static_info = {'status': generic_data["status"], 'data': v1_compat_generic_data, 'last_synced': generic_data["last_synced"]}

- 

-     prs = dashboard_data_prs(user_packages["combined"])

-     bzs = dashboard_data_bzs(user_packages["combined"], authenticated=is_packager())

-     abrt = dashboard_data_abrt(user_packages["combined"])

- 

-     # Clean stuff from api/v2

-     for drop in ["cache_ages", "static_data_timestamps"]:

-         del prs[drop]

-         del bzs[drop]

-         del abrt[drop]

- 

-     return jsonify({'static_info': static_info,

-         'prs': prs,

-         'bzs': bzs,

-         'abrt_reports': abrt,

-         "error": "This is a deprecated endpoint that will be turned off. Please, use /api/v2/packager_dashboard !"

-     })

- 

- 

-         'fails_to_install': health_check.get_health_check_user_data([package])[package],

-                        'health_check_data', 'blocker_trackers', 'fedora_releases', 'fe_trackers',

-         'fails_to_install': oraculum.CACHE.get_refreshed_time("health_check_data"),

-         'fails_to_install': oraculum.utils.health_check.get_health_check_user_data(packages),

- #

- # health_check.py - Health Check parsers and utilities for packager dashboard

- #

- # Copyright 2020, Red Hat, Inc

- #

- # This program is free software; you can redistribute it and/or modify

- # it under the terms of the GNU General Public License as published by

- # the Free Software Foundation; either version 2 of the License, or

- # (at your option) any later version.

- #

- # This program is distributed in the hope that it will be useful,

- # but WITHOUT ANY WARRANTY; without even the implied warranty of

- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- # GNU General Public License for more details.

- #

- # You should have received a copy of the GNU General Public License along

- # with this program; if not, write to the Free Software Foundation, Inc.,

- # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

- #

- # Authors:

- #   Frantisek Zatloukal <fzatlouk@redhat.com>

- #   Josef Skladanka <jskladan@redhat.com>

- 

- from collections import defaultdict

- 

- from oraculum import app, CACHE

- 

- from oraculum.utils.dashboard_helpers import get_json, release_from_number

- 

- 

- def process_health_check_json(json_data):

-     """

-     Cleans up data for further health check processing into following format:

-     {"package": {"arch": ["reason_a", "reason_b"], "arch_b": ["reason_a, reason_c"]}, "package_b"...}

-     """

-     data = defaultdict(dict)

-     for single_closure in json_data:

-         if single_closure["arch"] == "src":

-             arch = "src-" + single_closure["repo_arch"]

-         else:

-             arch = single_closure["repo_arch"]

-         data[single_closure["package"]][arch] = {

-             "reason": single_closure["broken"],

-             "since": single_closure["since"]

-         }

-     return data

- 

- 

- def get_health_check_data():

-     """

-     Retrieves json files containing data from fedora-health-check and combines them into dictionary with per-release keys

-     Returns dict {

-         "FXX":         {"package": {"arch": ["reason_a", "reason_b"], "arch_b": ["reason_a, reason_c"]}, "package_b"...}

-         "FXX-testing": {"package": {"arch": ["reason_a", "reason_b"], "arch_b": ["reason_a, reason_c"]}, "package_b"...}

-         #Rawhide releases don't have -testing counterpart

-         "rawhide":     {"package": {"arch": ["reason_a", "reason_b"], "arch_b": ["reason_a, reason_c"]}, "package_b"...}

-     }

-     Reason format is described below in get_health_check_user_data

-     """

-     data = {}

-     releases = CACHE.get('fedora_releases')["values"]

-     for release in releases[:-1]: # Process every release but rawhide

-         release = str(release)

-         # Remote resource might not have data for some Fedora Release, typically branched right after branching point

-         try:

-             data[release] = process_health_check_json(get_json(app.config["HEALTH_CHECK_URL"] + release))

-             data[release + "-testing"] = process_health_check_json(get_json(app.config["HEALTH_CHECK_URL"] + release + "-testing"))

-         except TypeError:

-             pass

-     try:

-         data["rawhide"] = process_health_check_json(get_json(app.config["HEALTH_CHECK_URL"] + "rawhide"))

-     except TypeError:

-         pass

-     return data

- 

- 

- def get_repo_for_health_check(release):

-     """

-     Used to give frontend a hint if a failure comes from stable, testing or rawhide repos

-     """

-     if "-testing" in release:

-         return "testing"

-     if "rawhide" in release:

-         return "rawhide"

-     return "stable"

- 

- 

- def get_health_check_user_data(packages):

-     """

-     Parses data from get_health_check_data and returns dict for package list:

-     {

-         "package_a":  {"fails_to_install": True/False, "releases": [{"release": XX, "problems": problems}]

-         ...

-     }

-     "problems": {

-         "arch_a": {"reason": ["package_a",...], "since": "2020-07-17T07:47:25.219142397Z"}

-         "arch_b": {"reason": ["package_a",...], "since": "2040-07-17T07:47:25.219142397Z"}

-         ...

-     }

-     """

-     fti_data = CACHE.get('health_check_data')

-     releases = CACHE.get('fedora_releases')

-     data = {}

- 

-     for package in packages:

-         data[package] = []

-         for release in fti_data:

-             if package in fti_data[release]:

-                 data[package].append({"release": release_from_number(release.replace("-testing", ""), releases), # We need to cut -testing,

-                                       "repo": get_repo_for_health_check(release),

-                                       "problems": fti_data[release][package]})

-     return data

- from unittest import mock

- 

- from bodhi.client.bindings import BodhiClient

- 

- from oraculum.utils import health_check

- from oraculum import app, CACHE

- 

- 

- class TestHealthCheck(object):

- 

-     stub_fedora_releases = {

-         "pre_eol": None,

-         "oldstable": 96,

-         "stable": 97,

-         "branched": 98,

-         "rawhide": 99,

-         "values": [96, 97, 98, 99]

-     }

- 

-     mocked_basic_health_check_data = {

-         "98": {

-             "package_a": {

-                 "noarch": {

-                     "reason": ["chromium"],

-                     "since": "2020-07-17T07:47:25.219142397Z"

-                 }

-             }

-         }

-     }

- 

-     def health_advanced_releases_stub(self, what):

-         if "fedora_releases" in what:

-             return self.stub_fedora_releases

- 

-         if "health_check_data" in what:

-             return self.mocked_basic_health_check_data

- 

- 

-     def test_get_data_structure(self, monkeypatch):

- 

-         expected_result = {

-             "96": {},

-             "96-testing": {},

-             "97": {},

-             "97-testing": {},

-             "98": {},

-             "98-testing": {},

-             "rawhide": {},

-         }

- 

- 

-         monkeypatch.setattr(CACHE, 'get', mock.MagicMock(return_value=self.stub_fedora_releases))

-         monkeypatch.setattr(health_check, 'get_json', mock.MagicMock(return_value=None))

-         monkeypatch.setattr(health_check, 'process_health_check_json', mock.MagicMock(return_value={}))

- 

-         assert health_check.get_health_check_data() == expected_result

- 

-     def test_get_health_check_user_data(self, monkeypatch):

- 

-         expected_result_basic = {

-             'package_a': [

-                 {

-                     'problems':{

-                         'noarch': {

-                             'reason': ['chromium'],

-                             'since': '2020-07-17T07:47:25.219142397Z'

-                             }

-                         },

-                     'release': 'Fedora 98',

-                     'repo': 'stable'

-                 }

-             ]

-         }

- 

- 

-         monkeypatch.setattr(CACHE, 'get', self.health_advanced_releases_stub)

-         assert health_check.get_health_check_user_data(["package_a"]) == expected_result_basic

-         assert health_check.get_health_check_user_data(["package_b"]) == {'package_b': []}