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

reconcile/statuspage/integration.py

@@ -1,110 +1,22 @@
-import logging
-import sys
-from collections.abc import Callable
-
 from reconcile.gql_definitions.statuspage import statuspages
 from reconcile.gql_definitions.statuspage.statuspages import StatusPageV1
-from reconcile.statuspage.page import (
-    StatusPage,
-    StatusPageProvider,
-    build_status_page,
-    init_provider_for_page,
-)
 from reconcile.statuspage.state import S3ComponentBindingState
-from reconcile.typed_queries.app_interface_vault_settings import (
-    get_app_interface_vault_settings,
-)
 from reconcile.utils import gql
-from reconcile.utils.runtime.integration import (
-    NoParams,
-    QontractReconcileIntegration,
-)
 from reconcile.utils.secret_reader import (
     SecretReaderBase,
-    create_secret_reader,
 )
-from reconcile.utils.semver_helper import make_semver
-from reconcile.utils.state import (
-    State,
-    init_state,
-)
-
-QONTRACT_INTEGRATION = "status-page-components"
-QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
+from reconcile.utils.state import init_state
 
 
-def get_status_pages(query_func: Callable) -> list[StatusPageV1]:
-    return statuspages.query(query_func).status_pages or []
+def get_status_pages() -> list[StatusPageV1]:
+    return statuspages.query(gql.get_api().query).status_pages or []
 
 
-def get_state(secret_reader: SecretReaderBase) -> State:
-    return init_state(
-        integration=QONTRACT_INTEGRATION,
+def get_binding_state(
+    integration: str, secret_reader: SecretReaderBase
+) -> S3ComponentBindingState:
+    state = init_state(
+        integration=integration,
         secret_reader=secret_reader,
     )
-
-
-class StatusPageComponentsIntegration(QontractReconcileIntegration[NoParams]):
-    def __init__(self) -> None:
-        super().__init__(NoParams())
-
-    @property
-    def name(self) -> str:
-        return QONTRACT_INTEGRATION
-
-    def reconcile(
-        self,
-        dry_run: bool,
-        desired_state: StatusPage,
-        current_state: StatusPage,
-        provider: StatusPageProvider,
-    ) -> None:
-        """
-        Reconcile the desired state with the current state of a status page.
-        """
-        #
-        # D E L E T E
-        #
-        desired_component_names = {c.name for c in desired_state.components}
-        current_component_names = {c.name for c in current_state.components}
-        component_names_to_delete = current_component_names - desired_component_names
-        for component_name in component_names_to_delete:
-            logging.info(
-                f"delete component {component_name} from page {desired_state.name}"
-            )
-            provider.delete_component(dry_run, component_name)
-
-        #
-        # C R E A T E   OR   U P D A T E
-        #
-        for desired in desired_state.components:
-            provider.apply_component(dry_run, desired)
-
-    def run(self, dry_run: bool = False) -> None:
-        vault_settings = get_app_interface_vault_settings()
-        secret_reader = create_secret_reader(use_vault=vault_settings.vault)
-        with get_state(secret_reader) as state:
-            binding_state = S3ComponentBindingState(state)
-            pages = get_status_pages(query_func=gql.get_api().query)
-
-            error = False
-            for p in pages:
-                try:
-                    desired_state = build_status_page(p)
-                    page_provider = init_provider_for_page(
-                        page=p,
-                        token=secret_reader.read_secret(p.credentials),
-                        component_binding_state=binding_state,
-                    )
-                    self.reconcile(
-                        dry_run,
-                        desired_state=desired_state,
-                        current_state=page_provider.get_current_page(),
-                        provider=page_provider,
-                    )
-                except Exception:
-                    logging.exception(f"failed to reconcile statuspage {p.name}")
-                    error = True
-
-            if error:
-                sys.exit(1)
+    return S3ComponentBindingState(state)

reconcile/statuspage/integrations/components.py

@@ -0,0 +1,77 @@
+import logging
+import sys
+
+from reconcile.statuspage.atlassian import AtlassianStatusPageProvider
+from reconcile.statuspage.integration import get_binding_state, get_status_pages
+from reconcile.statuspage.page import StatusPage
+from reconcile.utils.runtime.integration import (
+    NoParams,
+    QontractReconcileIntegration,
+)
+from reconcile.utils.semver_helper import make_semver
+
+QONTRACT_INTEGRATION = "status-page-components"
+QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
+
+
+class StatusPageComponentsIntegration(QontractReconcileIntegration[NoParams]):
+    def __init__(self) -> None:
+        super().__init__(NoParams())
+
+    @property
+    def name(self) -> str:
+        return QONTRACT_INTEGRATION
+
+    def reconcile(
+        self,
+        dry_run: bool,
+        desired_state: StatusPage,
+        current_state: StatusPage,
+        provider: AtlassianStatusPageProvider,
+    ) -> None:
+        """
+        Reconcile the desired state with the current state of a status page.
+        """
+        #
+        # D E L E T E
+        #
+        desired_component_names = {c.name for c in desired_state.components}
+        current_component_names = {c.name for c in current_state.components}
+        component_names_to_delete = current_component_names - desired_component_names
+        for component_name in component_names_to_delete:
+            logging.info(
+                f"delete component {component_name} from page {desired_state.name}"
+            )
+            provider.delete_component(dry_run, component_name)
+
+        #
+        # C R E A T E   OR   U P D A T E
+        #
+        for desired in desired_state.components:
+            provider.apply_component(dry_run, desired)
+
+    def run(self, dry_run: bool = False) -> None:
+        binding_state = get_binding_state(self.name, self.secret_reader)
+        pages = get_status_pages()
+
+        error = False
+        for p in pages:
+            try:
+                desired_state = StatusPage.init_from_page(p)
+                page_provider = AtlassianStatusPageProvider.init_from_page(
+                    page=p,
+                    token=self.secret_reader.read_secret(p.credentials),
+                    component_binding_state=binding_state,
+                )
+                self.reconcile(
+                    dry_run,
+                    desired_state=desired_state,
+                    current_state=page_provider.get_current_page(),
+                    provider=page_provider,
+                )
+            except Exception:
+                logging.exception(f"failed to reconcile statuspage {p.name}")
+                error = True
+
+        if error:
+            sys.exit(1)

reconcile/statuspage/integrations/maintenances.py

@@ -0,0 +1,111 @@
+import logging
+import sys
+from datetime import UTC, datetime, timedelta
+
+from reconcile.slack_base import slackapi_from_queries
+from reconcile.statuspage.atlassian import AtlassianStatusPageProvider
+from reconcile.statuspage.integration import get_binding_state, get_status_pages
+from reconcile.statuspage.page import StatusMaintenance
+from reconcile.statuspage.state import S3ComponentBindingState
+from reconcile.utils.differ import diff_iterables
+from reconcile.utils.runtime.integration import (
+    NoParams,
+    QontractReconcileIntegration,
+)
+from reconcile.utils.semver_helper import make_semver
+
+QONTRACT_INTEGRATION = "status-page-maintenances"
+QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
+
+
+class StatusPageMaintenancesIntegration(QontractReconcileIntegration[NoParams]):
+    @property
+    def name(self) -> str:
+        return QONTRACT_INTEGRATION
+
+    def reconcile(
+        self,
+        dry_run: bool,
+        desired_state: list[StatusMaintenance],
+        current_state: list[StatusMaintenance],
+        provider: AtlassianStatusPageProvider,
+    ) -> None:
+        diff = diff_iterables(
+            current=current_state, desired=desired_state, key=lambda x: x.name
+        )
+        for a in diff.add.values():
+            logging.info(f"Create StatusPage Maintenance: {a.name}")
+            if not dry_run:
+                provider.create_maintenance(a)
+        for c in diff.change.values():
+            logging.warning(
+                f"Update StatusPage Maintenance is not supported at this time: {c.desired.name}"
+            )
+        for d in diff.delete.values():
+            logging.warning(
+                f"Delete StatusPage Maintenance is not supported at this time: {d.name}"
+            )
+
+    def notify(
+        self,
+        dry_run: bool,
+        desired_state: list[StatusMaintenance],
+        binding_state: S3ComponentBindingState,
+    ) -> None:
+        now = datetime.now(UTC)
+        slack = slackapi_from_queries(QONTRACT_INTEGRATION, init_usergroups=False)
+        for m in desired_state:
+            scheduled_start = m.schedule_start
+            if now <= scheduled_start <= now + timedelta(hours=1):
+                state_key = f"notifications/{m.name}"
+                if binding_state.state.exists(state_key):
+                    continue
+                logging.info(f"Notify StatusPage Maintenance: {m.name}")
+                if not dry_run:
+                    slack.chat_post_message(m.message)
+                    binding_state.state.add(f"notifications/{m.name}")
+
+    def run(self, dry_run: bool = False) -> None:
+        binding_state = get_binding_state(self.name, self.secret_reader)
+        pages = get_status_pages()
+        now = datetime.now(UTC)
+
+        error = False
+        for p in pages:
+            try:
+                desired_state = [
+                    StatusMaintenance.init_from_maintenance(
+                        m, page_components=p.components or []
+                    )
+                    for m in p.maintenances or []
+                    if datetime.fromisoformat(m.scheduled_start) > now
+                ]
+                desired_state = sorted(desired_state, key=lambda d: d.name)
+                page_provider = AtlassianStatusPageProvider.init_from_page(
+                    page=p,
+                    token=self.secret_reader.read_secret(p.credentials),
+                    component_binding_state=binding_state,
+                )
+                current_state = [
+                    m
+                    for m in page_provider.scheduled_maintenances
+                    if page_provider.has_component_binding_for(m.name)
+                ]
+                current_state = sorted(current_state, key=lambda c: c.name)
+                self.reconcile(
+                    dry_run=dry_run,
+                    desired_state=desired_state,
+                    current_state=current_state,
+                    provider=page_provider,
+                )
+                self.notify(
+                    dry_run=dry_run,
+                    desired_state=desired_state,
+                    binding_state=binding_state,
+                )
+            except Exception:
+                logging.exception(f"failed to reconcile statuspage {p.name}")
+                error = True
+
+        if error:
+            sys.exit(1)

reconcile/statuspage/page.py

@@ -1,34 +1,22 @@
-from abc import (
-    ABC,
-    abstractmethod,
-)
-from collections.abc import Callable
-from typing import Optional
+from datetime import datetime
+from typing import Self, cast
 
 from pydantic import BaseModel
 
+from reconcile.gql_definitions.maintenance.maintenances import (
+    MaintenanceStatuspageAnnouncementV1,
+)
 from reconcile.gql_definitions.statuspage.statuspages import (
+    MaintenanceV1,
     StatusPageComponentV1,
     StatusPageV1,
 )
-from reconcile.statuspage.state import ComponentBindingState
 from reconcile.statuspage.status import (
     StatusProvider,
     build_status_provider_config,
 )
 
-
-def build_status_page_component(component: StatusPageComponentV1) -> "StatusComponent":
-    status_configs = [
-        build_status_provider_config(cfg) for cfg in component.status_config or []
-    ]
-    return StatusComponent(
-        name=component.name,
-        display_name=component.display_name,
-        description=component.description,
-        group_name=component.group_name,
-        status_provider_configs=[c for c in status_configs if c is not None],
-    )
+PROVIDER_NAME = "statuspage"
 
 
 class StatusComponent(BaseModel):
@@ -38,8 +26,8 @@ class StatusComponent(BaseModel):
 
     name: str
     display_name: str
-    description: Optional[str]
-    group_name: Optional[str]
+    description: str | None
+    group_name: str | None
     status_provider_configs: list[StatusProvider]
     """
     Status provider configs hold different ways for a component to determine its status
@@ -52,7 +40,7 @@ class StatusComponent(BaseModel):
         """
         return bool(self.status_provider_configs)
 
-    def desired_component_status(self) -> Optional[str]:
+    def desired_component_status(self) -> str | None:
         if self.status_management_enabled():
             for provider in self.status_provider_configs:
                 status = provider.get_status()
@@ -64,50 +52,20 @@ class StatusComponent(BaseModel):
     class Config:
         arbitrary_types_allowed = True
 
-
-class StatusPageProvider(ABC):
-    """
-    Provider specific status page reconcile implementation.
-    """
-
-    @abstractmethod
-    def get_current_page(self) -> "StatusPage":
-        ...
-
-    @abstractmethod
-    def apply_component(self, dry_run: bool, desired: StatusComponent) -> None:
-        ...
-
-    @abstractmethod
-    def delete_component(self, dry_run: bool, component_name: str) -> None:
-        ...
-
-
-def build_status_page(
-    page: StatusPageV1,
-) -> "StatusPage":
-    """
-    Translate a desired state status page into a status page object.
-    """
-    return StatusPage(
-        name=page.name,
-        components=[
-            build_status_page_component(component=c) for c in page.components or []
-        ],
-    )
-
-
-def init_provider_for_page(
-    page: StatusPageV1,
-    token: str,
-    component_binding_state: ComponentBindingState,
-) -> StatusPageProvider:
-    """
-    Initialize a status page provider for a given status page.
-    """
-    if page.provider in _PROVIDERS:
-        return _PROVIDERS[page.provider](page, token, component_binding_state)
-    raise ValueError(f"provider {page.provider} is not supported")
+    @classmethod
+    def init_from_page_component(
+        cls, component: StatusPageComponentV1, name_override: str | None = None
+    ) -> Self:
+        status_configs = [
+            build_status_provider_config(cfg) for cfg in component.status_config or []
+        ]
+        return cls(
+            name=name_override or component.name,
+            display_name=component.display_name,
+            description=component.description,
+            group_name=component.group_name,
+            status_provider_configs=[c for c in status_configs if c is not None],
+        )
 
 
 class StatusPage(BaseModel):
@@ -127,13 +85,90 @@ class StatusPage(BaseModel):
     this desired state does. People can still manage components manually.
     """
 
+    @classmethod
+    def init_from_page(
+        cls,
+        page: StatusPageV1,
+    ) -> Self:
+        """
+        Translate a desired state status page into a status page object.
+        """
+        return cls(
+            name=page.name,
+            components=[
+                StatusComponent.init_from_page_component(component=c)
+                for c in page.components or []
+            ],
+        )
 
-ProviderInitializer = Callable[
-    [StatusPageV1, str, ComponentBindingState], StatusPageProvider
-]
 
-_PROVIDERS: dict[str, ProviderInitializer] = {}
+class StatusMaintenanceAnnouncement(BaseModel):
+    """
+    Represents the desired state of a status maintenance.
+    """
+
+    remind_subscribers: bool | None = None
+    notify_subscribers_on_start: bool | None = None
+    notify_subscribers_on_completion: bool | None = None
 
+    @classmethod
+    def init_from_announcement(
+        cls, announcement: MaintenanceStatuspageAnnouncementV1
+    ) -> Self:
+        return cls(
+            remind_subscribers=announcement.remind_subscribers,
+            notify_subscribers_on_start=announcement.notify_subscribers_on_start,
+            notify_subscribers_on_completion=announcement.notify_subscribers_on_completion,
+        )
 
-def register_provider(provider: str, provider_init: ProviderInitializer) -> None:
-    _PROVIDERS[provider] = provider_init
+
+class StatusMaintenance(BaseModel):
+    """
+    Represents the desired state of a status maintenance.
+    """
+
+    name: str
+    message: str
+    schedule_start: datetime
+    schedule_end: datetime
+    components: list[StatusComponent]
+    announcements: StatusMaintenanceAnnouncement
+
+    @classmethod
+    def init_from_maintenance(
+        cls,
+        maintenance: MaintenanceV1,
+        page_components: list[StatusPageComponentV1],
+    ) -> Self:
+        affected_services = [a.name for a in maintenance.affected_services]
+        affected_components = [
+            StatusComponent.init_from_page_component(c, name_override=c.display_name)
+            for c in page_components
+            if c.app.name in affected_services
+        ]
+        if not affected_components:
+            raise ValueError(
+                f"No StatusPage component found for maintenance '{maintenance.name}'"
+                f"via apps {affected_services}. Please define at least one StatusPage component."
+            )
+
+        statuspage_announcements = [
+            StatusMaintenanceAnnouncement.init_from_announcement(
+                cast(MaintenanceStatuspageAnnouncementV1, m)
+            )
+            for m in maintenance.announcements or []
+            if m.provider == PROVIDER_NAME
+        ]
+        if len(statuspage_announcements) != 1:
+            raise ValueError(
+                f"Maintenance announcements must include exactly one item of provider {PROVIDER_NAME}"
+            )
+
+        return cls(
+            name=maintenance.name,
+            message=maintenance.message.rstrip("\n"),
+            schedule_start=maintenance.scheduled_start,
+            schedule_end=maintenance.scheduled_end,
+            components=affected_components,
+            announcements=statuspage_announcements[0],
+        )

reconcile/statuspage/state.py

@@ -1,5 +1,4 @@
 from typing import (
-    Optional,
     Protocol,
 )
 
@@ -13,17 +12,13 @@ from reconcile.utils.state import State
 
 
 class ComponentBindingState(Protocol):
-    def get_id_for_component_name(self, component_name: str) -> Optional[str]:
-        ...
+    def get_id_for_component_name(self, component_name: str) -> str | None: ...
 
-    def get_name_for_component_id(self, component_id: str) -> Optional[str]:
-        ...
+    def get_name_for_component_id(self, component_id: str) -> str | None: ...
 
-    def bind_component(self, component_name: str, component_id: str) -> None:
-        ...
+    def bind_component(self, component_name: str, component_id: str) -> None: ...
 
-    def forget_component(self, component_name: str) -> None:
-        ...
+    def forget_component(self, component_name: str) -> None: ...
 
 
 class S3ComponentBindingState(ComponentBindingState):
@@ -37,10 +32,10 @@ class S3ComponentBindingState(ComponentBindingState):
             v: k for k, v in self.name_to_id_cache.items()
         }
 
-    def get_id_for_component_name(self, component_name: str) -> Optional[str]:
+    def get_id_for_component_name(self, component_name: str) -> str | None:
         return self.name_to_id_cache.get(component_name)
 
-    def get_name_for_component_id(self, component_id: str) -> Optional[str]:
+    def get_name_for_component_id(self, component_id: str) -> str | None:
         return self.id_to_name_cache.get(component_id)
 
     def bind_component(self, component_name: str, component_id: str) -> None:

reconcile/statuspage/status.py

@@ -3,10 +3,9 @@ from abc import (
     abstractmethod,
 )
 from datetime import (
+    UTC,
     datetime,
-    timezone,
 )
-from typing import Optional
 
 from dateutil.parser import isoparse
 from pydantic import BaseModel
@@ -28,8 +27,7 @@ class StatusProvider(ABC):
     """
 
     @abstractmethod
-    def get_status(self) -> Optional[str]:
-        ...
+    def get_status(self) -> str | None: ...
 
 
 class ManualStatusProvider(StatusProvider, BaseModel):
@@ -39,13 +37,13 @@ class ManualStatusProvider(StatusProvider, BaseModel):
     the component.
     """
 
-    start: Optional[datetime] = None
+    start: datetime | None = None
     """
     The optional start time of the time window in which the manually
     defined status is active.
     """
 
-    end: Optional[datetime] = None
+    end: datetime | None = None
     """
     The optional end time of the time window in which the manually
     defined status is active.
@@ -57,7 +55,7 @@ class ManualStatusProvider(StatusProvider, BaseModel):
     time window is active or if no time window is defined.
     """
 
-    def get_status(self) -> Optional[str]:
+    def get_status(self) -> str | None:
         if self._is_active():
             return self.component_status
         return None
@@ -72,17 +70,15 @@ class ManualStatusProvider(StatusProvider, BaseModel):
             raise ValueError(
                 "manual component status time window is invalid: end before start"
             )
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         if self.start and now < self.start:
             return False
-        if self.end and self.end < now:
-            return False
-        return True
+        return not (self.end and self.end < now)
 
 
 def build_status_provider_config(
     cfg: StatusProviderV1,
-) -> Optional[StatusProvider]:
+) -> StatusProvider | None:
     """
     Translates a status provider config from the desired state into
     provider specific implementation that provides the status resolution logic.