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

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,73 @@
+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 StatusMaintenance
+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():
+            raise NotImplementedError(
+                f"Update StatusPage Maintenance is not supported at this time: {c.desired.name}"
+            )
+        for d in diff.delete.values():
+            raise NotImplementedError(
+                f"Delete StatusPage Maintenance is not supported at this time: {d.name}"
+            )
+
+    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 = [
+                    StatusMaintenance.init_from_maintenance(m)
+                    for m in p.maintenances or []
+                ]
+                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=dry_run,
+                    desired_state=desired_state,
+                    current_state=page_provider.maintenances,
+                    provider=page_provider,
+                )
+            except Exception:
+                logging.exception(f"failed to reconcile statuspage {p.name}")
+                error = True
+
+        if error:
+            sys.exit(1)

reconcile/statuspage/page.py

@@ -0,0 +1,114 @@
+from typing import Optional, Self
+
+from pydantic import BaseModel
+
+from reconcile.gql_definitions.statuspage.statuspages import (
+    MaintenanceV1,
+    StatusPageComponentV1,
+    StatusPageV1,
+)
+from reconcile.statuspage.status import (
+    StatusProvider,
+    build_status_provider_config,
+)
+
+
+class StatusComponent(BaseModel):
+    """
+    Represents a status page component from the desired state.
+    """
+
+    name: str
+    display_name: str
+    description: Optional[str]
+    group_name: Optional[str]
+    status_provider_configs: list[StatusProvider]
+    """
+    Status provider configs hold different ways for a component to determine its status
+    """
+
+    def status_management_enabled(self) -> bool:
+        """
+        Determines if this component has any status configurations available for
+        it to be able to manage its status.
+        """
+        return bool(self.status_provider_configs)
+
+    def desired_component_status(self) -> Optional[str]:
+        if self.status_management_enabled():
+            for provider in self.status_provider_configs:
+                status = provider.get_status()
+                if status:
+                    return status
+            return "operational"
+        return None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @classmethod
+    def init_from_page_component(cls, component: StatusPageComponentV1) -> Self:
+        status_configs = [
+            build_status_provider_config(cfg) for cfg in component.status_config or []
+        ]
+        return cls(
+            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],
+        )
+
+
+class StatusPage(BaseModel):
+    """
+    Represents the desired state of a status page and its components.
+    """
+
+    name: str
+    """
+    The name of the status page.
+    """
+
+    components: list[StatusComponent]
+    """
+    The desired components of the status page are represented in this list.
+    Important note: the actual status page might have more components than
+    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 []
+            ],
+        )
+
+
+class StatusMaintenance(BaseModel):
+    """
+    Represents the desired state of a status maintenance.
+    """
+
+    name: str
+    message: str
+    schedule_start: str
+    schedule_end: str
+
+    @classmethod
+    def init_from_maintenance(cls, maintenance: MaintenanceV1) -> Self:
+        return cls(
+            name=maintenance.name,
+            message=maintenance.message.rstrip("\n"),
+            schedule_start=maintenance.scheduled_start,
+            schedule_end=maintenance.scheduled_end,
+        )

reconcile/statuspage/state.py

@@ -0,0 +1,47 @@
+from typing import (
+    Optional,
+    Protocol,
+)
+
+from reconcile.utils.state import State
+
+# This module manages the binding state of components in the desired state
+# and their representation on an actual status page.
+#
+# This state management is required to map component identities between app-interface
+# and the status page provider.
+
+
+class ComponentBindingState(Protocol):
+    def get_id_for_component_name(self, component_name: str) -> Optional[str]: ...
+
+    def get_name_for_component_id(self, component_id: str) -> Optional[str]: ...
+
+    def bind_component(self, component_name: str, component_id: str) -> None: ...
+
+    def forget_component(self, component_name: str) -> None: ...
+
+
+class S3ComponentBindingState(ComponentBindingState):
+    def __init__(self, state: State):
+        self.state = state
+        self._update_cache()
+
+    def _update_cache(self) -> None:
+        self.name_to_id_cache: dict[str, str] = self.state.get_all("")
+        self.id_to_name_cache: dict[str, str] = {
+            v: k for k, v in self.name_to_id_cache.items()
+        }
+
+    def get_id_for_component_name(self, component_name: str) -> Optional[str]:
+        return self.name_to_id_cache.get(component_name)
+
+    def get_name_for_component_id(self, component_id: str) -> Optional[str]:
+        return self.id_to_name_cache.get(component_id)
+
+    def bind_component(self, component_name: str, component_id: str) -> None:
+        self.state.add(component_name, component_id, force=True)
+        self._update_cache()
+
+    def forget_component(self, component_name: str) -> None:
+        self.state.rm(component_name)

reconcile/statuspage/status.py

@@ -0,0 +1,97 @@
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from datetime import (
+    datetime,
+    timezone,
+)
+from typing import Optional
+
+from dateutil.parser import isoparse
+from pydantic import BaseModel
+
+from reconcile.gql_definitions.statuspage.statuspages import (
+    ManualStatusProviderV1,
+    StatusProviderV1,
+)
+
+# This module defines the interface for status providers for components on status
+# pages. A status provider is responsible for determining the status of a component.
+# This status will then be used to update the status page component.
+
+
+class StatusProvider(ABC):
+    """
+    The generic static provider interface that can be used to determine the
+    status of a component.
+    """
+
+    @abstractmethod
+    def get_status(self) -> Optional[str]: ...
+
+
+class ManualStatusProvider(StatusProvider, BaseModel):
+    """
+    This status provider is used to manually define the status of a component.
+    An optional time windows can be defined in which the status is applied to
+    the component.
+    """
+
+    start: Optional[datetime] = None
+    """
+    The optional start time of the time window in which the manually
+    defined status is active.
+    """
+
+    end: Optional[datetime] = None
+    """
+    The optional end time of the time window in which the manually
+    defined status is active.
+    """
+
+    component_status: str
+    """
+    The status to be used for the component if the
+    time window is active or if no time window is defined.
+    """
+
+    def get_status(self) -> Optional[str]:
+        if self._is_active():
+            return self.component_status
+        return None
+
+    def _is_active(self) -> bool:
+        """
+        Returns true if the config is active in regards to the start and
+        end time window. If no time window is defined, the config is always
+        active.
+        """
+        if self.start and self.end and self.end < self.start:
+            raise ValueError(
+                "manual component status time window is invalid: end before start"
+            )
+        now = datetime.now(timezone.utc)
+        if self.start and now < self.start:
+            return False
+        if self.end and self.end < now:
+            return False
+        return True
+
+
+def build_status_provider_config(
+    cfg: StatusProviderV1,
+) -> Optional[StatusProvider]:
+    """
+    Translates a status provider config from the desired state into
+    provider specific implementation that provides the status resolution logic.
+    """
+    if isinstance(cfg, ManualStatusProviderV1):
+        start = isoparse(cfg.manual.q_from) if cfg.manual.q_from else None
+        end = isoparse(cfg.manual.until) if cfg.manual.until else None
+        return ManualStatusProvider(
+            component_status=cfg.manual.component_status,
+            start=start,
+            end=end,
+        )
+    return None

reconcile/typed_queries/cost_report/cost_namespaces.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel
+
+from reconcile.gql_definitions.cost_report.cost_namespaces import query
+from reconcile.utils.gql import GqlApi
+
+
+class CostNamespace(BaseModel):
+    name: str
+    app_name: str
+    cluster_name: str
+    cluster_external_id: str | None
+
+    class Config:
+        frozen = True
+
+
+def get_cost_namespaces(
+    gql_api: GqlApi,
+) -> list[CostNamespace]:
+    variables = {
+        "filter": {
+            "cluster": {
+                "filter": {
+                    "enableCostReport": True,
+                },
+            },
+        },
+    }
+    namespaces = query(gql_api.query, variables=variables).namespaces or []
+    return [
+        CostNamespace(
+            name=namespace.name,
+            app_name=namespace.app.name,
+            cluster_name=namespace.cluster.name,
+            cluster_external_id=namespace.cluster.spec.external_id
+            if namespace.cluster.spec
+            else None,
+        )
+        for namespace in namespaces
+    ]

tools/cli_commands/cost_report/{command.py → aws.py}

@@ -1,7 +1,6 @@
-from collections import defaultdict
-from collections.abc import Iterable, Mapping, MutableMapping
+from collections.abc import Iterable, Mapping
 from decimal import Decimal
-from typing import List, Self, Tuple
+from typing import Self
 
 from sretoolbox.utils import threaded
 
@@ -13,27 +12,31 @@ from reconcile.typed_queries.cost_report.settings import get_cost_report_setting
 from reconcile.utils import gql
 from reconcile.utils.secret_reader import create_secret_reader
 from tools.cli_commands.cost_report.cost_management_api import CostManagementApi
-from tools.cli_commands.cost_report.model import ChildAppReport, Report, ServiceReport
+from tools.cli_commands.cost_report.model import ChildAppReport, Report, ReportItem
 from tools.cli_commands.cost_report.response import ReportCostResponse
-from tools.cli_commands.cost_report.view import render_report
+from tools.cli_commands.cost_report.util import process_reports
+from tools.cli_commands.cost_report.view import render_aws_cost_report
 
 THREAD_POOL_SIZE = 10
 
 
-class CostReportCommand:
+class AwsCostReportCommand:
     def __init__(
         self,
         gql_api: gql.GqlApi,
         cost_management_api: CostManagementApi,
         cost_management_console_base_url: str,
+        thread_pool_size: int = THREAD_POOL_SIZE,
     ) -> None:
         self.gql_api = gql_api
         self.cost_management_api = cost_management_api
         self.cost_management_console_base_url = cost_management_console_base_url
+        self.thread_pool_size = thread_pool_size
 
     def execute(self) -> str:
         apps = self.get_apps()
-        reports = self.get_reports(apps)
+        responses = self.get_reports(apps)
+        reports = self.process_reports(apps, responses)
         return self.render(reports)
 
     def get_apps(self) -> list[App]:
@@ -42,74 +45,44 @@ class CostReportCommand:
         """
         return get_app_names(self.gql_api)
 
-    def _fetch_report(self, app: App) -> Tuple[str, ReportCostResponse]:
+    def _get_report(self, app: App) -> tuple[str, ReportCostResponse]:
         return app.name, self.cost_management_api.get_aws_costs_report(app.name)
 
-    def _fetch_reports(self, apps: Iterable[App]) -> dict[str, ReportCostResponse]:
-        results = threaded.run(self._fetch_report, apps, THREAD_POOL_SIZE)
-        return dict(results)
-
-    def get_reports(self, apps: Iterable[App]) -> dict[str, Report]:
+    def get_reports(
+        self,
+        apps: Iterable[App],
+    ) -> Mapping[str, ReportCostResponse]:
         """
-        Fetch reports from cost management API and build reports with parent-child app tree.
+        Fetch reports from cost management API
         """
-        responses = self._fetch_reports(apps)
-
-        child_apps_by_parent = defaultdict(list)
-        for app in apps:
-            child_apps_by_parent[app.parent_app_name].append(app.name)
-
-        reports: dict[str, Report] = {}
-        root_apps = child_apps_by_parent.get(None, [])
-        for app_name in root_apps:
-            self._dfs_reports(
-                app_name,
-                None,
-                child_apps_by_parent=child_apps_by_parent,
-                responses=responses,
-                reports=reports,
-            )
-        return reports
-
-    def render(self, reports: Mapping[str, Report]) -> str:
-        return render_report(
-            reports=reports,
-            cost_management_console_base_url=self.cost_management_console_base_url,
-        )
+        results = threaded.run(self._get_report, apps, self.thread_pool_size)
+        return dict(results)
 
-    def _dfs_reports(
+    def process_reports(
         self,
-        app_name: str,
-        parent_app_name: str | None,
-        child_apps_by_parent: Mapping[str | None, list[str]],
+        apps: Iterable[App],
         responses: Mapping[str, ReportCostResponse],
-        reports: MutableMapping[str, Report],
-    ) -> None:
+    ) -> dict[str, Report]:
         """
-        Depth-first search to build the reports. Build leaf nodes first to ensure total is calculated correctly.
+        Build reports with parent-child app tree.
         """
-        child_apps = child_apps_by_parent.get(app_name, [])
-        for child_app in child_apps:
-            self._dfs_reports(
-                app_name=child_app,
-                parent_app_name=app_name,
-                child_apps_by_parent=child_apps_by_parent,
-                responses=responses,
-                reports=reports,
-            )
-        reports[app_name] = self._build_report(
-            app_name=app_name,
-            parent_app_name=parent_app_name,
-            child_apps=child_apps,
+        return process_reports(
+            apps,
+            responses,
+            report_builder=self._build_report,
+        )
+
+    def render(self, reports: Mapping[str, Report]) -> str:
+        return render_aws_cost_report(
             reports=reports,
-            response=responses[app_name],
+            cost_management_console_base_url=self.cost_management_console_base_url,
         )
 
     @staticmethod
     def _build_report(
         app_name: str,
         parent_app_name: str | None,
-        child_apps: List[str],
+        child_apps: list[str],
         reports: Mapping[str, Report],
         response: ReportCostResponse,
     ) -> Report:
@@ -123,30 +96,34 @@ class CostReportCommand:
         child_apps_total = Decimal(
             sum(child_app.total for child_app in child_app_reports)
         )
-        services_total = response.meta.total.cost.total.value
-        total = services_total + child_apps_total
+
+        items = [
+            ReportItem(
+                name=service.service,
+                delta_value=value.delta_value,
+                delta_percent=value.delta_percent,
+                total=value.cost.total.value,
+            )
+            for data in response.data
+            for service in data.services
+            if len(service.values) == 1 and (value := service.values[0]) is not None
+        ]
+
+        items_total = response.meta.total.cost.total.value
+        total = items_total + child_apps_total
         date = next((d for data in response.data if (d := data.date)), "")
+
         return Report(
             app_name=app_name,
             child_apps=child_app_reports,
             child_apps_total=child_apps_total,
             date=date,
             parent_app_name=parent_app_name,
-            services_delta_value=response.meta.delta.value,
-            services_delta_percent=response.meta.delta.percent,
-            services_total=services_total,
+            items_delta_value=response.meta.delta.value,
+            items_delta_percent=response.meta.delta.percent,
+            items_total=items_total,
             total=total,
-            services=[
-                ServiceReport(
-                    service=service.service,
-                    delta_value=value.delta_value,
-                    delta_percent=value.delta_percent,
-                    total=value.cost.total.value,
-                )
-                for data in response.data
-                for service in data.services
-                if len(service.values) == 1 and (value := service.values[0]) is not None
-            ],
+            items=items,
         )
 
     @classmethod
@@ -169,4 +146,5 @@ class CostReportCommand:
             gql_api=gql_api,
             cost_management_api=cost_management_api,
             cost_management_console_base_url=secret["console_base_url"],
+            thread_pool_size=THREAD_POOL_SIZE,
         )