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

reconcile/ocm_clusters.py

@@ -12,12 +12,32 @@ from reconcile import (
     mr_client_gateway,
     queries,
 )
-from reconcile.ocm.types import OCMSpec
+from reconcile.ocm.types import (
+    OCMSpec,
+    ROSAClusterAWSAccount,
+    ROSAClusterSpec,
+    ROSAOcmAwsAttrs,
+    ROSAOcmAwsStsAttrs,
+)
 from reconcile.status import ExitCodes
 from reconcile.utils.disabled_integrations import integration_is_enabled
-from reconcile.utils.semver_helper import parse_semver
+from reconcile.utils.jobcontroller.controller import build_job_controller
+from reconcile.utils.ocm.products import (
+    IGNORE_NETWORK_TYPE_ATTR,
+    OCMProduct,
+    OCMProductPortfolio,
+    OCMValidationException,
+    build_product_portfolio,
+)
+from reconcile.utils.rosa.session import RosaSessionBuilder
+from reconcile.utils.runtime.integration import (
+    PydanticRunParams,
+    QontractReconcileIntegration,
+)
+from reconcile.utils.semver_helper import make_semver, parse_semver
 
 QONTRACT_INTEGRATION = "ocm-clusters"
+QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
 
 
 def _set_rosa_ocm_attrs(cluster: Mapping[str, Any]):
@@ -26,30 +46,44 @@ def _set_rosa_ocm_attrs(cluster: Mapping[str, Any]):
     but the cluster only needs the target OCM environment where it belongs.
     This method changes the cluster dictionary to include just those.
     """
-
-    rosa = cluster["spec"]["account"]["rosa"]
-    ocm_env = [
-        env
-        for env in rosa["ocm_environments"]
-        if env["ocm"]["name"] == cluster["ocm"]["name"]
-    ]
-
-    if len(ocm_env) != 1:
-        logging.error(
-            "The cluster's OCM reference does not exist or it is duplicated in the AWS account manifest. "
-            "Check the cluster's AWS account rosa configuration. "
-            f"OCM:{cluster['ocm']['name']}, AWSAcc:{cluster['spec']['account']['uid']}"
+    account = cluster["spec"]["account"]
+    uid = account["uid"]
+    rosa_ocm_configs = account["rosa"]
+    rosa: ROSAOcmAwsAttrs | None = None
+    if rosa_ocm_configs:
+        ocm_env = [
+            env
+            for env in rosa_ocm_configs["ocm_environments"]
+            if env["ocm"]["name"] == cluster["ocm"]["name"]
+        ]
+        if len(ocm_env) != 1:
+            logging.error(
+                "The cluster's OCM reference does not exist or it is duplicated in the AWS account manifest. "
+                "Check the cluster's AWS account rosa configuration. "
+                f"OCM:{cluster['ocm']['name']}, AWSAcc:{cluster['spec']['account']['uid']}"
+            )
+            sys.exit(ExitCodes.ERROR)
+        env = ocm_env[0]
+        rosa = ROSAOcmAwsAttrs(
+            creator_role_arn=env["creator_role_arn"],
+            sts=ROSAOcmAwsStsAttrs(
+                installer_role_arn=env["installer_role_arn"],
+                support_role_arn=env["support_role_arn"],
+                controlplane_role_arn=env.get("controlplane_role_arn"),
+                worker_role_arn=env["worker_role_arn"],
+            ),
         )
-        sys.exit(ExitCodes.ERROR)
-
-    rosa["creator_role_arn"] = ocm_env[0]["creator_role_arn"]
-    rosa["installer_role_arn"] = ocm_env[0]["installer_role_arn"]
-    rosa["support_role_arn"] = ocm_env[0]["support_role_arn"]
-    rosa["controlplane_role_arn"] = ocm_env[0]["controlplane_role_arn"]
-    rosa["worker_role_arn"] = ocm_env[0]["worker_role_arn"]
+    else:
+        rosa = None
 
-    # Make pydantic happy
-    del rosa["ocm_environments"]
+    # doing this allows to exclude account fields which can be queried in graphql
+    rosa_cluster_aws_account = ROSAClusterAWSAccount(
+        uid=uid,
+        rosa=rosa,
+    )
+    if billing_account := account.get("billingAccount"):
+        rosa_cluster_aws_account.billing_account_id = billing_account["uid"]
+    cluster["spec"]["account"] = rosa_cluster_aws_account
 
 
 def fetch_desired_state(clusters: Iterable[Mapping[str, Any]]) -> dict[str, OCMSpec]:
@@ -91,10 +125,10 @@ def _cluster_version_needs_update(
     if not desired_version:
         return True
 
-    desired_version = parse_semver(desired_version)
-    current_version = parse_semver(current_version)
+    parsed_desired_version = parse_semver(desired_version)
+    parsed_current_version = parse_semver(current_version)
 
-    if current_version > desired_version:
+    if parsed_current_version > parsed_desired_version:
         # current version is geater due to an upgrade.
         # submit MR to update cluster version
         logging.info(
@@ -104,7 +138,7 @@ def _cluster_version_needs_update(
         )
         return True
 
-    if current_version < desired_version:
+    if parsed_current_version < parsed_desired_version:
         raise ClusterVersionError(
             f"[{cluster}] desired version [{desired_version}] is greater than "
             f"current version [{current_version}]. Please correct version to be "
@@ -152,17 +186,29 @@ def get_app_interface_spec_updates(
         desired_spec.spec.disable_user_workload_monitoring is None
         and current_spec.spec.disable_user_workload_monitoring
     ):
-        ocm_spec_updates[
-            ocmmod.SPEC_ATTR_DISABLE_UWM
-        ] = current_spec.spec.disable_user_workload_monitoring
+        ocm_spec_updates[ocmmod.SPEC_ATTR_DISABLE_UWM] = (
+            current_spec.spec.disable_user_workload_monitoring
+        )
 
     if (
         current_spec.spec.provision_shard_id is not None
         and desired_spec.spec.provision_shard_id != current_spec.spec.provision_shard_id
     ):
-        ocm_spec_updates[
-            ocmmod.SPEC_ATTR_PROVISION_SHARD_ID
-        ] = current_spec.spec.provision_shard_id
+        ocm_spec_updates[ocmmod.SPEC_ATTR_PROVISION_SHARD_ID] = (
+            current_spec.spec.provision_shard_id
+        )
+
+    if isinstance(current_spec.spec, ROSAClusterSpec) and isinstance(
+        desired_spec.spec, ROSAClusterSpec
+    ):
+        if (
+            current_spec.spec.oidc_endpoint_url
+            and desired_spec.spec.oidc_endpoint_url
+            != current_spec.spec.oidc_endpoint_url
+        ):
+            ocm_spec_updates[ocmmod.SPEC_ATTR_OIDC_ENDPONT_URL] = (
+                current_spec.spec.oidc_endpoint_url
+            )
 
     if current_spec.server_url and desired_spec.server_url != current_spec.server_url:
         root_updates[ocmmod.SPEC_ATTR_SERVER_URL] = current_spec.server_url
@@ -187,7 +233,7 @@ def get_app_interface_spec_updates(
 
 
 def get_cluster_ocm_update_spec(
-    ocm: ocmmod.OCM, cluster: str, current_spec: OCMSpec, desired_spec: OCMSpec
+    product: OCMProduct, cluster: str, current_spec: OCMSpec, desired_spec: OCMSpec
 ) -> tuple[dict[str, Any], bool]:
     """Get cluster updates to request to OCM api
 
@@ -198,29 +244,31 @@ def get_cluster_ocm_update_spec(
     :return: a tuple with the updates to request to OCM and a bool to notify errors
     """
 
-    impl = ocmmod.OCM_PRODUCTS_IMPL[current_spec.spec.product]
-
     error = False
     if not desired_spec.network.type:
         desired_spec.network.type = "OVNKubernetes"
 
     cspec = current_spec.spec.dict()
-    cspec[ocmmod.SPEC_ATTR_NETWORK] = current_spec.network.dict()
+    cspec[ocmmod.SPEC_ATTR_NETWORK] = current_spec.network.dict(
+        exclude={IGNORE_NETWORK_TYPE_ATTR}
+    )
 
     dspec = desired_spec.spec.dict()
-    dspec[ocmmod.SPEC_ATTR_NETWORK] = desired_spec.network.dict()
+    dspec[ocmmod.SPEC_ATTR_NETWORK] = desired_spec.network.dict(
+        exclude={IGNORE_NETWORK_TYPE_ATTR}
+    )
 
     # Convert ocm specs to dicts, removing null values and excluded attributes
     current_ocm_spec = {
         k: v
         for k, v in cspec.items()
-        if v is not None and k not in impl.EXCLUDED_SPEC_FIELDS
+        if v is not None and k not in product.EXCLUDED_SPEC_FIELDS
     }
 
     desired_ocm_spec = {
         k: v
         for k, v in dspec.items()
-        if v is not None and k not in impl.EXCLUDED_SPEC_FIELDS
+        if v is not None and k not in product.EXCLUDED_SPEC_FIELDS
     }
 
     # Updated attributes in app-interface
@@ -235,7 +283,7 @@ def get_cluster_ocm_update_spec(
 
     diffs = deleted_attrs | updated_attrs
 
-    not_allowed_updates = set(diffs) - impl.ALLOWED_SPEC_UPDATE_FIELDS
+    not_allowed_updates = set(diffs) - product.ALLOWED_SPEC_UPDATE_FIELDS
     if not_allowed_updates:
         error = True
         logging.error(f"[{cluster}] invalid updates: {not_allowed_updates}")
@@ -244,7 +292,7 @@ def get_cluster_ocm_update_spec(
 
 
 def _app_interface_updates_mr(
-    clusters_updates: Mapping[str, Any], gitlab_project_id: str, dry_run: bool
+    clusters_updates: Mapping[str, Any], gitlab_project_id: str | None, dry_run: bool
 ):
     """Creates an MR to app-interface with the necessary cluster manifest updates
 
@@ -278,94 +326,133 @@ def _cluster_is_compatible(cluster: Mapping[str, Any]) -> bool:
     return cluster.get("ocm") is not None
 
 
-def run(dry_run: bool, gitlab_project_id=None, thread_pool_size=10):
-    settings = queries.get_app_interface_settings()
-    clusters = queries.get_clusters()
-    clusters = [
-        c
-        for c in clusters
-        if integration_is_enabled(QONTRACT_INTEGRATION, c) and _cluster_is_compatible(c)
-    ]
-    if not clusters:
-        logging.debug("No OCM cluster definitions found in app-interface")
-        sys.exit(ExitCodes.SUCCESS)
-
-    ocm_map = ocmmod.OCMMap(
-        clusters=clusters,
-        integration=QONTRACT_INTEGRATION,
-        settings=settings,
-        init_provision_shards=True,
-    )
+class OcmClustersParams(PydanticRunParams):
+    gitlab_project_id: str | None = None
+    thread_pool_size: int = 10
 
-    # current_state is the state got from the ocm api
-    current_state, pending_state = ocm_map.cluster_specs()
-    desired_state = fetch_desired_state(clusters)
+    # rosa job controller params
+    job_controller_cluster: str | None = None
+    job_controller_namespace: str | None = None
+    rosa_job_service_account: str | None = None
+    rosa_role: str | None = None
+    rosa_job_image: str | None = None
 
-    error = False
-    clusters_updates = {}
-
-    for cluster_name, desired_spec in desired_state.items():
-        current_spec = current_state.get(cluster_name)
-        if current_spec:
-            # App-Interface manifests updates.
-            # OCM populated attributes that are not set in app-interface.
-            # These updates are performed with a single MR out of this main loop
-            clusters_updates[cluster_name], err = get_app_interface_spec_updates(
-                cluster_name, current_spec, desired_spec
-            )
-            if err:
-                error = True
-
-            # OCM API Updates
-            # Changes made to app-interface manifests that need to be requested
-            # to the OCM Api
-            ocm = ocm_map.get(cluster_name)
-            update_spec, err = get_cluster_ocm_update_spec(
-                ocm, cluster_name, current_spec, desired_spec
-            )
-            if err:
-                error = True
-                continue
-
-            # update cluster
-            # TODO(mafriedm): check dry_run in OCM API patch
-            if update_spec:
-                logging.info(["update_cluster", cluster_name])
-                logging.debug(
-                    f"current_spec: {current_spec}, desired_spec: {desired_spec}"
+
+class OcmClusters(QontractReconcileIntegration[OcmClustersParams]):
+    @property
+    def name(self) -> str:
+        return QONTRACT_INTEGRATION
+
+    def rosa_session_builder(self) -> RosaSessionBuilder | None:
+        if (
+            self.params.job_controller_cluster is None
+            or self.params.job_controller_namespace is None
+            or self.params.rosa_job_service_account is None
+            or self.params.rosa_role is None
+            or self.params.rosa_job_image is None
+        ):
+            return None
+        return RosaSessionBuilder(
+            aws_iam_role=self.params.rosa_role,
+            image=self.params.rosa_job_image,
+            service_account=self.params.rosa_job_service_account,
+            job_controller=build_job_controller(
+                cluster=self.params.job_controller_cluster,
+                namespace=self.params.job_controller_namespace,
+                integration=self.name,
+                integration_version=QONTRACT_INTEGRATION_VERSION,
+                secret_reader=self.secret_reader,
+                dry_run=False,
+            ),
+        )
+
+    def assemble_product_portfolio(self) -> OCMProductPortfolio:
+        return build_product_portfolio(self.rosa_session_builder())
+
+    def run(self, dry_run: bool) -> None:
+        settings = queries.get_app_interface_settings()
+        clusters = queries.get_clusters()
+        clusters = [
+            c
+            for c in clusters
+            if integration_is_enabled(self.name, c) and _cluster_is_compatible(c)
+        ]
+        if not clusters:
+            logging.debug("No OCM cluster definitions found in app-interface")
+            sys.exit(ExitCodes.SUCCESS)
+
+        product_portfolio = self.assemble_product_portfolio()
+        ocm_map = ocmmod.OCMMap(
+            clusters=clusters,
+            integration=self.name,
+            settings=settings,
+            init_provision_shards=True,
+            product_portfolio=product_portfolio,
+        )
+
+        # current_state is the state got from the ocm api
+        current_state, pending_state = ocm_map.cluster_specs()
+        desired_state = fetch_desired_state(clusters)
+
+        error = False
+        clusters_updates = {}
+
+        for cluster_name, desired_spec in desired_state.items():
+            current_spec = current_state.get(cluster_name)
+            if current_spec:
+                # App-Interface manifests updates.
+                # OCM populated attributes that are not set in app-interface.
+                # These updates are performed with a single MR out of this main loop
+                clusters_updates[cluster_name], err = get_app_interface_spec_updates(
+                    cluster_name, current_spec, desired_spec
                 )
-                if not dry_run:
-                    ocm = ocm_map.get(cluster_name)
-                    try:
-                        ocm.update_cluster(cluster_name, update_spec, dry_run)
-                    except NotImplementedError:
-                        logging.error(
-                            f"[{cluster_name}] Update clusters is currently not "
-                            f"implemented for [{desired_spec.spec.product}] product. "
-                            "Fix the app-interface manifest with the required changes. "
-                            f" {update_spec}"
-                        )
-                        # Not marking error because in cases where specific product
-                        # updates are not yet supported, changes made directly in OCM
-                        # and not added to app-interface would trigger this exception
-                        # and break this integration
-                        # error = True
-        else:
-            # create cluster
-            if cluster_name in pending_state:
-                continue
-            logging.info(["create_cluster", cluster_name])
-            ocm = ocm_map.get(cluster_name)
-            try:
-                ocm.create_cluster(cluster_name, desired_spec, dry_run)
-            except NotImplementedError:
-                logging.error(
-                    f"[{cluster_name}] Create clusters is not currently implemented "
-                    f"for [{desired_spec.spec.product}] product type. Make sure the "
-                    "cluster exists and it is returned by the OCM api before adding "
-                    "its manifest to app-interface"
+                if err:
+                    error = True
+
+                # OCM API Updates
+                # Changes made to app-interface manifests that need to be requested
+                # to the OCM Api
+                ocm = ocm_map.get(cluster_name)
+                product = product_portfolio.get_product_impl(
+                    current_spec.spec.product, current_spec.spec.hypershift
                 )
-                error = True
-
-    _app_interface_updates_mr(clusters_updates, gitlab_project_id, dry_run)
-    sys.exit(int(error))
+                update_spec, err = get_cluster_ocm_update_spec(
+                    product, cluster_name, current_spec, desired_spec
+                )
+                if err:
+                    error = True
+                    continue
+
+                # update cluster
+                if update_spec:
+                    logging.info(["update_cluster", cluster_name])
+                    logging.debug(
+                        f"current_spec: {current_spec}, desired_spec: {desired_spec}"
+                    )
+                    ocm = ocm_map.get(cluster_name)
+                    ocm.update_cluster(cluster_name, update_spec, dry_run)
+
+            else:
+                # create cluster
+                if cluster_name in pending_state:
+                    continue
+                logging.info(["create_cluster", cluster_name])
+                ocm = ocm_map.get(cluster_name)
+                try:
+                    ocm.create_cluster(cluster_name, desired_spec, dry_run)
+                except NotImplementedError:
+                    logging.error(
+                        f"[{cluster_name}] Create clusters is not currently implemented "
+                        f"for [{desired_spec.spec.product}] product type. Make sure the "
+                        "cluster exists and it is returned by the OCM api before adding "
+                        "its manifest to app-interface"
+                    )
+                    error = True
+                except OCMValidationException as e:
+                    logging.error("[%s] Error creating cluster: %s", cluster_name, e)
+                    error = True
+
+        _app_interface_updates_mr(
+            clusters_updates, self.params.gitlab_project_id, dry_run
+        )
+        sys.exit(int(error))

reconcile/ocm_external_configuration_labels.py

@@ -12,6 +12,13 @@ from reconcile.utils.ocm import OCMMap
 QONTRACT_INTEGRATION = "ocm-external-configuration-labels"
 
 
+def get_allowed_labels_for_cluster(cluster: dict[str, Any]) -> set[str]:
+    allowed_labels = cluster.get("ocm", {}).get(
+        "allowedClusterExternalConfigLabels", []
+    )
+    return set(allowed_labels)
+
+
 def fetch_current_state(clusters):
     settings = queries.get_app_interface_settings()
     ocm_map = OCMMap(
@@ -21,9 +28,12 @@ def fetch_current_state(clusters):
     current_state = []
     for cluster in clusters:
         cluster_name = cluster["name"]
+        allowed_labels = get_allowed_labels_for_cluster(cluster)
         ocm = ocm_map.get(cluster_name)
         labels = ocm.get_external_configuration_labels(cluster_name)
         for key, value in labels.items():
+            if key not in allowed_labels:
+                continue
             item = {"label": {"key": key, "value": value}, "cluster": cluster_name}
             current_state.append(item)
 
@@ -34,8 +44,13 @@ def fetch_desired_state(clusters):
     desired_state = []
     for cluster in clusters:
         cluster_name = cluster["name"]
+        allowed_labels = get_allowed_labels_for_cluster(cluster)
         labels = json.loads(cluster["externalConfiguration"]["labels"])
         for key, value in labels.items():
+            if key not in allowed_labels:
+                raise ValueError(
+                    f"Unsupported external configuration label '{key}' in cluster '{cluster_name}'"
+                )
             item = {"label": {"key": key, "value": value}, "cluster": cluster_name}
             desired_state.append(item)
 

reconcile/ocm_github_idp.py

@@ -63,7 +63,7 @@ def fetch_desired_state(clusters, vault_input_path, settings):
 
 
 def sanitize(state):
-    return {k: v for k, v in state.items() if k not in ["client_secret", "id"]}
+    return {k: v for k, v in state.items() if k not in {"client_secret", "id"}}
 
 
 def act(dry_run, ocm_map, current_state, desired_state):

reconcile/ocm_groups.py

@@ -13,6 +13,7 @@ from reconcile import (
 from reconcile.status import ExitCodes
 from reconcile.utils.disabled_integrations import integration_is_enabled
 from reconcile.utils.ocm import OCMMap
+from reconcile.utils.ocm.base import OCMClusterGroupId
 
 QONTRACT_INTEGRATION = "ocm-groups"
 
@@ -74,20 +75,39 @@ def run(dry_run, thread_pool_size=10):
         sys.exit(ExitCodes.SUCCESS)
 
     ocm_map, current_state = fetch_current_state(clusters, thread_pool_size)
-    desired_state = openshift_groups.fetch_desired_state(oc_map=ocm_map)
+    desired_state = openshift_groups.fetch_desired_state(clusters=ocm_map.clusters())
 
-    # we only manage dedicated-admins via OCM
-    current_state = [s for s in current_state if s["group"] == "dedicated-admins"]
-    desired_state = [s for s in desired_state if s["group"] == "dedicated-admins"]
+    current_state = [
+        s for s in current_state if s["group"] in OCMClusterGroupId.values()
+    ]
+    desired_state = [
+        s for s in desired_state if s["group"] in OCMClusterGroupId.values()
+    ]
 
     diffs = openshift_groups.calculate_diff(current_state, desired_state)
     openshift_groups.validate_diffs(diffs)
 
     for diff in diffs:
         # we do not need to create/delete groups in OCM
-        if diff["action"] in ["create_group", "delete_group"]:
+        if diff["action"] in {"create_group", "delete_group"}:
             continue
         logging.info(list(diff.values()))
 
         if not dry_run:
             act(diff, ocm_map)
+
+
+def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+    clusters = [
+        c["name"]
+        for c in queries.get_clusters()
+        if integration_is_enabled(QONTRACT_INTEGRATION, c) and _cluster_is_compatible(c)
+    ]
+    desired_state = openshift_groups.fetch_desired_state(clusters=clusters)
+    desired_state = [
+        s for s in desired_state if s["group"] in OCMClusterGroupId.values()
+    ]
+
+    return {
+        "state": desired_state,
+    }

reconcile/ocm_internal_notifications/integration.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import (
+    Callable,
+)
+from functools import lru_cache
+
+from reconcile.gql_definitions.common.ocm_environments import (
+    query as ocm_environment_query,
+)
+from reconcile.gql_definitions.fragments.ocm_environment import OCMEnvironment
+from reconcile.slack_base import slackapi_from_queries
+from reconcile.typed_queries.app_interface_custom_messages import (
+    get_app_interface_custom_message,
+)
+from reconcile.utils import gql
+from reconcile.utils.ocm.search_filters import Filter
+from reconcile.utils.ocm_base_client import (
+    init_ocm_base_client,
+)
+from reconcile.utils.runtime.integration import (
+    NoParams,
+    QontractReconcileIntegration,
+)
+from reconcile.utils.slack_api import UserNotFoundException
+
+QONTRACT_INTEGRATION = "ocm-internal-notifications"
+
+
+class OcmInternalNotifications(QontractReconcileIntegration[NoParams]):
+    """Notifications to internal Red Hat users based on conditions in OCM."""
+
+    def __init__(self) -> None:
+        super().__init__(NoParams())
+        self.slack = slackapi_from_queries(
+            integration_name=self.name, init_usergroups=False
+        )
+        self.slack_get_user_id_by_name = lru_cache()(self._slack_get_user_id_by_name)
+
+    @property
+    def name(self) -> str:
+        return QONTRACT_INTEGRATION
+
+    def get_environments(self, query_func: Callable) -> list[OCMEnvironment]:
+        return ocm_environment_query(query_func).environments
+
+    def _slack_get_user_id_by_name(
+        self, user_name: str, mail_address: str
+    ) -> str | None:
+        try:
+            return self.slack.get_user_id_by_name(
+                user_name=user_name, mail_address=mail_address
+            )
+        except UserNotFoundException:
+            return None
+
+    def run(self, dry_run: bool) -> None:
+        gqlapi = gql.get_api()
+        environments = self.get_environments(gqlapi.query)
+
+        for env in environments:
+            ocm = init_ocm_base_client(env, self.secret_reader)
+
+            if not (env.labels and env.labels.get("internal_notifications")):
+                logging.info(
+                    f"skipping environment {env.name} due to no internal_notifications label"
+                )
+                continue
+
+            clusters = ocm.get(
+                api_path="/api/clusters_mgmt/v1/clusters",
+                params={
+                    "search": Filter()
+                    .eq("state", "uninstalling")
+                    .eq("managed", "true")
+                    .render(),
+                    "orderBy": "created_at",
+                },
+            ).get("items")
+            subscriptions = ocm.get(
+                api_path="/api/accounts_mgmt/v1/subscriptions",
+                params={
+                    "search": Filter()
+                    .is_in("id", [c["subscription"]["id"] for c in clusters])
+                    .render(),
+                    "orderBy": "created_at",
+                },
+            ).get("items")
+
+            slack_user_ids = set()
+            for subscription in subscriptions:
+                creator = ocm.get(api_path=subscription["creator"]["href"])
+                email = creator["email"]
+                logging.info(
+                    f"found managed cluster in uninstalling state in environment {env.name} with creator {email}"
+                )
+                user, mail_address = email.split("@")
+                user_name = user.split("+")[0]
+                slack_user_id = self.slack_get_user_id_by_name(user_name, mail_address)
+                if slack_user_id:
+                    logging.info(
+                        f"found slack user id {slack_user_id} for user {user_name}"
+                    )
+                    slack_user_ids.add(slack_user_id)
+                else:
+                    logging.warning(f"slack user id not found for user {user_name}")
+
+            if not dry_run and slack_user_ids:
+                users = " ".join([f"<@{uid}>" for uid in slack_user_ids])
+                instructions = (
+                    get_app_interface_custom_message(
+                        "ocm-internal-notifications-instructions"
+                    )
+                    or ""
+                )
+                self.slack.chat_post_message(
+                    f"hey {users} :wave: you have clusters stuck in uninstalling state in the {env.name} environment. {instructions}"
+                )