qontract-reconcile 0.10.2.dev285__tar.gz → 0.10.2.dev287__tar.gz

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qontract-reconcile
-Version: 0.10.2.dev285
+Version: 0.10.2.dev287
 Summary: Collection of tools to reconcile services with their desired state as defined in the app-interface DB.
 Project-URL: homepage, https://github.com/app-sre/qontract-reconcile
 Project-URL: repository, https://github.com/app-sre/qontract-reconcile

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/pyproject.toml

@@ -262,12 +262,7 @@ disallow_incomplete_defs = true
 [[tool.mypy.overrides]]
 # Untyped modules
 module = [
-    "reconcile.quay_mirror_org",
-    "reconcile.quay_mirror",
-    "reconcile.quay_permissions",
-    "reconcile.quay_repos",
     "reconcile.queries",
-    "reconcile.query_validator",
     "reconcile.requests_sender",
     "reconcile.sendgrid_teammates",
     "reconcile.status_page_components",
@@ -346,9 +341,6 @@ module = [
     "reconcile.test.test_openshift_saas_deploy",
     "reconcile.test.test_openshift_upgrade_watcher",
     "reconcile.test.test_prometheus_rules_tester",
-    "reconcile.test.test_quay_mirror_org",
-    "reconcile.test.test_quay_mirror",
-    "reconcile.test.test_quay_repos",
     "reconcile.test.test_repo_owners",
     "reconcile.test.test_requests_sender",
     "reconcile.test.test_saasherder_allowed_secret_paths",

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/reconcile/aws_version_sync/integration.py

@@ -356,6 +356,15 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
                         # AWS ElastiCache Redis 6 could use a version like 6.x. Then, we don't need to manage it
                         continue
 
+                    if (
+                        resource.provider == SupportedResourceProvider.RDS
+                        and EXTENDED_SUPPORT_VERSION_INDICATOR
+                        in values["engine_version"]
+                    ):
+                        # AWS RDS PostgreSQL 11 and 12 extended support versions are not supported by this integration
+                        # See https://aws.amazon.com/about-aws/whats-new/2025/04/amazon-rds-postgresql-extended-support-11-22-rds-20250220-12-22-rds-20250220/
+                        continue
+
                     external_resources.append(
                         ExternalResource(
                             namespace_file=ns.path,

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/reconcile/quay_mirror.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import os
 import sys
@@ -7,8 +9,8 @@ from collections import (
     defaultdict,
     namedtuple,
 )
-from collections.abc import Iterable
 from typing import (
+    TYPE_CHECKING,
     Any,
     Self,
 )
@@ -33,6 +35,9 @@ from reconcile.utils.instrumented_wrappers import InstrumentedSkopeo as Skopeo
 from reconcile.utils.quay_mirror import record_timestamp, sync_tag
 from reconcile.utils.secret_reader import SecretReader
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 _LOG = logging.getLogger(__name__)
 
 QONTRACT_INTEGRATION = "quay-mirror"
@@ -203,7 +208,7 @@ class QuayMirror:
                     })
         return summary
 
-    def process_sync_tasks(self):
+    def process_sync_tasks(self) -> defaultdict[OrgKey, list[dict[str, str | None]]]:
         if self.is_compare_tags:
             _LOG.warning("Making a compare-tags run. This is a slow operation.")
         summary = self.process_repos_query(
@@ -308,12 +313,12 @@ class QuayMirror:
                         pass
                     finally:
                         self.response_cache_hits.inc(
-                            upstream.response_cache_hits
-                            + downstream.response_cache_hits
+                            (upstream.response_cache_hits or 0)
+                            + (downstream.response_cache_hits or 0)
                         )
                         self.response_cache_misses.inc(
-                            upstream.response_cache_misses
-                            + downstream.response_cache_misses
+                            (upstream.response_cache_misses or 0)
+                            + (downstream.response_cache_misses or 0)
                         )
 
                     _LOG.debug(
@@ -346,7 +351,7 @@ class QuayMirror:
         return self._has_enough_time_passed_since_last_compare_tags
 
     @staticmethod
-    def check_compare_tags_elapsed_time(path, interval) -> bool:
+    def check_compare_tags_elapsed_time(path: str, interval: float) -> bool:
         try:
             with open(path, encoding="locale") as file_obj:
                 last_compare_tags = float(file_obj.read())
@@ -356,12 +361,15 @@ class QuayMirror:
         next_compare_tags = last_compare_tags + interval
         return time.time() >= next_compare_tags
 
-    def _get_push_creds(self):
+    def _get_push_creds(self) -> dict[OrgKey, str]:
         result = self.gqlapi.query(self.QUAY_ORG_CATALOG_QUERY)
 
-        creds = {}
-        for org_data in result["quay_orgs"]:
-            push_secret = org_data["pushCredentials"]
+        creds: dict[OrgKey, str] = {}
+        if not result:
+            return creds
+
+        for org_data in result.get("quay_orgs") or []:
+            push_secret = org_data.get("pushCredentials")
             if push_secret is None:
                 continue
 
@@ -375,13 +383,13 @@ class QuayMirror:
 
 
 def run(
-    dry_run,
+    dry_run: bool,
     control_file_dir: str | None,
     compare_tags: bool | None,
     compare_tags_interval: int,
     repository_urls: Iterable[str] | None,
     exclude_repository_urls: Iterable[str] | None,
-):
+) -> None:
     with QuayMirror(
         dry_run,
         control_file_dir,
@@ -393,7 +401,7 @@ def run(
         quay_mirror.run()
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     with QuayMirror(dry_run=True) as quay_mirror:
         return {
             "repos": quay_mirror.process_repos_query(session=quay_mirror.session),

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/reconcile/quay_mirror_org.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import logging
 import os
 import tempfile
 from collections import defaultdict
-from collections.abc import Iterable
-from typing import Any, Self
+from typing import TYPE_CHECKING, Any, Self
 
 import requests
 from sretoolbox.container import (
@@ -20,6 +21,11 @@ from reconcile.quay_base import get_quay_api_store
 from reconcile.quay_mirror import QuayMirror
 from reconcile.utils.quay_mirror import record_timestamp, sync_tag
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from reconcile.quay_base import OrgKey
+
 _LOG = logging.getLogger(__name__)
 
 QONTRACT_INTEGRATION = "quay-mirror-org"
@@ -66,7 +72,7 @@ class QuayMirrorOrg:
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         self.session.close()
 
-    def run(self):
+    def run(self) -> None:
         sync_tasks = self.process_sync_tasks()
         for org, data in sync_tasks.items():
             for item in data:
@@ -83,19 +89,11 @@ class QuayMirrorOrg:
         if self.is_compare_tags and not self.dry_run:
             record_timestamp(self.control_file_path)
 
-    def process_org_mirrors(self, summary):
-        """adds new keys to the summary dict with information about mirrored
-        orgs
-
-        It collects the list of repositories in the upstream org from an API
+    def process_org_mirrors(self) -> dict[OrgKey, list[dict[str, Any]]]:
+        """It collects the list of repositories in the upstream org from an API
         call and not from App-Interface.
-
-        :param summary: summary
-        :type summary: dict
-        :return: summary
-        :rtype: dict
         """
-
+        summary = defaultdict(list)
         for org_key, org_info in self.quay_api_store.items():
             if not org_info.get("mirror"):
                 continue
@@ -128,7 +126,7 @@ class QuayMirrorOrg:
                         "username": username,
                         "token": token,
                     },
-                    "mirror_filters": org_info.get("mirror_filters").get(
+                    "mirror_filters": org_info.get("mirror_filters", {}).get(
                         repo["name"], {}
                     ),
                 }
@@ -136,9 +134,8 @@ class QuayMirrorOrg:
 
         return summary
 
-    def process_sync_tasks(self):
-        summary = defaultdict(list)
-        self.process_org_mirrors(summary)
+    def process_sync_tasks(self) -> dict[OrgKey, list[dict[str, Any]]]:
+        summary = self.process_org_mirrors()
 
         sync_tasks = defaultdict(list)
         for org_key, data in summary.items():
@@ -274,7 +271,7 @@ class QuayMirrorOrg:
 
         return self._has_enough_time_passed_since_last_compare_tags
 
-    def get_push_creds(self, org_key):
+    def get_push_creds(self, org_key: OrgKey) -> str:
         """returns username and password for the given org
 
         :param org_key: org_key
@@ -296,7 +293,7 @@ def run(
     compare_tags_interval: int,
     orgs: Iterable[str] | None,
     repositories: Iterable[str] | None,
-):
+) -> None:
     with QuayMirrorOrg(
         dry_run,
         control_file_dir,

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/reconcile/quay_permissions.py

@@ -1,7 +1,8 @@
 import logging
 import sys
+from typing import Any
 
-from reconcile.quay_base import get_quay_api_store
+from reconcile.quay_base import OrgKey, get_quay_api_store
 from reconcile.status import ExitCodes
 from reconcile.utils import gql
 
@@ -49,9 +50,13 @@ QUAY_REPOS_QUERY = """
 QONTRACT_INTEGRATION = "quay-permissions"
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     gqlapi = gql.get_api()
-    apps = gqlapi.query(QUAY_REPOS_QUERY)["apps"]
+    result = gqlapi.query(QUAY_REPOS_QUERY)
+    if not result:
+        return
+
+    apps: list[dict[str, Any]] = result.get("apps") or []
     quay_api_store = get_quay_api_store()
     error = False
     for app in apps:
@@ -61,7 +66,7 @@ def run(dry_run):
         for quay_repo_config in quay_repo_configs:
             instance_name = quay_repo_config["org"]["instance"]["name"]
             org_name = quay_repo_config["org"]["name"]
-            org_key = (instance_name, org_name)
+            org_key = OrgKey(instance_name, org_name)
 
             if not quay_repo_config["org"]["managedRepos"]:
                 logging.error(
@@ -95,7 +100,7 @@ def run(dry_run):
                             )
                             continue
 
-                        perm_org_key = (
+                        perm_org_key = OrgKey(
                             permission["quayOrg"]["instance"]["name"],
                             permission["quayOrg"]["name"],
                         )

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/reconcile/quay_repos.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import logging
 import sys
 from collections import namedtuple
+from typing import TYPE_CHECKING
 
 from reconcile.quay_base import (
     OrgKey,
@@ -9,6 +12,9 @@ from reconcile.quay_base import (
 from reconcile.status import ExitCodes
 from reconcile.utils import gql
 
+if TYPE_CHECKING:
+    from reconcile.quay_base import QuayApiStore
+
 QUAY_REPOS_QUERY = """
 {
   apps: apps_v1 {
@@ -37,7 +43,7 @@ QONTRACT_INTEGRATION = "quay-repos"
 RepoInfo = namedtuple("RepoInfo", ["org_key", "name", "public", "description"])
 
 
-def fetch_current_state(quay_api_store):
+def fetch_current_state(quay_api_store: QuayApiStore) -> list[RepoInfo]:
     state = []
 
     for org_key, org_info in quay_api_store.items():
@@ -60,16 +66,17 @@ def fetch_current_state(quay_api_store):
     return state
 
 
-def fetch_desired_state(quay_api_store):
+def fetch_desired_state(quay_api_store: QuayApiStore) -> list[RepoInfo]:
     gqlapi = gql.get_api()
     result = gqlapi.query(QUAY_REPOS_QUERY)
+    # fetch from quayRepos
+    if not result:
+        return []
 
     state = []
-
     seen_repos = set()
 
-    # fetch from quayRepos
-    for app in result["apps"]:
+    for app in result.get("apps") or []:
         quay_repos = app.get("quayRepos")
 
         if quay_repos is None:
@@ -115,7 +122,9 @@ def fetch_desired_state(quay_api_store):
     return state
 
 
-def get_downstream_orgs(quay_api_store, upstream_org_key):
+def get_downstream_orgs(
+    quay_api_store: QuayApiStore, upstream_org_key: OrgKey
+) -> list[OrgKey]:
     downstream_orgs = []
     for org_key, org_info in quay_api_store.items():
         if org_info.get("mirror") == upstream_org_key:
@@ -124,14 +133,16 @@ def get_downstream_orgs(quay_api_store, upstream_org_key):
     return downstream_orgs
 
 
-def get_repo_from_state(state, repo_info):
+def get_repo_from_state(state: list[RepoInfo], repo_info: RepoInfo) -> RepoInfo | None:
     for item in state:
         if item.org_key == repo_info.org_key and item.name == repo_info.name:
             return item
     return None
 
 
-def act_delete(dry_run, quay_api_store, current_repo):
+def act_delete(
+    dry_run: bool, quay_api_store: QuayApiStore, current_repo: RepoInfo
+) -> None:
     logging.info([
         "delete_repo",
         current_repo.org_key.instance,
@@ -143,7 +154,9 @@ def act_delete(dry_run, quay_api_store, current_repo):
         api.repo_delete(current_repo.name)
 
 
-def act_create(dry_run, quay_api_store, desired_repo):
+def act_create(
+    dry_run: bool, quay_api_store: QuayApiStore, desired_repo: RepoInfo
+) -> None:
     logging.info([
         "create_repo",
         desired_repo.org_key.instance,
@@ -157,7 +170,9 @@ def act_create(dry_run, quay_api_store, desired_repo):
         )
 
 
-def act_description(dry_run, quay_api_store, desired_repo):
+def act_description(
+    dry_run: bool, quay_api_store: QuayApiStore, desired_repo: RepoInfo
+) -> None:
     logging.info([
         "update_desc",
         desired_repo.org_key.instance,
@@ -169,7 +184,9 @@ def act_description(dry_run, quay_api_store, desired_repo):
         api.repo_update_description(desired_repo.name, desired_repo.description)
 
 
-def act_public(dry_run, quay_api_store, desired_repo):
+def act_public(
+    dry_run: bool, quay_api_store: QuayApiStore, desired_repo: RepoInfo
+) -> None:
     logging.info([
         "update_public",
         desired_repo.org_key.instance,
@@ -184,24 +201,28 @@ def act_public(dry_run, quay_api_store, desired_repo):
             api.repo_make_private(desired_repo.name)
 
 
-def act(dry_run, quay_api_store, current_state, desired_state):
-    for current_repo in current_state:
-        desired_repo = get_repo_from_state(desired_state, current_repo)
-        if not desired_repo:
-            act_delete(dry_run, quay_api_store, current_repo)
+def act(
+    dry_run: bool,
+    quay_api_store: QuayApiStore,
+    current_state: list[RepoInfo],
+    desired_state: list[RepoInfo],
+) -> None:
+    for current_state_repo in current_state:
+        if not get_repo_from_state(desired_state, current_state_repo):
+            act_delete(dry_run, quay_api_store, current_state_repo)
 
-    for desired_repo in desired_state:
-        current_repo = get_repo_from_state(current_state, desired_repo)
+    for desired_state_repo in desired_state:
+        current_repo = get_repo_from_state(current_state, desired_state_repo)
         if not current_repo:
-            act_create(dry_run, quay_api_store, desired_repo)
+            act_create(dry_run, quay_api_store, desired_state_repo)
         else:
-            if current_repo.public != desired_repo.public:
-                act_public(dry_run, quay_api_store, desired_repo)
-            if current_repo.description != desired_repo.description:
-                act_description(dry_run, quay_api_store, desired_repo)
+            if current_repo.public != desired_state_repo.public:
+                act_public(dry_run, quay_api_store, desired_state_repo)
+            if current_repo.description != desired_state_repo.description:
+                act_description(dry_run, quay_api_store, desired_state_repo)
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     quay_api_store = get_quay_api_store()
 
     # consistency checks

{qontract_reconcile-0.10.2.dev285 → qontract_reconcile-0.10.2.dev287}/reconcile/query_validator.py

@@ -1,6 +1,7 @@
 import logging
 import sys
 from textwrap import indent
+from typing import Any
 
 from reconcile import queries
 from reconcile.openshift_resources_base import (
@@ -30,14 +31,17 @@ QUERY_VALIDATIONS_QUERY = """
 """ % (indent(OPENSHIFT_RESOURCE, 6 * " "),)
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     gqlapi = gql.get_api()
-    query_validations = gqlapi.query(QUERY_VALIDATIONS_QUERY)["validations"]
+    data = gqlapi.query(QUERY_VALIDATIONS_QUERY)
+    if not data:
+        return
+    query_validations: list[dict[str, Any]] = data.get("validations") or []
     settings = queries.get_secret_reader_settings()
     error = False
     for qv in query_validations:
         qv_name = qv["name"]
-        for q in qv["queries"]:
+        for q in qv.get("queries") or []:
             try:
                 gqlapi.query(gql.get_resource(q["path"])["content"])
             except (gql.GqlGetResourceError, gql.GqlApiError) as e: