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

reconcile/aus/ocm_addons_upgrade_scheduler_org.py

@@ -1,32 +1,50 @@
-from typing import (
-    Any,
-    Optional,
-)
+import functools
 
 from pydantic import BaseModel
 
-from reconcile import queries
 from reconcile.aus import base as aus
+from reconcile.aus.base import (
+    AbstractUpgradePolicy,
+    AddonUpgradePolicy,
+    init_addon_service,
+)
+from reconcile.aus.cluster_version_data import VersionData
+from reconcile.aus.healthchecks import (
+    AUSClusterHealthCheckProvider,
+    build_cluster_health_providers_for_organization,
+)
+from reconcile.aus.metrics import (
+    AUSAddonUpgradePolicyInfoMetric,
+    AUSAddonVersionRemainingSoakDaysGauge,
+)
 from reconcile.aus.models import (
+    ClusterAddonUpgradeSpec,
     ClusterUpgradeSpec,
     OrganizationUpgradeSpec,
 )
-from reconcile.gql_definitions.advanced_upgrade_service.aus_organization import (
-    query as aus_organizations_query,
-)
+from reconcile.gql_definitions.fragments.aus_organization import AUSOCMOrganization
 from reconcile.gql_definitions.fragments.ocm_environment import OCMEnvironment
-from reconcile.utils import gql
-from reconcile.utils.cluster_version_data import VersionData
-from reconcile.utils.ocm import OCMMap
+from reconcile.utils import metrics
+from reconcile.utils.ocm.addons import (
+    OCMAddonInstallation,
+)
+from reconcile.utils.ocm.clusters import (
+    OCMCluster,
+    discover_clusters_for_organizations,
+)
+from reconcile.utils.ocm_base_client import (
+    OCMBaseClient,
+    init_ocm_base_client,
+    init_ocm_base_client_for_org,
+)
 
 QONTRACT_INTEGRATION = "ocm-addons-upgrade-scheduler-org"
 
 
 class AUSOrgAddonUpgradeState(BaseModel):
-
     addon_id: str
-    current_state: list[dict[str, Any]]
-    desired_state: list[dict[str, Any]]
+    current_state: list[AbstractUpgradePolicy]
+    upgrade_policies: list[ClusterUpgradeSpec]
 
 
 class OCMAddonsUpgradeSchedulerOrgIntegration(
@@ -39,119 +57,216 @@ class OCMAddonsUpgradeSchedulerOrgIntegration(
     def process_upgrade_policies_in_org(
         self, dry_run: bool, org_upgrade_spec: OrganizationUpgradeSpec
     ) -> None:
-        ocm_map, addon_states = get_state_for_org_spec_per_addon(
-            org_upgrade_spec, fetch_current_state=True
-        )
-        for addon_state in addon_states:
-            version_data_map = aus.get_version_data_map(
-                dry_run=dry_run,
-                upgrade_policies=addon_state.desired_state,
-                ocm_map=ocm_map,
-                addon_id=addon_state.addon_id,
-                integration=self.name,
-            )
-            diffs = calculate_diff(
-                addon_state.current_state,
-                addon_state.desired_state,
-                ocm_map,
-                version_data_map,
-                addon_id=addon_state.addon_id,
+        with init_ocm_base_client_for_org(
+            org_upgrade_spec.org, self.secret_reader
+        ) as org_ocm_api:
+            current_state = aus.fetch_current_state(
+                org_ocm_api,
+                org_upgrade_spec,
+                addons=True,
             )
-            aus.act(dry_run, diffs, ocm_map, addon_id=addon_state.addon_id)
+
+            addons = {
+                spec.addon.id
+                for spec in org_upgrade_spec.specs
+                if isinstance(spec, ClusterAddonUpgradeSpec)
+            }
+
+            for addon_id in addons:
+                addon_org_upgrade_spec = OrganizationUpgradeSpec(
+                    org=org_upgrade_spec.org,
+                    specs=[
+                        spec
+                        for spec in org_upgrade_spec.specs
+                        if isinstance(spec, ClusterAddonUpgradeSpec)
+                        and spec.addon.id == addon_id
+                    ],
+                )
+                version_data = aus.get_version_data_map(
+                    dry_run=dry_run,
+                    org_upgrade_spec=addon_org_upgrade_spec,
+                    addon_id=addon_id,
+                    integration=self.name,
+                ).get(
+                    org_upgrade_spec.org.environment.name, org_upgrade_spec.org.org_id
+                )
+
+                addon_current_state: list[AddonUpgradePolicy] = [
+                    s
+                    for s in current_state
+                    if isinstance(s, AddonUpgradePolicy) and s.addon_id == addon_id
+                ]
+
+                self.expose_remaining_soak_day_metrics(
+                    org_upgrade_spec=org_upgrade_spec,
+                    version_data=version_data,
+                    current_state=addon_current_state,
+                    metrics_builder=functools.partial(
+                        AUSAddonVersionRemainingSoakDaysGauge,
+                        integration=self.name,
+                        ocm_env=org_upgrade_spec.org.environment.name,
+                        addon=addon_id,
+                    ),
+                )
+
+                diffs = calculate_diff(
+                    addon_current_state=addon_current_state,
+                    org_upgrade_spec=addon_org_upgrade_spec,
+                    ocm_api=org_ocm_api,
+                    version_data=version_data,
+                    addon_id=addon_id,
+                )
+                aus.act(
+                    dry_run,
+                    diffs,
+                    org_ocm_api,
+                    addon_id=addon_id,
+                )
 
     def get_ocm_env_upgrade_specs(
-        self, ocm_env: OCMEnvironment, org_name: Optional[str] = None
+        self, ocm_env: OCMEnvironment
     ) -> dict[str, OrganizationUpgradeSpec]:
-        return {
-            org.name: OrganizationUpgradeSpec(
-                org=org,
-                specs=[
-                    ClusterUpgradeSpec(
-                        name=cluster.name,
-                        ocm=org,
-                        upgradePolicy=cluster.upgrade_policy,
-                    )
-                    for cluster in org.upgrade_policy_clusters or []
-                ],
-            )
-            for org in aus_organizations_query(
-                query_func=gql.get_api().query
-            ).organizations
-            or []
-            if org.environment.name == ocm_env.name
-            and org.addon_managed_upgrades
-            and (org_name is None or org.name == org_name)
-        }
+        """
+        Build the upgrade specs for all relevant organizations. Each org spec contains
+        one spec per cluster and addon.
+        """
+        organizations = self.get_orgs_for_environment(
+            ocm_env, only_addon_managed_upgrades=True
+        )
+        if not organizations:
+            return {}
 
+        addon_service = init_addon_service(ocm_env)
 
-def get_state_for_org_spec(
-    org_upgrade_spec: OrganizationUpgradeSpec, fetch_current_state: bool
-) -> tuple[OCMMap, list[dict[str, Any]], list[dict[str, Any]]]:
-    settings = queries.get_app_interface_settings()
-    cluster_like_objects = [
-        policy.dict(by_alias=True) for policy in org_upgrade_spec.specs
-    ]
-    ocm_map = OCMMap(
-        clusters=cluster_like_objects,
-        integration=QONTRACT_INTEGRATION,
-        settings=settings,
-        init_version_gates=True,
-        init_addons=True,
-    )
-    desired_state = aus.fetch_desired_state(cluster_like_objects, ocm_map, addons=True)
-    current_state: list[dict[str, Any]] = []
-    if fetch_current_state:
-        current_state = aus.fetch_current_state(
-            cluster_like_objects,
-            ocm_map,
-            addons=True,
-        )
+        # lookup cluster in OCM to figure out if they exist
+        # and to get their UUID
+        with init_ocm_base_client(ocm_env, self.secret_reader) as ocm_api:
+            clusters = discover_clusters_for_organizations(
+                ocm_api, [org.org_id for org in organizations]
+            )
+            addon_latest_versions = addon_service.get_addon_latest_versions(ocm_api)
+            addons_per_cluster: dict[str, list[OCMAddonInstallation]] = {
+                cluster.ocm_cluster.name: addon_service.get_addons_for_cluster(
+                    ocm_api=ocm_api,
+                    cluster_id=cluster.ocm_cluster.id,
+                    addon_latest_versions=addon_latest_versions,
+                    required_state="ready",
+                )
+                for cluster in clusters
+            }
+
+        cluster_health_providers = self._health_check_providers_for_env(ocm_env.name)
 
-    return (ocm_map, current_state, desired_state)
+        return {
+            o.name: OrganizationUpgradeSpec(
+                org=o,
+                specs=self._build_addon_upgrade_spec(
+                    org=o,
+                    clusters_by_name={
+                        c.ocm_cluster.name: c.ocm_cluster
+                        for c in clusters
+                        if c.organization_id == o.org_id
+                    },
+                    addons_per_cluster=addons_per_cluster,
+                    cluster_health_provider=build_cluster_health_providers_for_organization(
+                        org=o,
+                        providers=cluster_health_providers,
+                    ),
+                ),
+            )
+            for o in organizations
+        }
 
+    def _build_addon_upgrade_spec(
+        self,
+        org: AUSOCMOrganization,
+        clusters_by_name: dict[str, OCMCluster],
+        addons_per_cluster: dict[str, list[OCMAddonInstallation]],
+        cluster_health_provider: AUSClusterHealthCheckProvider,
+    ) -> list[ClusterAddonUpgradeSpec]:
+        """
+        builds a upgrade spec objects for each addon on each cluster
+        """
+        return [
+            ClusterAddonUpgradeSpec(
+                org=org,
+                upgradePolicy=cluster.upgrade_policy,
+                cluster=clusters_by_name[cluster.name],
+                addon=addon,
+                health=cluster_health_provider.cluster_health(
+                    cluster_external_id=clusters_by_name[cluster.name].external_id,
+                    org_id=org.org_id,
+                ),
+            )
+            for cluster in org.upgrade_policy_clusters or []
+            if cluster.name in clusters_by_name
+            # clusters that are not in the dict will be ignored because
+            # they don't exist in the OCM organization (or have been deprovisioned)
+            for addon in addons_per_cluster.get(cluster.name, [])
+        ]
 
-def get_state_for_org_spec_per_addon(
-    org_upgrade_spec: OrganizationUpgradeSpec, fetch_current_state: bool
-) -> tuple[OCMMap, list[AUSOrgAddonUpgradeState]]:
-    ocm_map, current_state, desired_state = get_state_for_org_spec(
-        org_upgrade_spec, fetch_current_state
-    )
-    result = []
-    for addon_id in set(a["addon_id"] for a in desired_state):
-        addon_current_state = [c for c in current_state if c["addon_id"] == addon_id]
-        addon_desired_state = [d for d in desired_state if d["addon_id"] == addon_id]
-        result.append(
-            AUSOrgAddonUpgradeState(
-                addon_id=addon_id,
-                current_state=addon_current_state,
-                desired_state=addon_desired_state,
+    def expose_org_upgrade_spec_metrics(
+        self, ocm_env: str, org_upgrade_spec: OrganizationUpgradeSpec
+    ) -> None:
+        for cluster_upgrade_spec in org_upgrade_spec.specs:
+            if not isinstance(cluster_upgrade_spec, ClusterAddonUpgradeSpec):
+                continue
+            mutexes = cluster_upgrade_spec.upgrade_policy.conditions.mutexes
+            metrics.set_info(
+                AUSAddonUpgradePolicyInfoMetric(
+                    integration=self.name,
+                    ocm_env=ocm_env,
+                    cluster_uuid=cluster_upgrade_spec.cluster_uuid,
+                    org_id=cluster_upgrade_spec.org.org_id,
+                    org_name=org_upgrade_spec.org.name,
+                    channel=cluster_upgrade_spec.cluster.version.channel_group,
+                    current_version=cluster_upgrade_spec.current_version,
+                    cluster_name=cluster_upgrade_spec.name,
+                    schedule=cluster_upgrade_spec.upgrade_policy.schedule,
+                    sector=cluster_upgrade_spec.upgrade_policy.conditions.sector or "",
+                    mutexes=",".join(mutexes) if mutexes else "",
+                    soak_days=str(
+                        cluster_upgrade_spec.upgrade_policy.conditions.soak_days or 0
+                    ),
+                    workloads=",".join(cluster_upgrade_spec.upgrade_policy.workloads),
+                    addon=cluster_upgrade_spec.addon.id,
+                    product=cluster_upgrade_spec.cluster.product.id,
+                    hypershift=cluster_upgrade_spec.cluster.hypershift.enabled,
+                ),
             )
-        )
-    return ocm_map, result
 
 
 def calculate_diff(
-    addon_current_state: list[dict[str, Any]],
-    addon_desired_state: list[dict[str, Any]],
-    ocm_map: OCMMap,
-    version_data_map: dict[str, VersionData],
+    addon_current_state: list[AddonUpgradePolicy],
+    org_upgrade_spec: OrganizationUpgradeSpec,
+    ocm_api: OCMBaseClient,
+    version_data: VersionData,
     addon_id: str = "",
-) -> list[dict[str, str]]:
+) -> list[aus.UpgradePolicyHandler]:
     diffs = aus.calculate_diff(
         addon_current_state,
-        addon_desired_state,
-        ocm_map,
-        version_data_map,
-        addon_id=addon_id,
+        org_upgrade_spec,
+        ocm_api,
+        version_data,
+        addon_id,
     )
-    for c in addon_current_state:
-        if addon_id == c["addon_id"] and c["schedule_type"] == "automatic":
+    for current in addon_current_state:
+        if addon_id == current.addon_id and (
+            current.schedule_type == "automatic" or current.state == "completed"
+        ):
             diffs.append(
-                {
-                    "action": "delete",
-                    "cluster": c["cluster"],
-                    "version": c["schedule_type"],
-                    "id": c["id"],
-                }
+                aus.UpgradePolicyHandler(
+                    action="delete",
+                    policy=aus.AddonUpgradePolicy(
+                        cluster=current.cluster,
+                        version=current.schedule_type,
+                        id=current.id,
+                        addon_id=current.addon_id,
+                        schedule_type=current.schedule_type,
+                        addon_service=init_addon_service(
+                            org_upgrade_spec.org.environment
+                        ),
+                    ),
+                )
             )
     return diffs

reconcile/aus/ocm_upgrade_scheduler.py

@@ -1,30 +1,32 @@
-from collections import defaultdict
-from typing import Optional
+import functools
+from abc import ABC
 
-from reconcile import queries
 from reconcile.aus import base as aus
-from reconcile.aus.models import (
-    ClusterUpgradeSpec,
-    OrganizationUpgradeSpec,
+from reconcile.aus.cluster_version_data import VersionData
+from reconcile.aus.metrics import (
+    AUSClusterVersionRemainingSoakDaysGauge,
+    AUSOrganizationVersionDataGauge,
 )
-from reconcile.gql_definitions.advanced_upgrade_service.aus_clusters import (
-    query as aus_clusters_query,
-)
-from reconcile.gql_definitions.fragments.ocm_environment import OCMEnvironment
-from reconcile.utils import gql
-from reconcile.utils.disabled_integrations import integration_is_enabled
+from reconcile.aus.models import OrganizationUpgradeSpec
+from reconcile.utils import metrics
 from reconcile.utils.ocm import (
     OCM_PRODUCT_OSD,
-    OCMMap,
+    OCM_PRODUCT_ROSA,
 )
+from reconcile.utils.ocm_base_client import init_ocm_base_client_for_org
 
 QONTRACT_INTEGRATION = "ocm-upgrade-scheduler"
-SUPPORTED_OCM_PRODUCTS = [OCM_PRODUCT_OSD]
+SUPPORTED_OCM_PRODUCTS = [OCM_PRODUCT_OSD, OCM_PRODUCT_ROSA]
 
 
 class OCMClusterUpgradeSchedulerIntegration(
-    aus.AdvancedUpgradeSchedulerBaseIntegration
+    aus.AdvancedUpgradeSchedulerBaseIntegration, ABC
 ):
+    """
+    This flavor of upgrade scheduler has been made abstract to indicate that it
+    should not be used directly anymore until its code is removed.
+    """
+
     @property
     def name(self) -> str:
         return QONTRACT_INTEGRATION
@@ -32,64 +34,67 @@ class OCMClusterUpgradeSchedulerIntegration(
     def process_upgrade_policies_in_org(
         self, dry_run: bool, org_upgrade_spec: OrganizationUpgradeSpec
     ) -> None:
-        settings = queries.get_app_interface_settings()
-        cluster_like_objects = [
-            policy.dict(by_alias=True) for policy in org_upgrade_spec.specs
-        ]
+        with init_ocm_base_client_for_org(
+            org_upgrade_spec.org, self.secret_reader
+        ) as ocm_api:
+            current_state = aus.fetch_current_state(
+                ocm_api=ocm_api,
+                org_upgrade_spec=org_upgrade_spec,
+            )
 
-        ocm_map = OCMMap(
-            clusters=cluster_like_objects,
-            integration=self.name,
-            settings=settings,
-            init_version_gates=True,
-        )
-        current_state = aus.fetch_current_state(
-            clusters=cluster_like_objects, ocm_map=ocm_map
-        )
-        desired_state = aus.fetch_desired_state(
-            clusters=cluster_like_objects, ocm_map=ocm_map
-        )
-        version_data_map = aus.get_version_data_map(
-            dry_run=dry_run,
-            upgrade_policies=desired_state,
-            ocm_map=ocm_map,
-            integration=self.name,
-        )
-        diffs = aus.calculate_diff(
-            current_state, desired_state, ocm_map, version_data_map
-        )
-        aus.act(dry_run, diffs, ocm_map)
+            # expose version data metrics for the current organization
+            # this does not include inherited version data from other
+            # organizations, so that aggregations in prometheus can be more
+            # flexible
+            self.expose_version_data_metrics(
+                ocm_env=org_upgrade_spec.org.environment.name,
+                org_id=org_upgrade_spec.org.org_id,
+                version_data=aus.get_version_data_map(
+                    dry_run=True,
+                    org_upgrade_spec=org_upgrade_spec,
+                    integration=self.name,
+                    inherit_version_data=False,
+                ).get(
+                    org_upgrade_spec.org.environment.name, org_upgrade_spec.org.org_id
+                ),
+            )
 
-    def get_ocm_env_upgrade_specs(
-        self, ocm_env: OCMEnvironment, org_name: Optional[str] = None
-    ) -> dict[str, OrganizationUpgradeSpec]:
-        specs_per_org: dict[str, list[ClusterUpgradeSpec]] = defaultdict(list)
-        for cluster in (
-            aus_clusters_query(query_func=gql.get_api().query).clusters or []
-        ):
-            supported_product = (
-                cluster.spec and cluster.spec.product in SUPPORTED_OCM_PRODUCTS
+            version_data = aus.get_version_data_map(
+                dry_run=dry_run,
+                org_upgrade_spec=org_upgrade_spec,
+                integration=self.name,
+            ).get(org_upgrade_spec.org.environment.name, org_upgrade_spec.org.org_id)
+            self.expose_remaining_soak_day_metrics(
+                org_upgrade_spec=org_upgrade_spec,
+                version_data=version_data,
+                current_state=current_state,
+                metrics_builder=functools.partial(
+                    AUSClusterVersionRemainingSoakDaysGauge,
+                    integration=self.name,
+                    ocm_env=org_upgrade_spec.org.environment.name,
+                ),
             )
-            in_env_shard = cluster.ocm and ocm_env.name == cluster.ocm.environment.name
-            in_org_shard = org_name is None or (
-                cluster.ocm and cluster.ocm.name == org_name
+
+            diffs = aus.calculate_diff(
+                current_state, org_upgrade_spec, ocm_api, version_data
             )
-            in_shard = in_env_shard and in_org_shard
-            if (
-                integration_is_enabled(self.name, cluster)
-                and cluster.ocm
-                and cluster.upgrade_policy
-                and supported_product
-                and in_shard
-            ):
-                specs_per_org[cluster.ocm.name].append(
-                    ClusterUpgradeSpec(
-                        name=cluster.name,
-                        ocm=cluster.ocm,
-                        upgradePolicy=cluster.upgrade_policy,
-                    )
+            aus.act(dry_run, diffs, ocm_api)
+
+    def expose_version_data_metrics(
+        self,
+        ocm_env: str,
+        org_id: str,
+        version_data: VersionData,
+    ) -> None:
+        for version, version_history in version_data.versions.items():
+            for workload, workload_history in version_history.workloads.items():
+                metrics.set_gauge(
+                    AUSOrganizationVersionDataGauge(
+                        integration=self.name,
+                        ocm_env=ocm_env,
+                        org_id=org_id,
+                        version=version,
+                        workload=workload,
+                    ),
+                    workload_history.soak_days,
                 )
-        return {
-            org_name: OrganizationUpgradeSpec(org=specs[0].ocm, specs=specs)
-            for org_name, specs in specs_per_org.items()
-        }

reconcile/aus/ocm_upgrade_scheduler_org.py

@@ -1,15 +1,23 @@
-from typing import Optional
+from collections import defaultdict
 
+from reconcile.aus.healthchecks import (
+    AUSClusterHealthCheckProvider,
+    build_cluster_health_providers_for_organization,
+)
 from reconcile.aus.models import (
     ClusterUpgradeSpec,
+    NodePoolSpec,
     OrganizationUpgradeSpec,
 )
+from reconcile.aus.node_pool_spec import get_node_pool_specs_by_org_cluster
 from reconcile.aus.ocm_upgrade_scheduler import OCMClusterUpgradeSchedulerIntegration
-from reconcile.gql_definitions.advanced_upgrade_service.aus_organization import (
-    query as aus_organizations_query,
-)
+from reconcile.gql_definitions.fragments.aus_organization import AUSOCMOrganization
 from reconcile.gql_definitions.fragments.ocm_environment import OCMEnvironment
-from reconcile.utils import gql
+from reconcile.utils.ocm.clusters import (
+    OCMCluster,
+    discover_clusters_for_organizations,
+)
+from reconcile.utils.ocm_base_client import init_ocm_base_client
 
 QONTRACT_INTEGRATION = "ocm-upgrade-scheduler-org"
 
@@ -20,24 +28,74 @@ class OCMClusterUpgradeSchedulerOrgIntegration(OCMClusterUpgradeSchedulerIntegra
         return QONTRACT_INTEGRATION
 
     def get_ocm_env_upgrade_specs(
-        self, ocm_env: OCMEnvironment, org_name: Optional[str] = None
+        self, ocm_env: OCMEnvironment
     ) -> dict[str, OrganizationUpgradeSpec]:
-        return {
-            org.name: OrganizationUpgradeSpec(
+        organizations = self.get_orgs_for_environment(ocm_env)
+        if not organizations:
+            return {}
+
+        # lookup cluster in OCM to figure out if they exist
+        # and to get their UUID
+        with init_ocm_base_client(ocm_env, self.secret_reader) as ocm_api:
+            clusters = discover_clusters_for_organizations(
+                ocm_api, [org.org_id for org in organizations]
+            )
+
+            cluster_health_providers = self._health_check_providers_for_env(
+                ocm_env.name
+            )
+
+            clusters_by_org = defaultdict(list)
+            for cluster in clusters:
+                clusters_by_org[cluster.organization_id].append(cluster)
+
+            node_pool_specs_by_org_cluster = get_node_pool_specs_by_org_cluster(
+                ocm_api,
+                clusters_by_org,
+            )
+
+            return {
+                org.name: OrganizationUpgradeSpec(
+                    org=org,
+                    specs=self._build_cluster_upgrade_specs(
+                        org=org,
+                        clusters_by_name={
+                            c.ocm_cluster.name: c.ocm_cluster
+                            for c in clusters_by_org[org.org_id]
+                        },
+                        cluster_health_provider=build_cluster_health_providers_for_organization(
+                            org=org,
+                            providers=cluster_health_providers,
+                        ),
+                        node_pool_specs_by_cluster_id=node_pool_specs_by_org_cluster.get(
+                            org.org_id
+                        )
+                        or {},
+                    ),
+                )
+                for org in organizations
+            }
+
+    def _build_cluster_upgrade_specs(
+        self,
+        org: AUSOCMOrganization,
+        clusters_by_name: dict[str, OCMCluster],
+        cluster_health_provider: AUSClusterHealthCheckProvider,
+        node_pool_specs_by_cluster_id: dict[str, list[NodePoolSpec]],
+    ) -> list[ClusterUpgradeSpec]:
+        return [
+            ClusterUpgradeSpec(
                 org=org,
-                specs=[
-                    ClusterUpgradeSpec(
-                        name=cluster.name,
-                        ocm=org,
-                        upgradePolicy=cluster.upgrade_policy,
-                    )
-                    for cluster in org.upgrade_policy_clusters or []
-                ],
+                upgradePolicy=cluster.upgrade_policy,
+                cluster=clusters_by_name[cluster.name],
+                health=cluster_health_provider.cluster_health(
+                    cluster_external_id=clusters_by_name[cluster.name].external_id,
+                    org_id=org.org_id,
+                ),
+                nodePools=node_pool_specs_by_cluster_id.get(ocm_cluster.id) or [],
             )
-            for org in aus_organizations_query(
-                query_func=gql.get_api().query
-            ).organizations
-            or []
-            if org.environment.name == ocm_env.name
-            and (org_name is None or org.name == org_name)
-        }
+            for cluster in org.upgrade_policy_clusters or []
+            # clusters that are not in the UUID dict will be ignored because
+            # they don't exist in the OCM organization (or have been deprovisioned)
+            if (ocm_cluster := clusters_by_name.get(cluster.name))
+        ]