qontract-reconcile 0.10.2.dev184__py3-none-any.whl → 0.10.2.dev186__py3-none-any.whl

reconcile/acs_notifiers.py

@@ -1,126 +0,0 @@
-import logging
-
-import reconcile.gql_definitions.acs.acs_policies as gql_acs_policies
-from reconcile.gql_definitions.jira.jira_servers import (
-    JiraServerV1,
-)
-from reconcile.gql_definitions.jira.jira_servers import (
-    query as query_jira_servers,
-)
-from reconcile.utils import gql
-from reconcile.utils.acs.notifiers import (
-    AcsNotifiersApi,
-    JiraCredentials,
-    JiraNotifier,
-)
-from reconcile.utils.differ import diff_iterables
-from reconcile.utils.disabled_integrations import integration_is_enabled
-from reconcile.utils.runtime.integration import (
-    NoParams,
-    QontractReconcileIntegration,
-)
-from reconcile.utils.semver_helper import make_semver
-
-
-class AcsNotifiersIntegration(QontractReconcileIntegration[NoParams]):
-    def __init__(self) -> None:
-        super().__init__(NoParams())
-        self.qontract_integration = "acs-notifiers"
-        self.qontract_integration_version = make_semver(0, 1, 0)
-
-    @property
-    def name(self) -> str:
-        return self.qontract_integration
-
-    def _get_escalation_policies(
-        self, acs_policies: list[gql_acs_policies.AcsPolicyV1]
-    ) -> list[gql_acs_policies.AppEscalationPolicyV1]:
-        return list(
-            {
-                p.integrations.notifiers.jira.escalation_policy.name: p.integrations.notifiers.jira.escalation_policy
-                for p in acs_policies
-                if p.integrations
-                and p.integrations.notifiers
-                and p.integrations.notifiers.jira
-                and integration_is_enabled(
-                    self.qontract_integration,
-                    p.integrations.notifiers.jira.escalation_policy.channels.jira_board[
-                        0
-                    ],
-                )
-            }.values()
-        )
-
-    def get_desired_state(
-        self, acs_policies: list[gql_acs_policies.AcsPolicyV1]
-    ) -> list[JiraNotifier]:
-        return [
-            JiraNotifier.from_escalation_policy(ep)
-            for ep in self._get_escalation_policies(acs_policies)
-        ]
-
-    def get_jira_credentials(
-        self, jira_servers: list[JiraServerV1]
-    ) -> dict[str, JiraCredentials]:
-        return {
-            server.server_url: JiraCredentials(
-                url=server.server_url,
-                username=server.username,
-                token=self.secret_reader.read_secret(server.token),
-            )
-            for server in jira_servers
-        }
-
-    def reconcile(
-        self,
-        current_state: list[JiraNotifier],
-        desired_state: list[JiraNotifier],
-        acs_api: AcsNotifiersApi,
-        jira_credentials: dict[str, JiraCredentials],
-        dry_run: bool,
-    ) -> 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 Jira notifier: {a.name}")
-            if not dry_run:
-                acs_api.create_jira_notifier(
-                    a,
-                    jira_credentials=jira_credentials[a.url],
-                )
-        for c in diff.change.values():
-            logging.info(f"Update Jira notifier: {c.desired.name}")
-            if not dry_run:
-                acs_api.update_jira_notifier(
-                    c.desired,
-                    jira_credentials=jira_credentials[c.desired.url],
-                )
-        for d in diff.delete.values():
-            logging.info(f"Delete Jira notifier: {d.name}")
-            if not dry_run:
-                acs_api.delete_jira_notifier(d)
-
-    def run(
-        self,
-        dry_run: bool,
-    ) -> None:
-        gql_api_query = gql.get_api().query
-        jira_credentials = self.get_jira_credentials(
-            query_jira_servers(query_func=gql_api_query).jira_servers or []
-        )
-        desired_state = self.get_desired_state(
-            gql_acs_policies.query(query_func=gql_api_query).acs_policies or []
-        )
-        instance = AcsNotifiersApi.get_acs_instance(query_func=gql_api_query)
-        with AcsNotifiersApi(
-            url=instance.url, token=self.secret_reader.read_secret(instance.credentials)
-        ) as acs_api:
-            current_state = acs_api.get_jira_notifiers()
-            self.reconcile(
-                current_state=current_state,
-                desired_state=desired_state,
-                acs_api=acs_api,
-                jira_credentials=jira_credentials,
-                dry_run=dry_run,
-            )

reconcile/utils/acs/notifiers.py

@@ -1,145 +0,0 @@
-import json
-from typing import Any
-
-from pydantic import BaseModel
-
-from reconcile.gql_definitions.acs.acs_policies import AppEscalationPolicyV1
-from reconcile.utils.acs.base import AcsBaseApi
-
-
-class JiraCredentials(BaseModel):
-    url: str
-    username: str
-    token: str
-
-
-class SeverityPriorityMapping(BaseModel):
-    severity: str
-    priority: str
-
-    @staticmethod
-    def from_api(mapping: dict[str, str]) -> "SeverityPriorityMapping":
-        return SeverityPriorityMapping(
-            severity=mapping["severity"].replace("_SEVERITY", "").lower(),
-            priority=mapping["priorityName"],
-        )
-
-    def to_api(self) -> Any:
-        return {
-            "severity": f"{self.severity.upper()}_SEVERITY",
-            "priorityName": self.priority,
-        }
-
-
-class JiraNotifier(BaseModel):
-    name: str
-    board: str
-    url: str
-    issue_type: str | None
-    severity_priority_mappings: list[SeverityPriorityMapping]
-    custom_fields: dict[str, Any] | None
-
-    @staticmethod
-    def from_api(notifier: dict[str, Any]) -> "JiraNotifier":
-        notifier_jira = notifier["jira"]
-        return JiraNotifier(
-            name=notifier["name"],
-            board=notifier["labelDefault"],
-            url=notifier_jira["url"],
-            issue_type=notifier_jira["issueType"],
-            severity_priority_mappings=sorted(
-                [
-                    SeverityPriorityMapping.from_api(mapping)
-                    for mapping in notifier_jira["priorityMappings"]
-                ],
-                key=lambda m: m.severity,
-            ),
-            custom_fields=json.loads(notifier_jira.get("defaultFieldsJson") or "{}"),
-        )
-
-    def to_api(self, ui_endpoint: str, jira_credentials: JiraCredentials) -> Any:
-        return {
-            "name": self.name,
-            "type": "jira",
-            "uiEndpoint": ui_endpoint,
-            "labelDefault": self.board,
-            "jira": {
-                "url": jira_credentials.url,
-                "username": jira_credentials.username,
-                "password": jira_credentials.token,
-                "issueType": self.issue_type or "Task",
-                "priorityMappings": [
-                    mapping.to_api() for mapping in self.severity_priority_mappings
-                ],
-                "defaultFieldsJson": json.dumps(self.custom_fields or {}),
-            },
-        }
-
-    @staticmethod
-    def from_escalation_policy(
-        escalation_policy: AppEscalationPolicyV1,
-    ) -> "JiraNotifier":
-        jira_board = escalation_policy.channels.jira_board[0]
-
-        custom_fields: dict[str, Any] = {}
-        for field in jira_board.issue_fields or []:
-            if field.name == "Security Level":
-                custom_fields["security"] = {"name": field.value}
-
-        if escalation_policy.channels.jira_component:
-            custom_fields["components"] = [
-                {"name": escalation_policy.channels.jira_component}
-            ]
-        if escalation_policy.channels.jira_labels:
-            custom_fields["labels"] = escalation_policy.channels.jira_labels
-
-        return JiraNotifier(
-            name=f"jira-{escalation_policy.name}",
-            board=jira_board.name,
-            url=jira_board.server.server_url,
-            issue_type=jira_board.issue_type or "Task",
-            severity_priority_mappings=sorted(
-                [
-                    SeverityPriorityMapping(**vars(sp))
-                    for sp in jira_board.severity_priority_mappings.mappings
-                ],
-                key=lambda m: m.severity,
-            ),
-            custom_fields=custom_fields,
-        )
-
-
-class AcsNotifiersApi(AcsBaseApi):
-    """
-    Implements methods to support reconcile operations against the ACS NotifiersService api
-    """
-
-    def get_notifiers(self) -> list[Any]:
-        return self.generic_request_json("/v1/notifiers", "GET")["notifiers"]
-
-    def get_jira_notifiers(self) -> list[JiraNotifier]:
-        return [
-            JiraNotifier.from_api(notifier)
-            for notifier in self.get_notifiers()
-            if notifier["type"] == "jira"
-        ]
-
-    def get_notifier_id_by_name(self, name: str) -> str:
-        return next(n["id"] for n in self.get_notifiers() if n["name"] == name)
-
-    def update_jira_notifier(
-        self, jira_notifier: JiraNotifier, jira_credentials: JiraCredentials
-    ) -> None:
-        notifier_id = self.get_notifier_id_by_name(jira_notifier.name)
-        body = jira_notifier.to_api(self.url, jira_credentials)
-        self.generic_request(f"/v1/notifiers/{notifier_id}", "PUT", body)
-
-    def create_jira_notifier(
-        self, jira_notifier: JiraNotifier, jira_credentials: JiraCredentials
-    ) -> None:
-        body = jira_notifier.to_api(self.url, jira_credentials)
-        self.generic_request("/v1/notifiers", "POST", body)
-
-    def delete_jira_notifier(self, jira_notifier: JiraNotifier) -> None:
-        notifier_id = self.get_notifier_id_by_name(jira_notifier.name)
-        self.generic_request(f"/v1/notifiers/{notifier_id}", "DELETE")