qontract-reconcile 0.9.1rc298__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/utils/oc_connection_parameters.py

@@ -4,8 +4,8 @@ import logging
 from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import (
-    Optional,
     Protocol,
+    runtime_checkable,
 )
 
 from sretoolbox.utils import threaded
@@ -22,51 +22,45 @@ class OCConnectionError(Exception):
 
 
 class Disable(Protocol):
-    integrations: Optional[list[str]]
-    e2e_tests: Optional[list[str]]
+    integrations: list[str] | None
 
 
 class Jumphost(Protocol):
     hostname: str
-    port: Optional[int]
-    remote_port: Optional[int]
+    port: int | None
+    remote_port: int | None
     known_hosts: str
     user: str
 
     @property
-    def identity(self) -> HasSecret:
-        ...
+    def identity(self) -> HasSecret: ...
 
 
+@runtime_checkable
 class Cluster(Protocol):
     name: str
     server_url: str
-    internal: Optional[bool]
-    insecure_skip_tls_verify: Optional[bool]
+    internal: bool | None
+    insecure_skip_tls_verify: bool | None
 
     @property
-    def jump_host(self) -> Optional[Jumphost]:
-        ...
+    def jump_host(self) -> Jumphost | None: ...
 
     @property
-    def automation_token(self) -> Optional[HasSecret]:
-        ...
+    def automation_token(self) -> HasSecret | None: ...
 
     @property
-    def cluster_admin_automation_token(self) -> Optional[HasSecret]:
-        ...
+    def cluster_admin_automation_token(self) -> HasSecret | None: ...
 
     @property
-    def disable(self) -> Optional[Disable]:
-        ...
+    def disable(self) -> Disable | None: ...
 
 
 class Namespace(Protocol):
-    cluster_admin: Optional[bool]
+    cluster_admin: bool | None
 
     @property
-    def cluster(self) -> Cluster:
-        ...
+    def cluster(self) -> Cluster: ...
 
 
 @dataclass
@@ -87,21 +81,20 @@ class OCConnectionParameters:
 
     cluster_name: str
     server_url: str
-    is_internal: Optional[bool]
+    is_internal: bool | None
     is_cluster_admin: bool
-    skip_tls_verify: Optional[bool]
-    automation_token: Optional[str]
-    cluster_admin_automation_token: Optional[str]
+    skip_tls_verify: bool | None
+    automation_token: str | None
+    cluster_admin_automation_token: str | None
     disabled_integrations: list[str]
-    disabled_e2e_tests: list[str]
-    jumphost_hostname: Optional[str]
-    jumphost_known_hosts: Optional[str]
-    jumphost_user: Optional[str]
-    jumphost_port: Optional[int]
-    jumphost_key: Optional[str]
-    jumphost_remote_port: Optional[int]
+    jumphost_hostname: str | None
+    jumphost_known_hosts: str | None
+    jumphost_user: str | None
+    jumphost_port: int | None
+    jumphost_key: str | None
+    jumphost_remote_port: int | None
     # The local port is currently calculated and set outside of this class
-    jumphost_local_port: Optional[int]
+    jumphost_local_port: int | None
 
     @staticmethod
     def _get_token_verify_server_url(secret: ClusterSecret, cluster: Cluster) -> str:
@@ -118,7 +111,7 @@ class OCConnectionParameters:
     @staticmethod
     def _get_automation_token(
         secret_reader: SecretReaderBase, secret: HasSecret, cluster: Cluster
-    ) -> Optional[str]:
+    ) -> str | None:
         secret_raw = secret_reader.read_all_secret(secret)
         return OCConnectionParameters._get_token_verify_server_url(
             ClusterSecret(
@@ -136,8 +129,8 @@ class OCConnectionParameters:
         cluster_admin: bool,
         use_jump_host: bool = True,
     ) -> OCConnectionParameters:
-        automation_token: Optional[str] = None
-        cluster_admin_automation_token: Optional[str] = None
+        automation_token: str | None = None
+        cluster_admin_automation_token: str | None = None
 
         if cluster_admin:
             if cluster.cluster_admin_automation_token:
@@ -159,26 +152,23 @@ class OCConnectionParameters:
                 logging.debug(
                     f"No admin automation token set for cluster '{cluster.name}', but privileged access requested."
                 )
+        elif cluster.automation_token:
+            try:
+                automation_token = OCConnectionParameters._get_automation_token(
+                    secret_reader, cluster.automation_token, cluster
+                )
+            except SecretNotFound:
+                logging.error(
+                    f"[{cluster.name}] automation token {cluster.automation_token} not found"
+                )
         else:
-            if cluster.automation_token:
-                try:
-                    automation_token = OCConnectionParameters._get_automation_token(
-                        secret_reader, cluster.automation_token, cluster
-                    )
-                except SecretNotFound:
-                    logging.error(
-                        f"[{cluster.name}] automation token {cluster.automation_token} not found"
-                    )
-            else:
-                # Note, that currently OCMap uses OCLogMsg if a token is missing, i.e.,
-                # for now this is valid behavior.
-                logging.debug(f"No automation token for cluster '{cluster.name}'.")
+            # Note, that currently OCMap uses OCLogMsg if a token is missing, i.e.,
+            # for now this is valid behavior.
+            logging.debug(f"No automation token for cluster '{cluster.name}'.")
 
         disabled_integrations = []
-        disabled_e2e_tests = []
         if cluster.disable:
             disabled_integrations = cluster.disable.integrations or []
-            disabled_e2e_tests = cluster.disable.e2e_tests or []
 
         jumphost_hostname = None
         jumphost_known_hosts = None
@@ -207,7 +197,6 @@ class OCConnectionParameters:
             server_url=cluster.server_url,
             is_internal=cluster.internal,
             skip_tls_verify=cluster.insecure_skip_tls_verify,
-            disabled_e2e_tests=disabled_e2e_tests,
             disabled_integrations=disabled_integrations,
             automation_token=automation_token,
             jumphost_hostname=jumphost_hostname,

reconcile/utils/oc_filters.py

@@ -1,6 +1,5 @@
 from collections.abc import Iterable
 from typing import (
-    Optional,
     Protocol,
     TypeVar,
 )
@@ -14,29 +13,28 @@ class Namespace(Protocol):
     name: str
 
     @property
-    def cluster(self) -> Cluster:
-        ...
+    def cluster(self) -> Cluster: ...
 
 
 NS = TypeVar("NS", bound=Namespace)
 
 
 def filter_namespaces_by_cluster(
-    namespaces: Iterable[NS], cluster_name: str
+    namespaces: Iterable[NS], cluster_names: Iterable[str]
 ) -> list[NS]:
-    return [n for n in namespaces if n.cluster.name == cluster_name]
+    return [n for n in namespaces if n.cluster.name in cluster_names]
 
 
 def filter_namespaces_by_name(
-    namespaces: Iterable[NS], namespace_name: str
+    namespaces: Iterable[NS], namespace_names: Iterable[str]
 ) -> list[NS]:
-    return [n for n in namespaces if n.name == namespace_name]
+    return [n for n in namespaces if n.name in namespace_names]
 
 
 def filter_namespaces_by_cluster_and_namespace(
     namespaces: Iterable[NS],
-    cluster_name: Optional[str],
-    namespace_name: Optional[str],
+    cluster_names: Iterable[str] | None,
+    namespace_names: Iterable[str] | None,
 ) -> list[NS]:
     """
     Filter namespaces by cluster and namespace name.
@@ -45,12 +43,12 @@ def filter_namespaces_by_cluster_and_namespace(
     be empty, no matter if the namespace name exists or not.
     """
     result: list[NS] = list(namespaces)
-    if cluster_name:
+    if cluster_names:
         result = filter_namespaces_by_cluster(
-            namespaces=result, cluster_name=cluster_name
+            namespaces=result, cluster_names=cluster_names
         )
-    if namespace_name:
+    if namespace_names:
         result = filter_namespaces_by_name(
-            namespaces=result, namespace_name=namespace_name
+            namespaces=result, namespace_names=namespace_names
         )
     return result

reconcile/utils/oc_map.py

@@ -1,17 +1,13 @@
 import logging
 from collections.abc import Iterable
 from threading import Lock
-from typing import (
-    Optional,
-    Union,
-)
 
 from sretoolbox.utils import threaded
 
 from reconcile.utils.jump_host import JumpHostSSH
 from reconcile.utils.oc import (
     OC,
-    OCDeprecated,
+    OCCli,
     OCLogMsg,
     StatusCodeError,
 )
@@ -41,18 +37,16 @@ class OCMap:
         self,
         connection_parameters: Iterable[OCConnectionParameters],
         integration: str = "",
-        e2e_test: str = "",
-        internal: Optional[bool] = None,
+        internal: bool | None = None,
         use_jump_host: bool = True,
         thread_pool_size: int = 1,
         init_projects: bool = False,
         init_api_resources: bool = False,
-        oc_cls: Optional[type[OC]] = None,
+        oc_cls: type[OC] | None = None,
     ):
-        self._oc_map: dict[str, Union[OCDeprecated, OCLogMsg]] = {}
-        self._privileged_oc_map: dict[str, Union[OCDeprecated, OCLogMsg]] = {}
+        self._oc_map: dict[str, OCCli | OCLogMsg] = {}
+        self._privileged_oc_map: dict[str, OCCli | OCLogMsg] = {}
         self._calling_integration = integration
-        self._calling_e2e_test = e2e_test
         self._internal = internal
         self._use_jump_host = use_jump_host
         self._thread_pool_size = thread_pool_size
@@ -128,7 +122,7 @@ class OCMap:
                     connection_parameters=connection_parameters
                 )
             try:
-                oc_client: Union[OCDeprecated, OCLogMsg] = self._oc_cls(
+                oc_client: OCCli | OCLogMsg = self._oc_cls(  # type: ignore[assignment]
                     connection_parameters=connection_parameters,
                     init_projects=self._init_projects,
                     init_api_resources=self._init_api_resources,
@@ -139,14 +133,12 @@ class OCMap:
                     cluster,
                     OCLogMsg(
                         log_level=logging.ERROR,
-                        message=f"[{cluster}]" f" is unreachable: {e}",
+                        message=f"[{cluster}] is unreachable: {e}",
                     ),
                     privileged,
                 )
 
-    def _set_oc(
-        self, cluster: str, value: Union[OCDeprecated, OCLogMsg], privileged: bool
-    ) -> None:
+    def _set_oc(self, cluster: str, value: OCCli | OCLogMsg, privileged: bool) -> None:
         with self._lock:
             if privileged:
                 self._privileged_oc_map[cluster] = value
@@ -160,25 +152,16 @@ class OCMap:
                 return True
         except (KeyError, TypeError):
             pass
-
-        try:
-            tests = cluster_info.disabled_e2e_tests or []
-            if self._calling_e2e_test.replace("_", "-") in tests:
-                return True
-        except (KeyError, TypeError):
-            pass
         return False
 
-    def get(
-        self, cluster: str, privileged: bool = False
-    ) -> Union[OCDeprecated, OCLogMsg]:
+    def get(self, cluster: str, privileged: bool = False) -> OCCli | OCLogMsg:
         cluster_map = self._privileged_oc_map if privileged else self._oc_map
         return cluster_map.get(
             cluster,
             OCLogMsg(log_level=logging.DEBUG, message=f"[{cluster}] cluster skipped"),
         )
 
-    def get_cluster(self, cluster: str, privileged: bool = False) -> OCDeprecated:
+    def get_cluster(self, cluster: str, privileged: bool = False) -> OCCli:
         result = self.get(cluster, privileged)
         if isinstance(result, OCLogMsg):
             raise result
@@ -200,10 +183,10 @@ class OCMap:
 
     def cleanup(self) -> None:
         for oc in self._oc_map.values():
-            if oc and isinstance(oc, OCDeprecated):
+            if oc and isinstance(oc, OCCli):
                 oc.cleanup()
         for oc in self._privileged_oc_map.values():
-            if oc and isinstance(oc, OCDeprecated):
+            if oc and isinstance(oc, OCCli):
                 oc.cleanup()
 
 
@@ -211,8 +194,7 @@ def init_oc_map_from_clusters(
     clusters: Iterable[Cluster],
     secret_reader: SecretReaderBase,
     integration: str = "",
-    e2e_test: str = "",
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
     thread_pool_size: int = 1,
     init_projects: bool = False,
@@ -231,7 +213,6 @@ def init_oc_map_from_clusters(
     return OCMap(
         connection_parameters=connection_parameters,
         integration=integration,
-        e2e_test=e2e_test,
         internal=internal,
         use_jump_host=use_jump_host,
         thread_pool_size=thread_pool_size,
@@ -244,8 +225,7 @@ def init_oc_map_from_namespaces(
     namespaces: Iterable[Namespace],
     secret_reader: SecretReaderBase,
     integration: str = "",
-    e2e_test: str = "",
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
     thread_pool_size: int = 1,
     init_projects: bool = False,
@@ -266,7 +246,6 @@ def init_oc_map_from_namespaces(
     return OCMap(
         connection_parameters=connection_parameters,
         integration=integration,
-        e2e_test=e2e_test,
         internal=internal,
         use_jump_host=use_jump_host,
         thread_pool_size=thread_pool_size,

reconcile/utils/ocm/__init__.py

@@ -1 +1,30 @@
-from reconcile.utils.ocm.ocm import *  # noqa: F401,F403
+from reconcile.utils.ocm.ocm import *  # noqa: F403
+from reconcile.utils.ocm.products import (  # noqa: F401
+    BYTES_IN_GIGABYTE,
+    CS_API_BASE,
+    DEFAULT_OCM_MACHINE_POOL_ID,
+    OCM_PRODUCT_HYPERSHIFT,
+    OCM_PRODUCT_OSD,
+    OCM_PRODUCT_ROSA,
+    SPEC_ATTR_ACCOUNT,
+    SPEC_ATTR_AVAILABILITY_ZONES,
+    SPEC_ATTR_CHANNEL,
+    SPEC_ATTR_CONSOLE_URL,
+    SPEC_ATTR_DISABLE_UWM,
+    SPEC_ATTR_ELBFQDN,
+    SPEC_ATTR_EXTERNAL_ID,
+    SPEC_ATTR_HYPERSHIFT,
+    SPEC_ATTR_ID,
+    SPEC_ATTR_INITIAL_VERSION,
+    SPEC_ATTR_LOAD_BALANCERS,
+    SPEC_ATTR_MULTI_AZ,
+    SPEC_ATTR_NETWORK,
+    SPEC_ATTR_OIDC_ENDPONT_URL,
+    SPEC_ATTR_PATH,
+    SPEC_ATTR_PRIVATE,
+    SPEC_ATTR_PROVISION_SHARD_ID,
+    SPEC_ATTR_SERVER_URL,
+    SPEC_ATTR_STORAGE,
+    SPEC_ATTR_SUBNET_IDS,
+    SPEC_ATTR_VERSION,
+)

reconcile/utils/ocm/addons.py

@@ -0,0 +1,228 @@
+from typing import Any
+
+from reconcile.utils.ocm.base import (
+    OCMAddonInstallation,
+    OCMAddonUpgradePolicy,
+)
+from reconcile.utils.ocm_base_client import OCMBaseClient
+
+
+class AddonService:
+    def get_addon_latest_versions(self, ocm_api: OCMBaseClient) -> dict[str, str]:
+        """
+        Returns the latest version for each addon.
+        """
+        latest_versions: dict[str, str] = {}
+        for addon in ocm_api.get_paginated(f"{self.addon_base_api_path()}/addons"):
+            addon_id = addon["id"]
+            latest_versions[addon_id] = addon["version"]["id"]
+        return latest_versions
+
+    def get_addons_for_cluster(
+        self,
+        ocm_api: OCMBaseClient,
+        cluster_id: str,
+        addon_latest_versions: dict[str, str],
+        required_state: str | None,
+    ) -> list[OCMAddonInstallation]:
+        """
+        Returns a list of Addons installed on a cluster
+
+        :param cluster_id: ID of the cluster
+        :param addon_latest_versions: dict of addon_id -> latest version. This allows us to
+            populate the addonsinstalation available upgrades in an efficient way.
+        :param required_state: only return addons with this state
+        """
+
+        params: dict[str, Any] | None = None
+        if required_state:
+            params = {"search": f"state='{required_state}'"}
+
+        addons = []
+        for addon in ocm_api.get_paginated(
+            api_path=f"{self.addon_base_api_path()}/clusters/{cluster_id}/addons",
+            params=params,
+        ):
+            current_version = addon["addon_version"]["id"]
+            latest_version = addon_latest_versions.get(addon["id"])
+            addon["addon_version"]["available_upgrades"] = (
+                [latest_version] if latest_version != current_version else []
+            )
+            addons.append(OCMAddonInstallation(**addon))
+        return addons
+
+    def addon_base_api_path(self) -> str:
+        raise NotImplementedError()
+
+    def get_addon_upgrade_policies(
+        self, ocm_api: OCMBaseClient, cluster_id: str, addon_id: str | None = None
+    ) -> list[OCMAddonUpgradePolicy]:
+        raise NotImplementedError()
+
+    def create_addon_upgrade_policy(
+        self,
+        ocm_api: OCMBaseClient,
+        cluster_id: str,
+        addon_id: str,
+        schedule_type: str,
+        version: str,
+        next_run: str,
+    ) -> None:
+        raise NotImplementedError()
+
+    def delete_addon_upgrade_policy(
+        self, ocm_api: OCMBaseClient, cluster_id: str, policy_id: str
+    ) -> None:
+        raise NotImplementedError()
+
+
+class AddonServiceV1(AddonService):
+    """
+    The original addon-service API that is part of CS.
+    """
+
+    def addon_base_api_path(self) -> str:
+        return "/api/clusters_mgmt/v1"
+
+    def get_addon_upgrade_policies(
+        self, ocm_api: OCMBaseClient, cluster_id: str, addon_id: str | None = None
+    ) -> list[OCMAddonUpgradePolicy]:
+        results: list[OCMAddonUpgradePolicy] = []
+
+        for policy in ocm_api.get_paginated(
+            f"{self.addon_base_api_path()}/clusters/{cluster_id}/addon_upgrade_policies"
+        ):
+            if addon_id and policy["addon_id"] != addon_id:
+                continue
+
+            state = self._get_addon_upgrade_policy_state(
+                ocm_api, cluster_id, policy["id"]
+            )
+            results.append(
+                OCMAddonUpgradePolicy(
+                    id=policy["id"],
+                    addon_id=addon_id,
+                    cluster_id=cluster_id,
+                    schedule_type=policy["schedule_type"],
+                    schedule=policy.get("schedule"),
+                    next_run=policy.get("next_run"),
+                    version=policy["version"],
+                    state=state,
+                )
+            )
+
+        return results
+
+    def _get_addon_upgrade_policy_state(
+        self, ocm_api: OCMBaseClient, cluster_id: str, addon_upgrade_policy_id: str
+    ) -> str | None:
+        try:
+            state_data = ocm_api.get(
+                f"{self.addon_base_api_path()}/clusters/{cluster_id}/addon_upgrade_policies/{addon_upgrade_policy_id}/state"
+            )
+            return state_data.get("value")
+        except Exception:
+            return None
+
+    def create_addon_upgrade_policy(
+        self,
+        ocm_api: OCMBaseClient,
+        cluster_id: str,
+        addon_id: str,
+        schedule_type: str,
+        version: str,
+        next_run: str,
+    ) -> None:
+        """
+        Creates a new Addon Upgrade Policy
+        """
+        spec = {
+            "version": version,
+            "schedule_type": schedule_type,
+            "addon_id": addon_id,
+            "cluster_id": cluster_id,
+            "upgrade_type": "ADDON",
+        }
+        ocm_api.post(
+            f"{self.addon_base_api_path()}/clusters/{cluster_id}/addon_upgrade_policies",
+            spec,
+        )
+
+    def delete_addon_upgrade_policy(
+        self, ocm_api: OCMBaseClient, cluster_id: str, policy_id: str
+    ) -> None:
+        """
+        Deletes an existing Addon Upgrade Policy
+        """
+        ocm_api.delete(
+            f"{self.addon_base_api_path()}/clusters/{cluster_id}/addon_upgrade_policies/{policy_id}"
+        )
+
+
+class AddonServiceV2(AddonService):
+    """
+    The dedicated addon-service API that is part of OCM.
+    """
+
+    def addon_base_api_path(self) -> str:
+        return "/api/addons_mgmt/v1"
+
+    def get_addon_upgrade_policies(
+        self, ocm_api: OCMBaseClient, cluster_id: str, addon_id: str | None = None
+    ) -> list[OCMAddonUpgradePolicy]:
+        results: list[OCMAddonUpgradePolicy] = []
+
+        for policy in ocm_api.get_paginated(
+            f"{self.addon_base_api_path()}/clusters/{cluster_id}/upgrade_plans"
+        ):
+            if addon_id and policy["addon_id"] != addon_id:
+                continue
+
+            results.append(
+                OCMAddonUpgradePolicy(
+                    id=policy["id"],
+                    addon_id=addon_id,
+                    cluster_id=cluster_id,
+                    schedule_type=policy["type"],
+                    schedule=policy.get("schedule"),
+                    next_run=policy.get("next_run"),
+                    version=policy["version"],
+                    state=policy.get("state"),
+                    addon_service=self,
+                )
+            )
+
+        return results
+
+    def create_addon_upgrade_policy(
+        self,
+        ocm_api: OCMBaseClient,
+        cluster_id: str,
+        addon_id: str,
+        schedule_type: str,
+        version: str,
+        next_run: str,
+    ) -> None:
+        """
+        Schedules an addon upgrade. Leverages addon-service upgrade plans behind the scene.
+        """
+        spec = {
+            "version": version,
+            "type": schedule_type,
+            "addon_id": addon_id,
+            "cluster_id": cluster_id,
+            "next_run": next_run,
+        }
+        ocm_api.post(
+            f"{self.addon_base_api_path()}/clusters/{cluster_id}/upgrade_plans", spec
+        )
+
+    def delete_addon_upgrade_policy(
+        self, ocm_api: OCMBaseClient, cluster_id: str, policy_id: str
+    ) -> None:
+        """
+        Deletes an existing upgrade plan.
+        """
+        ocm_api.delete(
+            f"{self.addon_base_api_path()}/clusters/{cluster_id}/upgrade_plans/{policy_id}"
+        )