qontract-reconcile 0.10.1rc801__py3-none-any.whl → 0.10.1rc803__py3-none-any.whl

{qontract_reconcile-0.10.1rc801.dist-info → qontract_reconcile-0.10.1rc803.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qontract-reconcile
-Version: 0.10.1rc801
+Version: 0.10.1rc803
 Summary: Collection of tools to reconcile services with their desired state as defined in the app-interface DB.
 Home-page: https://github.com/app-sre/qontract-reconcile
 Author: Red Hat App-SRE Team

{qontract_reconcile-0.10.1rc801.dist-info → qontract_reconcile-0.10.1rc803.dist-info}/RECORD

@@ -260,6 +260,7 @@ reconcile/gql_definitions/common/state_aws_account.py,sha256=LAdpCG2-ykVpWBPO0Zu
 reconcile/gql_definitions/common/users.py,sha256=uDiEDqa4QP89I2oFuKhCtVB61ZviIt7Y75fgrcCm7M4,1681
 reconcile/gql_definitions/cost_report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reconcile/gql_definitions/cost_report/app_names.py,sha256=fzqYXyiTSll359J1F1o7qapco0MSxgs3sr_Ssb2Kbns,1786
+reconcile/gql_definitions/cost_report/cost_namespaces.py,sha256=wV76J8Ynq0ObSfjSZQRLmCPUZ96frGc82Z5HPM_e4F4,2219
 reconcile/gql_definitions/cost_report/settings.py,sha256=0nhBDJ5MZ1m7XkNDGrRLmsnUbzqZ4WRh_DDEEzKhcxU,2153
 reconcile/gql_definitions/dashdotdb_slo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reconcile/gql_definitions/dashdotdb_slo/slo_documents_query.py,sha256=zUa-CmpOwiymVmOV6KwDHH5mMl06p000320FcOas6hU,4315
@@ -432,6 +433,15 @@ reconcile/skupper_network/integration.py,sha256=178Q9RSYuZ9NmrCK4jRMLMekrewUaaRd
 reconcile/skupper_network/models.py,sha256=DNTI7HZv-rqY42GIIxyRuvroHLvdH6rJerjIq9lj3RU,6663
 reconcile/skupper_network/reconciler.py,sha256=XS-1oKBr_1l3dYUAVqUH6gCHg1G5ZuOfY_7fgGVAiFA,9996
 reconcile/skupper_network/site_controller.py,sha256=A3K-62BjJ5HiFVydV0ouGoD1NwrO7XhAH15BHAcS9fk,1550
+reconcile/statuspage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reconcile/statuspage/atlassian.py,sha256=m8tRECVD_9KnIvqWs6pUocAnmfj2w_eDTFE4il7hkH8,15335
+reconcile/statuspage/integration.py,sha256=hsazrQMceJbr61nEkJLxJbHhudTGtFuH0mlCo66-2ug,711
+reconcile/statuspage/page.py,sha256=DB69C6yAfwZIdo4HBQi8BTUZXL8l9yOPnjnt3k_HZgk,3177
+reconcile/statuspage/state.py,sha256=HD9EOoKm_nEqCMLIwW809En3cq5VhyzKJPUbsh-bae8,1617
+reconcile/statuspage/status.py,sha256=mfRJ_tW7jM4_Vy_1cc8C0fKJEoA2GwrA3gJeV1KImAw,2834
+reconcile/statuspage/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reconcile/statuspage/integrations/components.py,sha256=49KHd_E9AdRvcEA6n75q1McZv2LfN-hRsW-WA7dgw9g,2651
+reconcile/statuspage/integrations/maintenances.py,sha256=pwt3WHymfkqP7ox1GB-D6Wn0crmcrDE_p4SW9wRaqWE,2651
 reconcile/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reconcile/templates/aws_access_key_email.j2,sha256=2MUr1ERmyISzKgHqsWYLd-1Wbl-peUa-FsGUS-JLUFc,238
 reconcile/templates/email.yml.j2,sha256=OZgczNRgXPj2gVYTgwQyHAQrMGu7xp-e4W1rX19GcrU,690
@@ -584,6 +594,7 @@ reconcile/typed_queries/app_interface_metrics_exporter/__init__.py,sha256=47DEQp
 reconcile/typed_queries/app_interface_metrics_exporter/onboarding_status.py,sha256=X-N1WJGOL6OR9940P0_K4-YJzkL5Vg4favhYrBxXD9A,327
 reconcile/typed_queries/cost_report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reconcile/typed_queries/cost_report/app_names.py,sha256=HMEMIqAbMyVQfoQ5YXTXE4xDt7FaXBRz0QIHnsIZC1c,478
+reconcile/typed_queries/cost_report/cost_namespaces.py,sha256=VXIqdGE5lwa5z4UTROEsuc3QdxgodRgXglei0LJI2Co,985
 reconcile/typed_queries/cost_report/settings.py,sha256=xbTMMUQnbub2pav4B-ctzzRe7ijjTv2bqfqdtb9OnO0,589
 reconcile/typed_queries/terraform_tgw_attachments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reconcile/typed_queries/terraform_tgw_attachments/aws_accounts.py,sha256=T5HSeyBcGKP-LzDmIzs-WlBwOtSenYpm0Odw5--xdOg,410
@@ -766,26 +777,28 @@ tools/app_interface_metrics_exporter.py,sha256=zkwkxdAUAxjdc-pzx2_oJXG25fo0Fnyd5
 tools/app_interface_reporter.py,sha256=upA-J-n-HXHKVDINRuMR7vTt-iJvQORKUVi9D3leQto,17738
 tools/glitchtip_access_reporter.py,sha256=oPBnk_YoDuljU3v0FaChzOwwnk4vap1xEE67QEjzdqs,2948
 tools/glitchtip_access_revalidation.py,sha256=8kbBJk04mkq28kWoRDDkfCGIF3GRg3pJrFAh1sW0dbk,2821
-tools/qontract_cli.py,sha256=MtuyVLlAFq9e8cbUqx2uOecXbnG01GVA_hqV79qUiGc,114628
+tools/qontract_cli.py,sha256=GduWl9WzfSmOmWjZfyoyR9U6oP8uf8ckF0iHf78tHvE,114858
 tools/sd_app_sre_alert_report.py,sha256=e9vAdyenUz2f5c8-z-5WY0wv-SJ9aePKDH2r4IwB6pc,5063
 tools/template_validation.py,sha256=-U-lTGeLaci8yWPEblCJeev2DOlY1jM9QOOh-O1zts8,3376
 tools/cli_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tools/cli_commands/gpg_encrypt.py,sha256=w8hl4jIEWk5wKbEFN6fVEOwUJGmdlvOqYodW3XSN7mU,4978
 tools/cli_commands/cost_report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tools/cli_commands/cost_report/command.py,sha256=ecT4SjCwhoWNFF9Xb1spqYzI7QMwX9EFWz6XFSW4bas,6317
-tools/cli_commands/cost_report/cost_management_api.py,sha256=o-qz-ykT7R6pMjrLVl030W7JuYAYSCdOXTO4B06aV3s,1771
-tools/cli_commands/cost_report/model.py,sha256=blNk52T6KIDy-7w4V6qvZhGFWplxgDfZ5jRZimPDYJo,593
-tools/cli_commands/cost_report/response.py,sha256=lOmIohSuwJBxoSAC9LCwihBsyWgutHCIW-nvd6_HX5Y,867
-tools/cli_commands/cost_report/view.py,sha256=2a6LOuUEbFQYw57Mkc3R2onLOT3oObizHtKFyj9stMU,8558
+tools/cli_commands/cost_report/aws.py,sha256=bdvbT3bDymBOMx4Ve4kt154MeGiGusTSpOpMMFrQ4SM,5191
+tools/cli_commands/cost_report/cost_management_api.py,sha256=tFzjaZ3RSVJeAUsfSWXHiQlMVbV8dFcXibK158ODQcA,2549
+tools/cli_commands/cost_report/model.py,sha256=KGkro82zoFXLmfQ4nv7dkv4QoNtOF-k6PT6VURCLZKE,548
+tools/cli_commands/cost_report/openshift.py,sha256=XNEJpgtIQAi3Eoej1Btnl74IWg3g-gLh6W36WOwQ9bk,6188
+tools/cli_commands/cost_report/response.py,sha256=_kbpBSjMjbPXGkjDgidTOLvFpVqfBo3VMkSOheUdmMA,1308
+tools/cli_commands/cost_report/util.py,sha256=r4K8nC1S0YZNSUNro141cYG1nuG8HwkkYEqWV9GCvu8,1861
+tools/cli_commands/cost_report/view.py,sha256=pKM6LDeWZJcTw2a7sWBwKSuR9p3SAk3lEb37uwMhlLw,10183
 tools/sre_checkpoints/__init__.py,sha256=CDaDaywJnmRCLyl_NCcvxi-Zc0hTi_3OdwKiFOyS39I,145
 tools/sre_checkpoints/util.py,sha256=zEDbGr18ZeHNQwW8pUsr2JRjuXIPz--WAGJxZo9sv_Y,894
 tools/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tools/test/test_app_interface_metrics_exporter.py,sha256=SX7qL3D1SIRKFo95FoQztvftCWEEf-g1mfXOtgCog-g,1271
-tools/test/test_qontract_cli.py,sha256=w2l4BHB09k1d-BGJ1jBUNCqDv7zkqYrMHojQXg-21kQ,4155
+tools/test/test_qontract_cli.py,sha256=_D61RFGAN5x44CY1tYbouhlGXXABwYfxKSWSQx3Jrss,4941
 tools/test/test_sd_app_sre_alert_report.py,sha256=v363r9zM7__0kR5K6mvJoGFcM9BvE33fWAayrqkpojA,2116
 tools/test/test_sre_checkpoints.py,sha256=SKqPPTl9ua0RFdSSofnoQX-JZE6dFLO3LRhfQzqtfh8,2607
-qontract_reconcile-0.10.1rc801.dist-info/METADATA,sha256=OdsfVh3qLjKCXC75ElYhLLDgte17zsyQpsrpG9zaxtI,2314
-qontract_reconcile-0.10.1rc801.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-qontract_reconcile-0.10.1rc801.dist-info/entry_points.txt,sha256=rIxI5zWtHNlfpDeq1a7pZXAPoqf7HG32KMTN3MeWK_8,429
-qontract_reconcile-0.10.1rc801.dist-info/top_level.txt,sha256=l5ISPoXzt0SdR4jVdkfa7RPSKNc8zAHYWAnR-Dw8Ey8,24
-qontract_reconcile-0.10.1rc801.dist-info/RECORD,,
+qontract_reconcile-0.10.1rc803.dist-info/METADATA,sha256=NTfgWm43JS7pKaeQtl4uuf73kEQxGqfhtxg1alCle_E,2314
+qontract_reconcile-0.10.1rc803.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+qontract_reconcile-0.10.1rc803.dist-info/entry_points.txt,sha256=rIxI5zWtHNlfpDeq1a7pZXAPoqf7HG32KMTN3MeWK_8,429
+qontract_reconcile-0.10.1rc803.dist-info/top_level.txt,sha256=l5ISPoXzt0SdR4jVdkfa7RPSKNc8zAHYWAnR-Dw8Ey8,24
+qontract_reconcile-0.10.1rc803.dist-info/RECORD,,

reconcile/gql_definitions/cost_report/cost_namespaces.py

@@ -0,0 +1,84 @@
+"""
+Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
+"""
+from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
+from datetime import datetime  # noqa: F401 # pylint: disable=W0611
+from enum import Enum  # noqa: F401 # pylint: disable=W0611
+from typing import (  # noqa: F401 # pylint: disable=W0611
+    Any,
+    Optional,
+    Union,
+)
+
+from pydantic import (  # noqa: F401 # pylint: disable=W0611
+    BaseModel,
+    Extra,
+    Field,
+    Json,
+)
+
+
+DEFINITION = """
+query CostNamespaces($filter: JSON) {
+  namespaces: namespaces_v1(filter: $filter) {
+    name
+    app {
+      name
+    }
+    cluster {
+      name
+      spec {
+        external_id
+      }
+    }
+  }
+}
+"""
+
+
+class ConfiguredBaseModel(BaseModel):
+    class Config:
+        smart_union=True
+        extra=Extra.forbid
+
+
+class AppV1(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+
+
+class ClusterSpecV1(ConfiguredBaseModel):
+    external_id: Optional[str] = Field(..., alias="external_id")
+
+
+class ClusterV1(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+    spec: Optional[ClusterSpecV1] = Field(..., alias="spec")
+
+
+class NamespaceV1(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+    app: AppV1 = Field(..., alias="app")
+    cluster: ClusterV1 = Field(..., alias="cluster")
+
+
+class CostNamespacesQueryData(ConfiguredBaseModel):
+    namespaces: Optional[list[NamespaceV1]] = Field(..., alias="namespaces")
+
+
+def query(query_func: Callable, **kwargs: Any) -> CostNamespacesQueryData:
+    """
+    This is a convenience function which queries and parses the data into
+    concrete types. It should be compatible with most GQL clients.
+    You do not have to use it to consume the generated data classes.
+    Alternatively, you can also mime and alternate the behavior
+    of this function in the caller.
+
+    Parameters:
+        query_func (Callable): Function which queries your GQL Server
+        kwargs: optional arguments that will be passed to the query function
+
+    Returns:
+        CostNamespacesQueryData: queried data parsed into generated classes
+    """
+    raw_data: dict[Any, Any] = query_func(DEFINITION, **kwargs)
+    return CostNamespacesQueryData(**raw_data)

reconcile/statuspage/atlassian.py

@@ -0,0 +1,425 @@
+import logging
+import time
+from typing import (
+    Any,
+    Optional,
+    Self,
+)
+
+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,
+    StatusPage,
+)
+from reconcile.statuspage.state import ComponentBindingState
+from reconcile.statuspage.status import ManualStatusProvider
+
+
+class AtlassianRawComponent(BaseModel):
+    """
+    atlassian status page REST schema for component
+    """
+
+    id: str
+    name: str
+    description: Optional[str]
+    position: int
+    status: str
+    automation_email: Optional[str]
+    group_id: Optional[str]
+    group: Optional[bool]
+
+
+class AtlassianRawMaintenanceUpdate(BaseModel):
+    """
+    atlassian status page REST schema for maintenance updates
+    """
+
+    body: str
+
+
+class AtlassianRawMaintenance(BaseModel):
+    """
+    atlassian status page REST schema for maintenance
+    """
+
+    id: str
+    name: str
+    scheduled_for: str
+    scheduled_until: str
+    incident_updates: list[AtlassianRawMaintenanceUpdate]
+
+
+class AtlassianAPI:
+    """
+    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.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]:
+        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:
+        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:
+        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:
+        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 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:
+    """
+    The provider implements CRUD operations for Atlassian status pages.
+    It also takes care of a mixed set of components on a page, where some
+    components are managed by app-interface and some are managed manually
+    by various teams. The term `bound` used throughout the code refers to
+    components that are managed by app-interface. The binding status is
+    managed by the injected `ComponentBindingState` instance and persists
+    the binding information (what app-interface component name is bound to
+    what status page component id).
+    """
+
+    def __init__(
+        self,
+        page_name: str,
+        api: AtlassianAPI,
+        component_binding_state: ComponentBindingState,
+    ):
+        self.page_name = page_name
+        self._api = api
+        self._binding_state = component_binding_state
+
+        # component cache
+        self._components: list[AtlassianRawComponent] = []
+        self._components_by_id: dict[str, AtlassianRawComponent] = {}
+        self._components_by_displayname: dict[str, AtlassianRawComponent] = {}
+        self._group_name_to_id: dict[str, str] = {}
+        self._group_id_to_name: dict[str, str] = {}
+        self._build_component_cache()
+
+    def _build_component_cache(self):
+        self._components = self._api.list_components()
+        self._components_by_id = {c.id: c for c in self._components}
+        self._components_by_displayname = {c.name: c for c in self._components}
+        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]:
+        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]:
+        return self._components_by_id.get(id)
+
+    def get_current_page(self) -> StatusPage:
+        """
+        Builds a StatusPage instance from the current state of the page. This
+        way the current state of the page can be compared to the desired state
+        of the page coming from GQL.
+        """
+        components = [
+            self._bound_raw_component_to_status_component(c) for c in self._components
+        ]
+        return StatusPage(
+            name=self.page_name,
+            components=[c for c in components if c is not None],
+        )
+
+    def _bound_raw_component_to_status_component(
+        self, raw_component: AtlassianRawComponent
+    ) -> Optional[StatusComponent]:
+        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 None
+
+    def lookup_component(
+        self, desired_component: StatusComponent
+    ) -> tuple[Optional[AtlassianRawComponent], bool]:
+        """
+        Finds the component on the page that matches the desired component. This
+        is either done explicitely by using binding information if available or
+        by using the display name of the desired component to find a matching
+        component on the page. This way, this provider offers adoption logic
+        for existing components on the page that are not yes bound to app-interface.
+        """
+        component_id = self._binding_state.get_id_for_component_name(
+            desired_component.name
+        )
+        component = None
+        bound = True
+        if component_id:
+            component = self.get_raw_component_by_id(component_id)
+
+        if component is None:
+            bound = False
+            # either the component name is not bound to an ID or for whatever
+            # reason or the component is not found on the page anymore
+            component = self._components_by_displayname.get(
+                desired_component.display_name
+            )
+            if component and self._binding_state.get_name_for_component_id(
+                component.id
+            ):
+                # this component is already bound to a different component
+                # in app-interface. we are protecting this binding here by
+                # not allowing this component to be found via display name
+                component = None
+
+        return component, bound
+
+    def should_apply(
+        self, desired: StatusComponent, current: Optional[AtlassianRawComponent]
+    ) -> bool:
+        """
+        Verifies if the desired component should be applied to the status page
+        when compared to the current state of the component on the page.
+        """
+        current_group_name = (
+            self._group_id_to_name.get(current.group_id)
+            if current and current.group_id
+            else None
+        )
+
+        # check if group exists
+        group_id = None
+        if desired.group_name:
+            group_id = self._group_name_to_id.get(desired.group_name, None)
+            if not group_id:
+                raise ValueError(
+                    f"Group {desired.group_name} referenced "
+                    f"by {desired.name} does not exist"
+                )
+
+        # Special handling if a component needs to be moved out of any grouping.
+        # We would need to use the component_group endpoint but for not lets
+        # ignore this situation.
+        if current and current_group_name and not desired.group_name:
+            raise ValueError(
+                f"Remove grouping from the component "
+                f"{desired.group_name} is currently unsupported"
+            )
+
+        # 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
+        )
+
+        # shortcut execution if there is nothing to do
+        update_required = (
+            current is None
+            or desired.display_name != current.name
+            or desired.description != current.description
+            or desired.group_name != current_group_name
+            or status_update_required
+        )
+        return update_required
+
+    def apply_component(self, dry_run: bool, desired: StatusComponent) -> None:
+        current_component, bound = self.lookup_component(desired)
+
+        # if the component is not yet bound to a statuspage component, bind it now
+        if current_component and not bound:
+            self._bind_component(
+                dry_run=dry_run,
+                component_name=desired.name,
+                component_id=current_component.id,
+            )
+
+        # validte 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
+
+        # calculate update
+        component_update = {
+            "name": desired.display_name,
+            "description": desired.description,
+        }
+
+        # resolve group
+        group_id = (
+            self._group_name_to_id.get(desired.group_name, None)
+            if desired.group_name
+            else None
+        )
+        if group_id:
+            component_update["group_id"] = group_id
+
+        # resolve status
+        desired_component_status = desired.desired_component_status()
+        if desired_component_status:
+            component_update["status"] = desired_component_status
+
+        if current_component:
+            logging.info(f"update component {desired.name}: {component_update}")
+            if not dry_run:
+                self._api.update_component(current_component.id, component_update)
+        else:
+            logging.info(f"create component {desired.name}: {component_update}")
+            if not dry_run:
+                component_id = self._api.create_component(component_update)
+                self._bind_component(
+                    dry_run=dry_run,
+                    component_name=desired.name,
+                    component_id=component_id,
+                )
+
+    def delete_component(self, dry_run: bool, component_name: str) -> None:
+        component_id = self._binding_state.get_id_for_component_name(component_name)
+        if component_id:
+            if not dry_run:
+                self._api.delete_component(component_id)
+                self._binding_state.forget_component(component_name)
+                self._build_component_cache()
+        else:
+            logging.warning(
+                f"can't delete component {component_name} because it is not "
+                f"bound to any component on page {self.page_name}"
+            )
+
+    def has_component_binding_for(self, component_name: str) -> bool:
+        return self._binding_state.get_id_for_component_name(component_name) is not None
+
+    def _bind_component(
+        self,
+        dry_run: bool,
+        component_name: str,
+        component_id: str,
+    ) -> None:
+        logging.info(
+            f"bind component {component_name} to ID {component_id} "
+            f"on page {self.page_name}"
+        )
+        if not dry_run:
+            self._binding_state.bind_component(component_name, component_id)
+
+    @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 maintenances(self) -> list[StatusMaintenance]:
+        return [
+            StatusMaintenance(
+                name=m.name,
+                message=m.incident_updates[0].body,
+                schedule_start=m.scheduled_for,
+                schedule_end=m.scheduled_until,
+            )
+            for m in self._api.list_scheduled_maintenances()
+        ]
+
+    def create_maintenance(self, maintenance: StatusMaintenance) -> None:
+        data = {
+            "name": maintenance.name,
+            "status": "scheduled",
+            "scheduled_for": maintenance.schedule_start,
+            "scheduled_until": maintenance.schedule_end,
+            "body": maintenance.message,
+        }
+        incident_id = self._api.create_incident(data)
+        self._bind_component(
+            dry_run=False,
+            component_name=maintenance.name,
+            component_id=incident_id,
+        )

reconcile/statuspage/integration.py

@@ -0,0 +1,22 @@
+from reconcile.gql_definitions.statuspage import statuspages
+from reconcile.gql_definitions.statuspage.statuspages import StatusPageV1
+from reconcile.statuspage.state import S3ComponentBindingState
+from reconcile.utils import gql
+from reconcile.utils.secret_reader import (
+    SecretReaderBase,
+)
+from reconcile.utils.state import init_state
+
+
+def get_status_pages() -> list[StatusPageV1]:
+    return statuspages.query(gql.get_api().query).status_pages or []
+
+
+def get_binding_state(
+    integration: str, secret_reader: SecretReaderBase
+) -> S3ComponentBindingState:
+    state = init_state(
+        integration=integration,
+        secret_reader=secret_reader,
+    )
+    return S3ComponentBindingState(state)