qontract-reconcile 0.10.2.dev485__py3-none-any.whl → 0.10.2.dev494__py3-none-any.whl

reconcile/typed_queries/vcs.py

@@ -0,0 +1,42 @@
+from collections.abc import Callable
+
+from pydantic import BaseModel
+from qontract_utils.vcs import Provider
+
+from reconcile.gql_definitions.common.vcs import query
+from reconcile.gql_definitions.fragments.vault_secret import VaultSecret
+from reconcile.utils import gql
+
+
+class Vcs(BaseModel):
+    name: str
+    url: str
+    default: bool = False
+    token: VaultSecret
+    provider: Provider
+
+
+def get_vcs_instances(query_func: Callable | None = None) -> list[Vcs]:
+    if not query_func:
+        query_func = gql.get_api().query
+    data = query(query_func=query_func)
+    vcs = [
+        Vcs(
+            name=gh_org.name,
+            url=gh_org.url,
+            default=gh_org.default or False,
+            token=gh_org.token,
+            provider=Provider.GITHUB,
+        )
+        for gh_org in data.gh_orgs or []
+    ]
+    vcs += [
+        Vcs(
+            name=gl_instance.name,
+            url=gl_instance.url,
+            token=gl_instance.token,
+            provider=Provider.GITLAB,
+        )
+        for gl_instance in data.gl_instances or []
+    ]
+    return vcs

reconcile/utils/runtime/integration.py

@@ -10,12 +10,16 @@ from typing import (
     Optional,
     TypeVar,
 )
+from urllib.parse import urlparse
 
+from httpx import Response
 from pydantic import BaseModel
+from qontract_api_client.client import AuthenticatedClient
 
 from reconcile.typed_queries.app_interface_vault_settings import (
     get_app_interface_vault_settings,
 )
+from reconcile.utils.config import get_config
 from reconcile.utils.secret_reader import (
     SecretReaderBase,
     create_secret_reader,
@@ -238,7 +242,58 @@ class QontractReconcileIntegration[RunParamsTypeVar: RunParams](ABC):
         )
 
 
+class QontractReconcileApiIntegration[RunParamsTypeVar: RunParams](ABC):
+    """
+    The base class for all integrations using the Qontract API.
+    """
+
+    def __init__(self, params: RunParamsTypeVar) -> None:
+        self.params: RunParamsTypeVar = params
+
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+    @staticmethod
+    async def _raise_on_4xx_5xx(response: Response) -> None:
+        response.raise_for_status()
+
+    @property
+    def qontract_api_client(self) -> AuthenticatedClient:
+        """
+        Returns the qontract-api client.
+        """
+        config = get_config()
+        return AuthenticatedClient(
+            base_url=urlparse(config["qontract-api"]["server"]).geturl(),
+            token=config["qontract-api"].get("token", ""),
+            httpx_args={
+                "event_hooks": {"response": [self._raise_on_4xx_5xx]},
+            },
+        )
+
+    @property
+    def secret_manager_url(self) -> str:
+        """
+        Returns the configured secret manager URL.
+        """
+        config = get_config()
+        return config["vault"]["server"]
+
+    @abstractmethod
+    async def async_run(self, dry_run: bool) -> None:
+        """
+        The `async_run` function of a QontractReconcileIntegration is the asynchronous
+        entry point to its actual functionality. It is obliged to honor the `dry_run`
+        argument and not perform any changes to the system if it is set to `True`.
+        At the same time the integration should progress as far as possible in the dry-run
+        mode to highlight any issues that would have prevented it from running in non-dry-run
+        mode.
+        """
+
+
 RUN_FUNCTION = "run"
+ASYNC_RUN_FUNCTION = "async_run"
 NAME_FIELD = "QONTRACT_INTEGRATION"
 EARLY_EXIT_DESIRED_STATE_FUNCTION = "early_exit_desired_state"
 DESIRED_STATE_SHARD_CONFIG_FUNCTION = "desired_state_shard_config"
@@ -308,3 +363,47 @@ class ModuleBasedQontractReconcileIntegration(
 
     def run(self, dry_run: bool) -> None:
         self.params.module.run(dry_run, *self.params.args, **self.params.kwargs)
+
+    async def async_run(self, dry_run: bool) -> None:
+        await self.params.module.async_run(
+            dry_run, *self.params.args, **self.params.kwargs
+        )
+
+
+class ModuleBasedQontractReconcileApiIntegration(
+    QontractReconcileApiIntegration[ModuleArgsKwargsRunParams]
+):
+    """
+    Since most integrations are implemented as modules, this class provides a
+    wrapper around a module that implements the `QontractReconcileIntegration`
+    interface. This way such module based integrations can be used as if they
+    were instances of the `QontractReconcileIntegration` class.
+    """
+
+    def __init__(self, params: ModuleArgsKwargsRunParams):
+        super().__init__(params)
+        # self.name  # run to check if the name can be extracted from the module
+        if not self._integration_supports(NAME_FIELD):
+            raise NotImplementedError(f"Integration has no {NAME_FIELD} field")
+        if not self._integration_supports(ASYNC_RUN_FUNCTION):
+            raise NotImplementedError(
+                f"Integration has no {ASYNC_RUN_FUNCTION}() function"
+            )
+
+    def _integration_supports(self, func_name: str) -> bool:
+        """
+        Verifies, that an integration supports a specific function.
+        todo: more thorough verification of the functions signature would be required.
+        """
+        return func_name in dir(self.params.module)
+
+    @property
+    def name(self) -> str:
+        if self._integration_supports(NAME_FIELD):
+            return self.params.module.QONTRACT_INTEGRATION.replace("_", "-")
+        raise NotImplementedError("Integration missing QONTRACT_INTEGRATION.")
+
+    async def async_run(self, dry_run: bool) -> None:
+        await self.params.module.async_run(
+            dry_run, *self.params.args, **self.params.kwargs
+        )

reconcile/utils/runtime/runner.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 import sys
 from dataclasses import dataclass
@@ -15,6 +16,7 @@ from reconcile.utils.runtime.desired_state_diff import (
     build_desired_state_diff,
 )
 from reconcile.utils.runtime.integration import (
+    QontractReconcileApiIntegration,
     QontractReconcileIntegration,
     RunParams,
 )
@@ -28,7 +30,7 @@ class IntegrationRunConfiguration:
     Holds all required context and configuration for an integration run.
     """
 
-    integration: QontractReconcileIntegration
+    integration: QontractReconcileIntegration | QontractReconcileApiIntegration
     valdiate_schemas: bool
     """
     Whether to fail an integration if it queries schemas it is not allowed to.
@@ -66,10 +68,18 @@ class IntegrationRunConfiguration:
     """
 
     def main_bundle_desired_state(self) -> dict[str, Any] | None:
+        if not isinstance(self.integration, QontractReconcileIntegration):
+            raise RuntimeError(
+                "main_bundle_desired_state is only available for QontractReconcileIntegration"
+            )
         self.switch_to_main_bundle()
         return self.integration.get_early_exit_desired_state()
 
     def comparison_bundle_desired_state(self) -> dict[str, Any] | None:
+        if not isinstance(self.integration, QontractReconcileIntegration):
+            raise RuntimeError(
+                "comparison_bundle_desired_state is only available for QontractReconcileIntegration"
+            )
         self.switch_to_comparison_bundle()
         data = self.integration.get_early_exit_desired_state()
         self.switch_to_main_bundle()
@@ -133,6 +143,7 @@ def get_desired_state_diff(
         logging.exception("Failed to fetch desired state for current bundle")
         return None
 
+    assert isinstance(run_cfg.integration, QontractReconcileIntegration)
     return build_desired_state_diff(
         run_cfg.integration.get_desired_state_shard_config()
         if run_cfg.check_only_affected_shards
@@ -157,16 +168,21 @@ def run_integration_cfg(run_cfg: IntegrationRunConfiguration) -> None:
 
 
 def _integration_wet_run[RunParamsTypeVar: RunParams](
-    integration: QontractReconcileIntegration[RunParamsTypeVar],
+    integration: QontractReconcileIntegration[RunParamsTypeVar]
+    | QontractReconcileApiIntegration[RunParamsTypeVar],
 ) -> None:
     """
     Runs an integration in wet mode, i.e. not in dry-run mode.
     """
-    integration.run(False)
+    if isinstance(integration, QontractReconcileIntegration):
+        integration.run(False)
+    else:
+        asyncio.run(integration.async_run(False))
 
 
 def _integration_dry_run[RunParamsTypeVar: RunParams](
-    integration: QontractReconcileIntegration[RunParamsTypeVar],
+    integration: QontractReconcileIntegration[RunParamsTypeVar]
+    | QontractReconcileApiIntegration[RunParamsTypeVar],
     desired_state_diff: DesiredStateDiff | None,
 ) -> None:
     """
@@ -189,7 +205,8 @@ def _integration_dry_run[RunParamsTypeVar: RunParams](
     # we can still try to run the integration in sharded mode on the
     # affected shards only
     if (
-        integration.supports_sharded_dry_run_mode()
+        isinstance(integration, QontractReconcileIntegration)
+        and integration.supports_sharded_dry_run_mode()
         and not integration.params_have_shard_info()  # already running in sharded mode?
         and desired_state_diff
         and desired_state_diff.affected_shards
@@ -201,6 +218,7 @@ def _integration_dry_run[RunParamsTypeVar: RunParams](
             sharded_integration = integration.build_integration_instance_for_shard(
                 shard
             )
+            # TODO: support async mode for sharded dry-runs
             sharded_integration.run(True)
 
         # run all shards
@@ -220,8 +238,11 @@ def _integration_dry_run[RunParamsTypeVar: RunParams](
         else:
             return
 
-    # if not, we run the integration in full
-    integration.run(True)
+    if isinstance(integration, QontractReconcileIntegration):
+        # if not, we run the integration in full
+        integration.run(True)
+    else:
+        asyncio.run(integration.async_run(True))
 
 
 def _is_task_result_an_error(result: Any) -> bool: