qontract-reconcile 0.10.0__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/utils/ocm/upgrades.py

@@ -0,0 +1,181 @@
+from typing import Any
+
+from reconcile.utils.ocm.base import OCMVersionGate
+from reconcile.utils.ocm_base_client import OCMBaseClient
+
+UPGRADE_POLICY_DESIRED_KEYS = {"id", "schedule_type", "schedule", "next_run", "version"}
+
+
+def build_cluster_url(cluster_id: str) -> str:
+    return f"/api/clusters_mgmt/v1/clusters/{cluster_id}"
+
+
+#
+# UPGRADE POLICIES
+#
+
+
+def get_upgrade_policies(
+    ocm_api: OCMBaseClient, cluster_id: str, schedule_type: str | None = None
+) -> list[dict[str, Any]]:
+    """Returns a list of details of Upgrade Policies
+
+    :param cluster: cluster name
+
+    :type cluster: string
+    """
+    results: list[dict[str, Any]] = []
+
+    for policy in ocm_api.get_paginated(
+        f"{build_cluster_url(cluster_id)}/upgrade_policies"
+    ):
+        if schedule_type and policy["schedule_type"] != schedule_type:
+            continue
+        policy_data = {
+            k: v for k, v in policy.items() if k in UPGRADE_POLICY_DESIRED_KEYS
+        }
+        policy_data["state"] = get_upgrade_policy_state(
+            ocm_api, cluster_id, policy["id"]
+        )
+        results.append(policy_data)
+
+    return results
+
+
+def get_upgrade_policy_state(
+    ocm_api: OCMBaseClient, cluster_id: str, upgrade_policy_id: str
+) -> str | None:
+    try:
+        state_data = ocm_api.get(
+            f"{build_cluster_url(cluster_id)}/upgrade_policies/{upgrade_policy_id}/state"
+        )
+        return state_data.get("value")
+    except Exception:
+        return None
+
+
+def create_upgrade_policy(ocm_api: OCMBaseClient, cluster_id: str, spec: dict) -> None:
+    """
+    Creates a new Upgrade Policy
+    """
+    ocm_api.post(f"{build_cluster_url(cluster_id)}/upgrade_policies", spec)
+
+
+def delete_upgrade_policy(
+    ocm_api: OCMBaseClient, cluster_id: str, policy_id: str
+) -> None:
+    """
+    Deletes an existing Upgrade Policy
+    """
+    ocm_api.delete(f"{build_cluster_url(cluster_id)}/upgrade_policies/{policy_id}")
+
+
+#
+# CONTROL PLANE UPGRADE POLICIES
+#
+
+
+def get_control_plane_upgrade_policies(
+    ocm_api: OCMBaseClient, cluster_id: str, schedule_type: str | None = None
+) -> list[dict[str, Any]]:
+    """
+    Returns a list of details of Upgrade Policies
+    """
+    results: list[dict[str, Any]] = []
+    for policy in ocm_api.get_paginated(
+        f"{build_cluster_url(cluster_id)}/control_plane/upgrade_policies"
+    ):
+        if schedule_type and policy["schedule_type"] != schedule_type:
+            continue
+        policy_data = {
+            k: v for k, v in policy.items() if k in UPGRADE_POLICY_DESIRED_KEYS
+        }
+        policy_data["state"] = policy.get("state", {}).get("value")
+        results.append(policy_data)
+    return results
+
+
+def create_control_plane_upgrade_policy(
+    ocm_api: OCMBaseClient, cluster_id: str, spec: dict
+) -> None:
+    """
+    Creates a new Upgrade Policy for the control plane
+    """
+    ocm_api.post(
+        f"{build_cluster_url(cluster_id)}/control_plane/upgrade_policies", spec
+    )
+
+
+def delete_control_plane_upgrade_policy(
+    ocm_api: OCMBaseClient, cluster_id: str, upgrade_policy_id: str
+) -> None:
+    """
+    Deletes an existing Control Plane Upgrade Policy
+    """
+    ocm_api.delete(
+        f"{build_cluster_url(cluster_id)}/control_plane/upgrade_policies/{upgrade_policy_id}"
+    )
+
+
+#
+# NODE POOLUPGRADE POLICIES
+#
+
+
+def get_node_pool_upgrade_policies(
+    ocm_api: OCMBaseClient, cluster_id: str, node_pool: str
+) -> list[dict[str, Any]]:
+    """
+    Returns a list of details of Upgrade Policies
+    """
+    results: list[dict[str, Any]] = []
+    for policy in ocm_api.get_paginated(
+        f"{build_cluster_url(cluster_id)}/node_pools/{node_pool}/upgrade_policies"
+    ):
+        results.append({
+            k: v for k, v in policy.items() if k in UPGRADE_POLICY_DESIRED_KEYS
+        })
+    return results
+
+
+def create_node_pool_upgrade_policy(
+    ocm_api: OCMBaseClient, cluster_id: str, node_pool: str, spec: dict
+) -> None:
+    """
+    Creates a new Upgrade Policy for the node pool plane
+    """
+    ocm_api.post(
+        f"{build_cluster_url(cluster_id)}/node_pools/{node_pool}/upgrade_policies", spec
+    )
+
+
+#
+# VERSION AGREEMENTS
+#
+
+
+def create_version_agreement(
+    ocm_api: OCMBaseClient, gate_id: str, cluster_id: str
+) -> dict[str, str | bool]:
+    return ocm_api.post(
+        f"{build_cluster_url(cluster_id)}/gate_agreements",
+        {"version_gate": {"id": gate_id}},
+    )
+
+
+def get_version_agreement(
+    ocm_api: OCMBaseClient, cluster_id: str
+) -> list[dict[str, Any]]:
+    agreements = []
+    for item in ocm_api.get_paginated(
+        f"{build_cluster_url(cluster_id)}/gate_agreements"
+    ):
+        agreements.append(item)
+    return agreements
+
+
+def get_version_gates(ocm_api: OCMBaseClient) -> list[OCMVersionGate]:
+    return [
+        OCMVersionGate(**g)
+        for g in ocm_api.get_paginated("/api/clusters_mgmt/v1/version_gates")
+    ]

reconcile/utils/ocm_base_client.py

@@ -3,11 +3,10 @@ from collections.abc import (
     Generator,
     Mapping,
 )
+from types import TracebackType
 from typing import (
     Any,
-    Optional,
     Protocol,
-    Union,
 )
 
 from pydantic import BaseModel
@@ -17,6 +16,8 @@ from requests import (
 )
 from sretoolbox.utils import retry
 
+from reconcile.gql_definitions.fragments.aus_organization import AUSOCMOrganization
+from reconcile.utils.metrics import ocm_request
 from reconcile.utils.secret_reader import (
     HasSecret,
     SecretReaderBase,
@@ -37,7 +38,7 @@ class OCMBaseClient:
         access_token_client_secret: str,
         access_token_url: str,
         access_token_client_id: str,
-        session: Optional[Session] = None,
+        session: Session | None = None,
     ):
         self._access_token_client_secret = access_token_client_secret
         self._access_token_client_id = access_token_client_id
@@ -61,14 +62,13 @@ class OCMBaseClient:
         self._access_token = r.json().get("access_token")
 
     def _init_request_headers(self):
-        self._session.headers.update(
-            {
-                "Authorization": f"Bearer {self._access_token}",
-                "accept": "application/json",
-            }
-        )
+        self._session.headers.update({
+            "Authorization": f"Bearer {self._access_token}",
+            "accept": "application/json",
+        })
 
-    def get(self, api_path: str, params: Optional[Mapping[str, str]] = None) -> Any:
+    def get(self, api_path: str, params: Mapping[str, str] | None = None) -> Any:
+        ocm_request.labels(verb="GET", client_id=self._access_token_client_id).inc()
         r = self._session.get(
             f"{self._url}{api_path}",
             params=params,
@@ -80,40 +80,36 @@ class OCMBaseClient:
     def get_paginated(
         self,
         api_path: str,
-        params: Optional[dict[str, Any]] = None,
+        params: dict[str, Any] | None = None,
         max_page_size: int = 100,
-        max_pages: Optional[int] = None,
+        max_pages: int | None = None,
     ) -> Generator[dict[str, Any], None, None]:
-        if not params:
-            params_copy = {}
-        else:
-            params_copy = params.copy()
+        """
+        Note, that pagination is currently broken.
+        Each call will return a random order, meaning pages are not consistent.
+        ALWAYS by default try to use "orderBy: id", as id exists for every resource and has an index in the db.
+        """
+        params_copy = {} if not params else params.copy()
         params_copy["size"] = max_page_size
 
-        # fetch pages
-        records_seen = 0
         while True:
-            rs = self.get(api_path, params=params)
-            for item in rs.get("items", []):
-                yield item
-            total_records = rs.get("total", 0)
+            rs = self.get(api_path, params=params_copy)
+            yield from rs.get("items", [])
             current_page = rs.get("page", 0)
             records_on_page = rs.get("size", len(rs.get("items", [])))
-            records_seen += records_on_page
-            if total_records > records_seen and (
-                max_pages and max_pages < current_page
-            ):
-                # more page available
-                params_copy["page"] = current_page + 1
-            else:
+            if records_on_page < max_page_size:
+                return
+            if max_pages is not None and current_page >= max_pages:
                 return
+            params_copy["page"] = current_page + 1
 
     def post(
         self,
         api_path: str,
-        data: Optional[Union[Mapping[str, Any], str]] = None,
-        params: Optional[Mapping[str, str]] = None,
+        data: Mapping[str, Any] | None = None,
+        params: Mapping[str, str] | None = None,
     ) -> Any:
+        ocm_request.labels(verb="POST", client_id=self._access_token_client_id).inc()
         r = self._session.post(
             f"{self._url}{api_path}",
             json=data,
@@ -133,8 +129,9 @@ class OCMBaseClient:
         self,
         api_path: str,
         data: Mapping[str, Any],
-        params: Optional[Mapping[str, str]] = None,
+        params: Mapping[str, str] | None = None,
     ):
+        ocm_request.labels(verb="PATCH", client_id=self._access_token_client_id).inc()
         r = self._session.patch(
             f"{self._url}{api_path}",
             json=data,
@@ -148,8 +145,27 @@ class OCMBaseClient:
             raise e
 
     def delete(self, api_path: str):
+        ocm_request.labels(verb="DELETE", client_id=self._access_token_client_id).inc()
         r = self._session.delete(f"{self._url}{api_path}", timeout=REQUEST_TIMEOUT_SEC)
-        r.raise_for_status()
+        try:
+            r.raise_for_status()
+        except Exception:
+            logging.error(r.text)
+            raise
+
+    def close(self) -> None:
+        self._session.close()
+
+    def __enter__(self) -> "OCMBaseClient":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
 
 
 class OCMAPIClientConfigurationProtocol(Protocol):
@@ -158,8 +174,7 @@ class OCMAPIClientConfigurationProtocol(Protocol):
     access_token_url: str
 
     @property
-    def access_token_client_secret(self) -> HasSecret:
-        ...
+    def access_token_client_secret(self) -> HasSecret: ...
 
 
 class OCMAPIClientConfiguration(BaseModel, arbitrary_types_allowed=True):
@@ -169,10 +184,30 @@ class OCMAPIClientConfiguration(BaseModel, arbitrary_types_allowed=True):
     access_token_client_secret: HasSecret
 
 
+def init_ocm_base_client_for_org(
+    org: AUSOCMOrganization,
+    secret_reader: SecretReaderBase,
+    session: Session | None = None,
+) -> OCMBaseClient:
+    if org.access_token_client_id:
+        return init_ocm_base_client(
+            OCMAPIClientConfiguration(
+                url=org.environment.url,
+                access_token_client_id=org.access_token_client_id,
+                access_token_url=org.access_token_url,
+                access_token_client_secret=org.access_token_client_secret,
+            ),
+            secret_reader,
+            session,
+        )
+
+    return init_ocm_base_client(org.environment, secret_reader, session)
+
+
 def init_ocm_base_client(
     cfg: OCMAPIClientConfigurationProtocol,
     secret_reader: SecretReaderBase,
-    session: Optional[Session] = None,
+    session: Session | None = None,
 ) -> OCMBaseClient:
     """
     Initiate an API client towards an OCM instance.