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

reconcile/status_board.py

@@ -0,0 +1,275 @@
+import logging
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from collections.abc import Iterable, Mapping
+from typing import (
+    Any,
+    Optional,
+)
+
+from pydantic import BaseModel
+
+from reconcile.gql_definitions.status_board.status_board import StatusBoardV1
+from reconcile.typed_queries.status_board import (
+    get_selected_app_names,
+    get_status_board,
+)
+from reconcile.utils.differ import diff_mappings
+from reconcile.utils.ocm.status_board import (
+    create_application,
+    create_product,
+    delete_application,
+    delete_product,
+    get_managed_products,
+    get_product_applications,
+)
+from reconcile.utils.ocm_base_client import (
+    OCMBaseClient,
+    init_ocm_base_client,
+)
+from reconcile.utils.runtime.integration import QontractReconcileIntegration
+
+QONTRACT_INTEGRATION = "status-board-exporter"
+
+
+class AbstractStatusBoard(ABC, BaseModel):
+    """Abstract class for upgrade policies
+    Used to create and delete upgrade policies in OCM."""
+
+    id: str | None
+    name: str
+    fullname: str
+    metadata: dict[str, Any] | None
+
+    @abstractmethod
+    def create(self, ocm: OCMBaseClient) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, ocm: OCMBaseClient) -> None:
+        pass
+
+    @abstractmethod
+    def summarize(self) -> str:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def get_priority() -> int:
+        pass
+
+
+class Product(AbstractStatusBoard):
+    applications: list["Application"] | None
+
+    def create(self, ocm: OCMBaseClient) -> None:
+        spec = self.dict(by_alias=True)
+        spec.pop("applications")
+        spec.pop("id")
+        self.id = create_product(ocm, spec)
+
+    def delete(self, ocm: OCMBaseClient) -> None:
+        if not self.id:
+            logging.error(f'Trying to delete Product "{self.name}" without id')
+            return
+        delete_product(ocm, self.id)
+
+    def summarize(self) -> str:
+        return f'Product: "{self.name}"'
+
+    @staticmethod
+    def get_priority() -> int:
+        return 0
+
+
+class Application(AbstractStatusBoard):
+    product: Optional["Product"]
+
+    def create(self, ocm: OCMBaseClient) -> None:
+        spec = self.dict(by_alias=True)
+        spec.pop("id")
+        product = spec.pop("product")
+        product_id = product.get("id")
+        if product_id:
+            spec["product"] = {"id": product_id}
+            self.id = create_application(ocm, spec)
+        else:
+            logging.warning("Missing product id for application")
+
+    def delete(self, ocm: OCMBaseClient) -> None:
+        if not self.id:
+            logging.error(f'Trying to delete Application "{self.name}" without id')
+            return
+        delete_application(ocm, self.id)
+
+    def summarize(self) -> str:
+        return f'Application: "{self.name}" "{self.fullname}"'
+
+    @staticmethod
+    def get_priority() -> int:
+        return 1
+
+
+class StatusBoardHandler(BaseModel):
+    action: str
+    status_board_object: AbstractStatusBoard
+
+    def act(self, dry_run: bool, ocm: OCMBaseClient) -> None:
+        logging.info(f"{self.action} - {self.status_board_object.summarize()}")
+        if dry_run:
+            return
+
+        match self.action:
+            case "delete":
+                self.status_board_object.delete(ocm)
+            case "create":
+                self.status_board_object.create(ocm)
+
+
+class StatusBoardExporterIntegration(QontractReconcileIntegration):
+    @property
+    def name(self) -> str:
+        return QONTRACT_INTEGRATION
+
+    @staticmethod
+    def get_product_apps(sb: StatusBoardV1) -> dict[str, set[str]]:
+        global_selectors = (
+            sb.global_app_selectors.exclude or [] if sb.global_app_selectors else []
+        )
+        return {
+            p.product_environment.product.name: get_selected_app_names(
+                global_selectors, p
+            )
+            for p in sb.products
+        }
+
+    @staticmethod
+    def get_current_products_applications(ocm_api: OCMBaseClient) -> list[Product]:
+        products_raw = get_managed_products(ocm_api)
+        products = [Product(**p) for p in products_raw]
+
+        for p in products:
+            if not p.id:
+                logging.error(f'Product "{p.name}" has no id')
+                continue
+            p.applications = [
+                Application(**a) for a in get_product_applications(ocm_api, p.id)
+            ]
+
+        return products
+
+    @staticmethod
+    def get_diff(
+        desired_product_apps: Mapping[str, set[str]],
+        current_products_applications: Iterable[Product],
+    ) -> list[StatusBoardHandler]:
+        def create_app(app_name: str, product: Product) -> Application:
+            return Application(
+                name=app_name,
+                fullname=f"{product.name}/{app_name}",
+                product=product,
+            )
+
+        return_list: list[StatusBoardHandler] = []
+        current_products = {p.name: p for p in current_products_applications}
+
+        current_as_mapping: Mapping[str, set[str]] = {
+            c.name: {a.name for a in c.applications or []}
+            for c in current_products_applications
+        }
+
+        diff_result = diff_mappings(
+            current_as_mapping,
+            desired_product_apps,
+        )
+
+        for product_name in diff_result.add:
+            product = Product(name=product_name, fullname=product_name, applications=[])
+            return_list.append(
+                StatusBoardHandler(
+                    action="create",
+                    status_board_object=product,
+                )
+            )
+            # new product, so it misses also the applications
+            for app_name in desired_product_apps[product_name]:
+                return_list.append(
+                    StatusBoardHandler(
+                        action="create",
+                        status_board_object=create_app(app_name, product),
+                    )
+                )
+
+        # existing product, only add/remove applications
+        for product_name, apps in diff_result.change.items():
+            product = current_products[product_name]
+            for app_name in apps.desired - apps.current:
+                return_list.append(
+                    StatusBoardHandler(
+                        action="create",
+                        status_board_object=create_app(app_name, product),
+                    )
+                )
+            to_delete = apps.current - apps.desired
+            for application in product.applications or []:
+                if application.name in to_delete:
+                    return_list.append(
+                        StatusBoardHandler(
+                            action="delete",
+                            status_board_object=application,
+                        )
+                    )
+
+        # product is deleted entirely
+        for product_name in diff_result.delete:
+            for application in current_products[product_name].applications or []:
+                return_list.append(
+                    StatusBoardHandler(action="delete", status_board_object=application)
+                )
+            return_list.append(
+                StatusBoardHandler(
+                    action="delete", status_board_object=current_products[product_name]
+                )
+            )
+        return return_list
+
+    @staticmethod
+    def apply_diff(
+        dry_run: bool, ocm_api: OCMBaseClient, diff: list[StatusBoardHandler]
+    ) -> None:
+        creations: list[StatusBoardHandler] = []
+        deletions: list[StatusBoardHandler] = []
+
+        for o in diff:
+            match o.action:
+                case "create":
+                    creations.append(o)
+                case "delete":
+                    deletions.append(o)
+
+        # Products need to be created before Applications
+        creations.sort(key=lambda x: x.status_board_object.get_priority())
+
+        # Applications need to be deleted before Products
+        deletions.sort(key=lambda x: x.status_board_object.get_priority(), reverse=True)
+
+        for d in creations + deletions:
+            d.act(dry_run, ocm_api)
+
+    def run(self, dry_run: bool) -> None:
+        # update cyclic reference
+        Product.update_forward_refs()
+
+        for sb in get_status_board():
+            ocm_api = init_ocm_base_client(sb.ocm, self.secret_reader)
+            desired_product_apps: dict[str, set[str]] = self.get_product_apps(sb)
+
+            current_products_applications = self.get_current_products_applications(
+                ocm_api
+            )
+
+            diff = self.get_diff(desired_product_apps, current_products_applications)
+
+            self.apply_diff(dry_run, ocm_api, diff)

reconcile/statuspage/__init__.py

@@ -1,5 +0,0 @@
-from reconcile.statuspage import atlassian
-from reconcile.statuspage.page import register_provider
-
-# Status page providers are registered here to prevent all kinds of cyclic imports.
-register_provider(atlassian.PROVIDER_NAME, atlassian.init_provider_for_page)

reconcile/statuspage/atlassian.py

@@ -1,24 +1,26 @@
 import logging
+import time
+from datetime import datetime
 from typing import (
     Any,
-    Optional,
-    Protocol,
+    Self,
 )
 
-import statuspageio  # type: ignore
+import requests
 from pydantic import BaseModel
+from requests import Response
+from sretoolbox.utils import retry
 
 from reconcile.gql_definitions.statuspage.statuspages import StatusPageV1
 from reconcile.statuspage.page import (
     StatusComponent,
+    StatusMaintenance,
+    StatusMaintenanceAnnouncement,
     StatusPage,
-    StatusPageProvider,
 )
 from reconcile.statuspage.state import ComponentBindingState
 from reconcile.statuspage.status import ManualStatusProvider
 
-PROVIDER_NAME = "atlassian"
-
 
 class AtlassianRawComponent(BaseModel):
     """
@@ -27,66 +29,118 @@ class AtlassianRawComponent(BaseModel):
 
     id: str
     name: str
-    description: Optional[str]
+    description: str | None
     position: int
     status: str
-    automation_email: Optional[str]
-    group_id: Optional[str]
-    group: Optional[bool]
+    automation_email: str | None
+    group_id: str | None
+    group: bool | None
 
 
-class AtlassianAPI(Protocol):
-    def list_components(self) -> list[AtlassianRawComponent]:
-        ...
+class AtlassianRawMaintenanceUpdate(BaseModel):
+    """
+    atlassian status page REST schema for maintenance updates
+    """
 
-    def update_component(self, id: str, data: dict[str, Any]) -> None:
-        ...
+    body: str
 
-    def create_component(self, data: dict[str, Any]) -> str:
-        ...
 
-    def delete_component(self, id: str) -> None:
-        ...
+class AtlassianRawMaintenance(BaseModel):
+    """
+    atlassian status page REST schema for maintenance
+    """
 
+    id: str
+    name: str
+    scheduled_for: str
+    scheduled_until: str
+    incident_updates: list[AtlassianRawMaintenanceUpdate]
+    components: list[AtlassianRawComponent]
+    auto_transition_deliver_notifications_at_end: bool | None
+    auto_transition_deliver_notifications_at_start: bool | None
+    scheduled_remind_prior: bool | None
 
-class LegacyLibAtlassianAPI:
+
+class AtlassianAPI:
     """
-    This API class wraps the statuspageio python library for basic component operations.
-    This class is named Legacy for a couple reasons:
-    * the underlying library is not maintained anymore
-    * the library has no type annotated
-    * the library does not support pagination which becomes important for this API
-    Therefore this lib will be replaced by a think wrapper based on uplink in an upcoming PR.
+    This API class wraps the statuspageio REST API for basic component operations.
     """
 
     def __init__(self, page_id: str, api_url: str, token: str):
         self.page_id = page_id
         self.api_url = api_url
         self.token = token
-        self._client = statuspageio.Client(
-            api_key=self.token, page_id=self.page_id, organization_id="unset"
+        self.auth_headers = {"Authorization": f"OAuth {self.token}"}
+
+    @retry(max_attempts=10)
+    def _do_get(self, url: str, params: dict[str, Any]) -> Response:
+        response = requests.get(
+            url, params=params, headers=self.auth_headers, timeout=30
         )
+        response.raise_for_status()
+        return response
+
+    def _list_items(self, url: str) -> list[Any]:
+        all_items: list[Any] = []
+        page = 1
+        per_page = 100
+        while True:
+            params = {"page": page, "per_page": per_page}
+            response = self._do_get(url, params=params)
+            items = response.json()
+            all_items += items
+            if len(items) < per_page:
+                break
+            page += 1
+            # https://developer.statuspage.io/#section/Rate-Limiting
+            # Each API token is limited to 1 request / second as measured on a 60 second rolling window
+            time.sleep(1)
+
+        return all_items
 
     def list_components(self) -> list[AtlassianRawComponent]:
-        return [
-            AtlassianRawComponent(
-                **c.toDict(),
-            )
-            for c in self._client.components.list()
-        ]
+        url = f"{self.api_url}/v1/pages/{self.page_id}/components"
+        all_components = self._list_items(url)
+        return [AtlassianRawComponent(**c) for c in all_components]
 
     def update_component(self, id: str, data: dict[str, Any]) -> None:
-        self._client.components.update(id, **data)
+        url = f"{self.api_url}/v1/pages/{self.page_id}/components/{id}"
+        requests.patch(
+            url, json={"component": data}, headers=self.auth_headers
+        ).raise_for_status()
 
     def create_component(self, data: dict[str, Any]) -> str:
-        result = self._client.components.create(**data)
-        return result["id"]
+        url = f"{self.api_url}/v1/pages/{self.page_id}/components"
+        response = requests.post(
+            url, json={"component": data}, headers=self.auth_headers
+        )
+        response.raise_for_status()
+        return response.json()["id"]
 
     def delete_component(self, id: str) -> None:
-        self._client.components.delete(id)
+        url = f"{self.api_url}/v1/pages/{self.page_id}/components/{id}"
+        requests.delete(url, headers=self.auth_headers).raise_for_status()
+
+    def list_scheduled_maintenances(self) -> list[AtlassianRawMaintenance]:
+        url = f"{self.api_url}/v1/pages/{self.page_id}/incidents/scheduled"
+        all_scheduled_incidents = self._list_items(url)
+        return [AtlassianRawMaintenance(**i) for i in all_scheduled_incidents]
+
+    def list_active_maintenances(self) -> list[AtlassianRawMaintenance]:
+        url = f"{self.api_url}/v1/pages/{self.page_id}/incidents/active_maintenance"
+        all_active_incidents = self._list_items(url)
+        return [AtlassianRawMaintenance(**i) for i in all_active_incidents]
+
+    def create_incident(self, data: dict[str, Any]) -> str:
+        url = f"{self.api_url}/v1/pages/{self.page_id}/incidents"
+        response = requests.post(
+            url, json={"incident": data}, headers=self.auth_headers
+        )
+        response.raise_for_status()
+        return response.json()["id"]
 
 
-class AtlassianStatusPageProvider(StatusPageProvider):
+class AtlassianStatusPageProvider:
     """
     The provider implements CRUD operations for Atlassian status pages.
     It also takes care of a mixed set of components on a page, where some
@@ -123,13 +177,13 @@ class AtlassianStatusPageProvider(StatusPageProvider):
         self._group_name_to_id = {g.name: g.id for g in self._components if g.group}
         self._group_id_to_name = {g.id: g.name for g in self._components if g.group}
 
-    def get_component_by_id(self, id: str) -> Optional[StatusComponent]:
+    def get_component_by_id(self, id: str) -> StatusComponent | None:
         raw = self.get_raw_component_by_id(id)
         if raw:
             return self._bound_raw_component_to_status_component(raw)
         return None
 
-    def get_raw_component_by_id(self, id: str) -> Optional[AtlassianRawComponent]:
+    def get_raw_component_by_id(self, id: str) -> AtlassianRawComponent | None:
         return self._components_by_id.get(id)
 
     def get_current_page(self) -> StatusPage:
@@ -146,34 +200,41 @@ class AtlassianStatusPageProvider(StatusPageProvider):
             components=[c for c in components if c is not None],
         )
 
+    def _raw_component_to_status_component(
+        self, raw_component: AtlassianRawComponent, name_override: str | None = None
+    ) -> StatusComponent:
+        group_name = (
+            self._group_id_to_name.get(raw_component.group_id)
+            if raw_component.group_id
+            else None
+        )
+        return StatusComponent(
+            name=name_override or raw_component.name,
+            display_name=raw_component.name,
+            description=raw_component.description,
+            group_name=group_name,
+            status_provider_configs=[
+                ManualStatusProvider(
+                    component_status=raw_component.status,
+                )
+            ],
+        )
+
     def _bound_raw_component_to_status_component(
         self, raw_component: AtlassianRawComponent
-    ) -> Optional[StatusComponent]:
+    ) -> StatusComponent | None:
         bound_component_name = self._binding_state.get_name_for_component_id(
             raw_component.id
         )
         if bound_component_name:
-            group_name = (
-                self._group_id_to_name.get(raw_component.group_id)
-                if raw_component.group_id
-                else None
-            )
-            return StatusComponent(
-                name=bound_component_name,
-                display_name=raw_component.name,
-                description=raw_component.description,
-                group_name=group_name,
-                status_provider_configs=[
-                    ManualStatusProvider(
-                        component_status=raw_component.status,
-                    )
-                ],
+            return self._raw_component_to_status_component(
+                raw_component, name_override=bound_component_name
             )
         return None
 
     def lookup_component(
         self, desired_component: StatusComponent
-    ) -> tuple[Optional[AtlassianRawComponent], bool]:
+    ) -> tuple[AtlassianRawComponent | None, bool]:
         """
         Finds the component on the page that matches the desired component. This
         is either done explicitely by using binding information if available or
@@ -207,7 +268,7 @@ class AtlassianStatusPageProvider(StatusPageProvider):
         return component, bound
 
     def should_apply(
-        self, desired: StatusComponent, current: Optional[AtlassianRawComponent]
+        self, desired: StatusComponent, current: AtlassianRawComponent | None
     ) -> bool:
         """
         Verifies if the desired component should be applied to the status page
@@ -240,8 +301,15 @@ class AtlassianStatusPageProvider(StatusPageProvider):
 
         # component status
         desired_component_status = desired.desired_component_status()
-        status_update_required = desired_component_status is not None and (
-            not current or desired_component_status != current.status
+        active_maintenance_affecting_component = [
+            m
+            for m in self.active_maintenances
+            if desired.display_name in [c.name for c in m.components]
+        ]
+        status_update_required = (
+            desired_component_status is not None
+            and (not current or desired_component_status != current.status)
+            and not active_maintenance_affecting_component
         )
 
         # shortcut execution if there is nothing to do
@@ -265,7 +333,7 @@ class AtlassianStatusPageProvider(StatusPageProvider):
                 component_id=current_component.id,
             )
 
-        # validte the component and check if the current state needs to be updated
+        # validate the component and check if the current state needs to be updated
         needs_update = self.should_apply(desired, current_component)
         if not needs_update:
             return
@@ -288,7 +356,13 @@ class AtlassianStatusPageProvider(StatusPageProvider):
         # resolve status
         desired_component_status = desired.desired_component_status()
         if desired_component_status:
-            component_update["status"] = desired_component_status
+            active_maintenance_affecting_component = [
+                m
+                for m in self.active_maintenances
+                if desired.display_name in [c.name for c in m.components]
+            ]
+            if not active_maintenance_affecting_component:
+                component_update["status"] = desired_component_status
 
         if current_component:
             logging.info(f"update component {desired.name}: {component_update}")
@@ -333,21 +407,86 @@ class AtlassianStatusPageProvider(StatusPageProvider):
         if not dry_run:
             self._binding_state.bind_component(component_name, component_id)
 
+    def _raw_maintenance_to_status_maintenance(
+        self,
+        raw_maintenance: AtlassianRawMaintenance,
+        name_override: str | None = None,
+    ) -> StatusMaintenance:
+        return StatusMaintenance(
+            name=name_override or raw_maintenance.name,
+            message=raw_maintenance.incident_updates[0].body,
+            schedule_start=datetime.fromisoformat(raw_maintenance.scheduled_for),
+            schedule_end=datetime.fromisoformat(raw_maintenance.scheduled_until),
+            components=[
+                self._raw_component_to_status_component(c)
+                for c in raw_maintenance.components
+            ],
+            announcements=StatusMaintenanceAnnouncement(
+                remind_subscribers=raw_maintenance.scheduled_remind_prior,
+                notify_subscribers_on_start=raw_maintenance.auto_transition_deliver_notifications_at_start,
+                notify_subscribers_on_completion=raw_maintenance.auto_transition_deliver_notifications_at_end,
+            ),
+        )
 
-def init_provider_for_page(
-    page: StatusPageV1,
-    token: str,
-    component_binding_state: ComponentBindingState,
-) -> AtlassianStatusPageProvider:
-    """
-    Initializes the provider for atlassian status page.
-    """
-    return AtlassianStatusPageProvider(
-        page_name=page.name,
-        api=LegacyLibAtlassianAPI(
-            page_id=page.page_id,
-            api_url=page.api_url,
-            token=token,
-        ),
-        component_binding_state=component_binding_state,
-    )
+    @classmethod
+    def init_from_page(
+        cls,
+        page: StatusPageV1,
+        token: str,
+        component_binding_state: ComponentBindingState,
+    ) -> Self:
+        """
+        Initializes the provider for atlassian status page.
+        """
+        return cls(
+            page_name=page.name,
+            api=AtlassianAPI(
+                page_id=page.page_id,
+                api_url=page.api_url,
+                token=token,
+            ),
+            component_binding_state=component_binding_state,
+        )
+
+    @property
+    def scheduled_maintenances(self) -> list[StatusMaintenance]:
+        return [
+            self._raw_maintenance_to_status_maintenance(m)
+            for m in self._api.list_scheduled_maintenances()
+        ]
+
+    @property
+    def active_maintenances(self) -> list[StatusMaintenance]:
+        return [
+            self._raw_maintenance_to_status_maintenance(m)
+            for m in self._api.list_active_maintenances()
+        ]
+
+    def create_maintenance(self, maintenance: StatusMaintenance) -> None:
+        component_ids: list[str] = []
+        for sc in maintenance.components:
+            current_component, _ = self.lookup_component(sc)
+            if current_component:
+                component_ids.append(current_component.id)
+        data = {
+            "name": maintenance.name,
+            "status": "scheduled",
+            "scheduled_for": maintenance.schedule_start.isoformat(),
+            "scheduled_until": maintenance.schedule_end.isoformat(),
+            "body": maintenance.message,
+            "scheduled_remind_prior": maintenance.announcements.remind_subscribers,
+            "scheduled_auto_transition": True,
+            "scheduled_auto_in_progress": True,
+            "scheduled_auto_completed": True,
+            "component_ids": component_ids,
+            "auto_transition_to_maintenance_state": True,
+            "auto_transition_to_operational_state": True,
+            "auto_transition_deliver_notifications_at_start": maintenance.announcements.notify_subscribers_on_start,
+            "auto_transition_deliver_notifications_at_end": maintenance.announcements.notify_subscribers_on_completion,
+        }
+        incident_id = self._api.create_incident(data)
+        self._bind_component(
+            dry_run=False,
+            component_name=maintenance.name,
+            component_id=incident_id,
+        )