qontract-reconcile 0.10.2.dev361__py3-none-any.whl → 0.10.2.dev474__py3-none-any.whl

reconcile/quay_membership.py

@@ -10,7 +10,7 @@ from reconcile.gql_definitions.quay_membership.quay_membership import (
     PermissionQuayOrgTeamV1,
     UserV1,
 )
-from reconcile.quay_base import QuayApiStore, get_quay_api_store
+from reconcile.quay_base import OrgKey, QuayApiStore
 from reconcile.status import ExitCodes
 from reconcile.utils import (
     expiration,
@@ -58,10 +58,11 @@ def fetch_current_state(quay_api_store: QuayApiStore) -> AggregatedList:
     state = AggregatedList()
 
     for org_key, org_data in quay_api_store.items():
-        quay_api = org_data["api"]
         teams = org_data["teams"]
         if not teams:
             continue
+
+        quay_api = org_data["api"]
         for team in teams:
             try:
                 members = quay_api.list_team_members(team)
@@ -76,8 +77,13 @@ def fetch_current_state(quay_api_store: QuayApiStore) -> AggregatedList:
             else:
                 # Teams are only added to the state if they exist so that
                 # there is a proper diff between the desired and current state.
+                # Use tuple format (instance, org_name) to match desired state format
                 state.add(
-                    {"service": "quay-membership", "org": org_key, "team": team},
+                    {
+                        "service": "quay-membership",
+                        "org": (org_key.instance, org_key.org_name),
+                        "team": team,
+                    },
                     members,
                 )
     return state
@@ -117,9 +123,16 @@ class RunnerAction:
         def action(params: dict, items: list) -> bool:
             org = params["org"]
             team = params["team"]
+            # Convert org tuple (instance, org_name) to OrgKey for lookup
+            org_key = (
+                OrgKey(org[0], org[1])
+                if isinstance(org, tuple)
+                else OrgKey("quay.io", org)
+            )
+            org_data = self.quay_api_store[org_key]
+            quay_api = org_data["api"]
 
             missing_users = False
-            quay_api = self.quay_api_store[org]["api"]
             for member in items:
                 logging.info([label, member, org, team])
                 user_exists = quay_api.user_exists(member)
@@ -147,19 +160,26 @@ class RunnerAction:
         def action(params: dict, items: list) -> bool:
             org = params["org"]
             team = params["team"]
+            # Convert org tuple (instance, org_name) to OrgKey for lookup
+            org_key = (
+                OrgKey(org[0], org[1])
+                if isinstance(org, tuple)
+                else OrgKey("quay.io", org)
+            )
+            org_data = self.quay_api_store[org_key]
 
             # Ensure all quay org/teams are declared as dependencies in a
             # `/dependencies/quay-org-1.yml` datafile.
-            if team not in self.quay_api_store[org]["teams"]:
+            if team not in org_data["teams"]:
                 raise RunnerError(
                     f"Quay team {team} is not defined as a "
-                    f"managedTeam in the {org} org."
+                    f"managedTeam in the {org_key.org_name} org."
                 )
 
             logging.info([label, org, team])
 
             if not self.dry_run:
-                quay_api = self.quay_api_store[org]["api"]
+                quay_api = org_data["api"]
                 quay_api.create_or_update_team(team)
 
             return True
@@ -172,12 +192,19 @@ class RunnerAction:
         def action(params: dict, items: list) -> bool:
             org = params["org"]
             team = params["team"]
+            # Convert org tuple (instance, org_name) to OrgKey for lookup
+            org_key = (
+                OrgKey(org[0], org[1])
+                if isinstance(org, tuple)
+                else OrgKey("quay.io", org)
+            )
+            org_data = self.quay_api_store[org_key]
 
+            quay_api = org_data["api"]
             if self.dry_run:
                 for member in items:
                     logging.info([label, member, org, team])
             else:
-                quay_api = self.quay_api_store[org]["api"]
                 for member in items:
                     logging.info([label, member, org, team])
                     quay_api.remove_user_from_team(member, team)
@@ -188,24 +215,23 @@ class RunnerAction:
 
 
 def run(dry_run: bool) -> None:
-    quay_api_store = get_quay_api_store()
-
-    current_state = fetch_current_state(quay_api_store)
-    desired_state = fetch_desired_state()
-
-    # calculate diff
-    diff = current_state.diff(desired_state)
-    logging.debug("State diff: %s", diff)
-
-    # Run actions
-    runner_action = RunnerAction(dry_run, quay_api_store)
-    runner = AggregatedDiffRunner(diff)
-
-    runner.register("insert", runner_action.create_team())
-    runner.register("update-insert", runner_action.add_to_team())
-    runner.register("update-delete", runner_action.del_from_team())
-    runner.register("delete", runner_action.del_from_team())
-
-    status = runner.run()
-    if not status:
-        sys.exit(ExitCodes.ERROR)
+    with QuayApiStore() as quay_api_store:
+        current_state = fetch_current_state(quay_api_store)
+        desired_state = fetch_desired_state()
+
+        # calculate diff
+        diff = current_state.diff(desired_state)
+        logging.debug("State diff: %s", diff)
+
+        # Run actions
+        runner_action = RunnerAction(dry_run, quay_api_store)
+        runner = AggregatedDiffRunner(diff)
+
+        runner.register("insert", runner_action.create_team())
+        runner.register("update-insert", runner_action.add_to_team())
+        runner.register("update-delete", runner_action.del_from_team())
+        runner.register("delete", runner_action.del_from_team())
+
+        status = runner.run()
+        if not status:
+            sys.exit(ExitCodes.ERROR)

reconcile/quay_mirror.py

@@ -66,7 +66,7 @@ class QuayMirror:
     }
     """
 
-    response_cache: dict[tuple[str, str], Response] = {}
+    response_cache: dict[tuple[str, str | None], Response] = {}
 
     def __init__(
         self,

reconcile/quay_mirror_org.py

@@ -17,7 +17,7 @@ from sretoolbox.container.image import (
 )
 from sretoolbox.container.skopeo import SkopeoCmdError
 
-from reconcile.quay_base import get_quay_api_store
+from reconcile.quay_base import QuayApiStore
 from reconcile.quay_mirror import QuayMirror
 from reconcile.utils.quay_mirror import record_timestamp, sync_tag
 
@@ -45,7 +45,7 @@ class QuayMirrorOrg:
     ) -> None:
         self.dry_run = dry_run
         self.skopeo_cli = Skopeo(dry_run)
-        self.quay_api_store = get_quay_api_store()
+        self.quay_api_store = QuayApiStore()
         self.compare_tags = compare_tags
         self.compare_tags_interval = compare_tags_interval
         self.orgs = orgs
@@ -71,6 +71,7 @@ class QuayMirrorOrg:
 
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         self.session.close()
+        self.quay_api_store.cleanup()
 
     def run(self) -> None:
         sync_tasks = self.process_sync_tasks()
@@ -101,11 +102,9 @@ class QuayMirrorOrg:
             if self.orgs and org_key.org_name not in self.orgs:
                 continue
 
-            quay_api = org_info["api"]
             upstream_org_key = org_info["mirror"]
             assert upstream_org_key is not None
             upstream_org = self.quay_api_store[upstream_org_key]
-            upstream_quay_api = upstream_org["api"]
 
             push_token = upstream_org["push_token"]
 
@@ -114,7 +113,10 @@ class QuayMirrorOrg:
             username = push_token["user"]
             token = push_token["token"]
 
+            quay_api = org_info["api"]
             org_repos = [item["name"] for item in quay_api.list_images()]
+
+            upstream_quay_api = upstream_org["api"]
             for repo in upstream_quay_api.list_images():
                 if repo["name"] not in org_repos:
                     continue

reconcile/quay_permissions.py

@@ -2,7 +2,10 @@ import logging
 import sys
 from typing import Any
 
-from reconcile.quay_base import OrgKey, get_quay_api_store
+from reconcile.quay_base import (
+    OrgKey,
+    QuayApiStore,
+)
 from reconcile.status import ExitCodes
 from reconcile.utils import gql
 
@@ -57,85 +60,88 @@ def run(dry_run: bool) -> None:
         return
 
     apps: list[dict[str, Any]] = result.get("apps") or []
-    quay_api_store = get_quay_api_store()
     error = False
-    for app in apps:
-        quay_repo_configs = app.get("quayRepos")
-        if not quay_repo_configs:
-            continue
-        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 = OrgKey(instance_name, org_name)
-
-            if not quay_repo_config["org"]["managedRepos"]:
-                logging.error(
-                    f"[{app['name']}] Can not manage repo permissions in {org_name} "
-                    "since managedRepos is set to false."
-                )
-                error = True
-                continue
-
-            # processing quayRepos section
-            logging.debug(["app", app["name"], instance_name, org_name])
 
-            quay_api = quay_api_store[org_key]["api"]
-            teams = quay_repo_config.get("teams")
-            if not teams:
+    with QuayApiStore() as quay_api_store:
+        for app in apps:
+            quay_repo_configs = app.get("quayRepos")
+            if not quay_repo_configs:
                 continue
-            repos = quay_repo_config["items"]
-            for repo in repos:
-                repo_name = repo["name"]
-
-                # processing repo section
-                logging.debug(["repo", repo_name])
-
-                for team in teams:
-                    permissions = team["permissions"]
-                    role = team["role"]
-                    for permission in permissions:
-                        if permission["service"] != "quay-membership":
-                            logging.warning(
-                                "wrong service kind, should be quay-membership"
+            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 = OrgKey(instance_name, org_name)
+
+                if not quay_repo_config["org"]["managedRepos"]:
+                    logging.error(
+                        f"[{app['name']}] Can not manage repo permissions in {org_name} "
+                        "since managedRepos is set to false."
+                    )
+                    error = True
+                    continue
+
+                # processing quayRepos section
+                logging.debug(["app", app["name"], instance_name, org_name])
+
+                org_data = quay_api_store[org_key]
+                teams = quay_repo_config.get("teams")
+                if not teams:
+                    continue
+                repos = quay_repo_config["items"]
+                quay_api = org_data["api"]
+
+                for repo in repos:
+                    repo_name = repo["name"]
+
+                    # processing repo section
+                    logging.debug(["repo", repo_name])
+
+                    for team in teams:
+                        permissions = team["permissions"]
+                        role = team["role"]
+                        for permission in permissions:
+                            if permission["service"] != "quay-membership":
+                                logging.warning(
+                                    "wrong service kind, should be quay-membership"
+                                )
+                                continue
+
+                            perm_org_key = OrgKey(
+                                permission["quayOrg"]["instance"]["name"],
+                                permission["quayOrg"]["name"],
                             )
-                            continue
-
-                        perm_org_key = OrgKey(
-                            permission["quayOrg"]["instance"]["name"],
-                            permission["quayOrg"]["name"],
-                        )
-
-                        if perm_org_key != org_key:
-                            logging.warning(f"wrong org, should be {org_key}")
-                            continue
 
-                        team_name = permission["team"]
-
-                        # processing team section
-                        logging.debug(["team", team_name])
-                        try:
-                            current_role = quay_api.get_repo_team_permissions(
-                                repo_name, team_name
-                            )
-                            if current_role != role:
-                                logging.info([
-                                    "update_role",
-                                    org_key,
-                                    repo_name,
-                                    team_name,
-                                    role,
-                                ])
-                                if not dry_run:
-                                    quay_api.set_repo_team_permissions(
-                                        repo_name, team_name, role
-                                    )
-                        except Exception:
-                            error = True
-                            logging.exception(
-                                "could not manage repo permissions: "
-                                f"repo name: {repo_name}, "
-                                f"team name: {team_name}"
-                            )
+                            if perm_org_key != org_key:
+                                logging.warning(f"wrong org, should be {org_key}")
+                                continue
+
+                            team_name = permission["team"]
+
+                            # processing team section
+                            logging.debug(["team", team_name])
+                            try:
+                                current_role = quay_api.get_repo_team_permissions(
+                                    repo_name, team_name
+                                )
+                                if current_role != role:
+                                    logging.info([
+                                        "update_role",
+                                        org_key,
+                                        repo_name,
+                                        team_name,
+                                        role,
+                                    ])
+                                    if not dry_run:
+                                        quay_api.set_repo_team_permissions(
+                                            repo_name, team_name, role
+                                        )
+                            except Exception:
+                                error = True
+                                logging.exception(
+                                    "could not manage repo permissions: "
+                                    f"repo name: {repo_name}, "
+                                    f"team name: {team_name}"
+                                )
 
     if error:
         sys.exit(ExitCodes.ERROR)

reconcile/quay_repos.py

@@ -3,18 +3,14 @@ from __future__ import annotations
 import logging
 import sys
 from collections import namedtuple
-from typing import TYPE_CHECKING
 
 from reconcile.quay_base import (
     OrgKey,
-    get_quay_api_store,
+    QuayApiStore,
 )
 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 {
@@ -51,7 +47,6 @@ def fetch_current_state(quay_api_store: QuayApiStore) -> list[RepoInfo]:
             continue
 
         quay_api = org_info["api"]
-
         for repo in quay_api.list_images():
             name = repo["name"]
             public = repo["is_public"]
@@ -150,7 +145,8 @@ def act_delete(
         current_repo.name,
     ])
     if not dry_run:
-        api = quay_api_store[current_repo.org_key]["api"]
+        org_data = quay_api_store[current_repo.org_key]
+        api = org_data["api"]
         api.repo_delete(current_repo.name)
 
 
@@ -164,7 +160,8 @@ def act_create(
         desired_repo.name,
     ])
     if not dry_run:
-        api = quay_api_store[desired_repo.org_key]["api"]
+        org_data = quay_api_store[desired_repo.org_key]
+        api = org_data["api"]
         api.repo_create(
             desired_repo.name, desired_repo.description, desired_repo.public
         )
@@ -180,7 +177,8 @@ def act_description(
         desired_repo.description,
     ])
     if not dry_run:
-        api = quay_api_store[desired_repo.org_key]["api"]
+        org_data = quay_api_store[desired_repo.org_key]
+        api = org_data["api"]
         api.repo_update_description(desired_repo.name, desired_repo.description)
 
 
@@ -194,7 +192,8 @@ def act_public(
         desired_repo.name,
     ])
     if not dry_run:
-        api = quay_api_store[desired_repo.org_key]["api"]
+        org_data = quay_api_store[desired_repo.org_key]
+        api = org_data["api"]
         if desired_repo.public:
             api.repo_make_public(desired_repo.name)
         else:
@@ -223,32 +222,31 @@ def act(
 
 
 def run(dry_run: bool) -> None:
-    quay_api_store = get_quay_api_store()
-
-    # consistency checks
-    for org_key, org_info in quay_api_store.items():
-        if org_info.get("mirror"):
-            # ensure there are no circular mirror dependencies
-            mirror_org_key = org_info["mirror"]
-            assert mirror_org_key is not None
-            mirror_org = quay_api_store[mirror_org_key]
-            if mirror_org.get("mirror"):
-                logging.error(
-                    f"{mirror_org_key.instance}/"
-                    + f"{mirror_org_key.org_name} "
-                    + "can't have mirrors and be a mirror"
-                )
-                sys.exit(ExitCodes.ERROR)
+    with QuayApiStore() as quay_api_store:
+        # consistency checks
+        for org_key, org_info in quay_api_store.items():
+            if org_info.get("mirror"):
+                # ensure there are no circular mirror dependencies
+                mirror_org_key = org_info["mirror"]
+                assert mirror_org_key is not None
+                mirror_org = quay_api_store[mirror_org_key]
+                if mirror_org.get("mirror"):
+                    logging.error(
+                        f"{mirror_org_key.instance}/"
+                        + f"{mirror_org_key.org_name} "
+                        + "can't have mirrors and be a mirror"
+                    )
+                    sys.exit(ExitCodes.ERROR)
 
-            # ensure no org defines `managedRepos` and `mirror` at the same
-            if org_info.get("managedRepos"):
-                logging.error(
-                    f"{org_key.instance}/{org_key.org_name} "
-                    + "has defined mirror and managedRepos"
-                )
-                sys.exit(ExitCodes.ERROR)
+                # ensure no org defines `managedRepos` and `mirror` at the same
+                if org_info.get("managedRepos"):
+                    logging.error(
+                        f"{org_key.instance}/{org_key.org_name} "
+                        + "has defined mirror and managedRepos"
+                    )
+                    sys.exit(ExitCodes.ERROR)
 
-    # run integration
-    current_state = fetch_current_state(quay_api_store)
-    desired_state = fetch_desired_state(quay_api_store)
-    act(dry_run, quay_api_store, current_state, desired_state)
+        # run integration
+        current_state = fetch_current_state(quay_api_store)
+        desired_state = fetch_desired_state(quay_api_store)
+        act(dry_run, quay_api_store, current_state, desired_state)