qontract-reconcile 0.10.2.dev269__py3-none-any.whl → 0.10.2.dev270__py3-none-any.whl

reconcile/openshift_base.py

@@ -4,6 +4,7 @@ from collections import Counter
 from collections.abc import (
     Iterable,
     Mapping,
+    MutableMapping,
     Sequence,
 )
 from dataclasses import (
@@ -27,6 +28,7 @@ from reconcile.utils import (
     differ,
     metrics,
 )
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.oc import (
     DeploymentFieldIsImmutableError,
     FieldIsImmutableError,
@@ -104,8 +106,7 @@ class HasNameAndAuthService(Protocol):
     name: str
 
     @property
-    def auth(self) -> Sequence[HasService]:
-        pass
+    def auth(self) -> Sequence[HasService]: ...
 
 
 class HasOrgAndGithubUsername(Protocol):
@@ -297,7 +298,7 @@ def populate_current_state(
     integration: str,
     integration_version: str,
     caller: str | None = None,
-):
+) -> None:
     # if spec.oc is None: - oc can't be none because init_namespace_specs_to_fetch does not create specs if oc is none
     #    return
     if not spec.oc.is_kind_supported(spec.kind):
@@ -330,7 +331,7 @@ def populate_current_state(
 def fetch_current_state(
     namespaces: Iterable[Mapping] | None = None,
     clusters: Iterable[Mapping] | None = None,
-    thread_pool_size: int | None = None,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     integration: str | None = None,
     integration_version: str | None = None,
     override_managed_types: Iterable[str] | None = None,
@@ -346,7 +347,7 @@ def fetch_current_state(
     oc_map = OC_Map(
         namespaces=namespaces,
         clusters=clusters,
-        integration=integration,
+        integration=integration or "",
         settings=settings,
         internal=internal,
         use_jump_host=use_jump_host,
@@ -377,7 +378,7 @@ def fetch_current_state(
 
 
 @retry(max_attempts=30)
-def wait_for_namespace_exists(oc, namespace):
+def wait_for_namespace_exists(oc: OCCli, namespace: str) -> None:
     if not oc.project_exists(namespace):
         raise StatusCodeError(f"namespace {namespace} does not exist")
 
@@ -541,13 +542,20 @@ def apply(
         oc.recycle_pods(dry_run, namespace, resource_type, resource)
 
 
-def create(dry_run, oc_map, cluster, namespace, resource_type, resource):
+def create(
+    dry_run: bool,
+    oc_map: ClusterMap,
+    cluster: str,
+    namespace: str,
+    resource_type: str,
+    resource: OR,
+) -> None:
     logging.info(["create", cluster, namespace, resource_type, resource.name])
 
     oc = oc_map.get(cluster)
-    if not oc:
+    if isinstance(oc, OCLogMsg):
         logging.log(level=oc.log_level, msg=oc.message)
-        return None
+        return
     if not dry_run:
         annotated = resource.annotate()
         oc.create(namespace, annotated)
@@ -585,7 +593,7 @@ def delete(
         return None
 
 
-def check_unused_resource_types(ri):
+def check_unused_resource_types(ri: ResourceInventory) -> None:
     for cluster, namespace, resource_type, data in ri:
         if not data["desired"].items():
             msg = (
@@ -1036,18 +1044,18 @@ def _realize_resource_data_3way_diff(
 
 
 def realize_data(
-    dry_run,
+    dry_run: bool,
     oc_map: ClusterMap,
     ri: ResourceInventory,
-    thread_pool_size,
-    take_over=False,
-    caller=None,
-    all_callers=None,
-    wait_for_namespace=False,
-    no_dry_run_skip_compare=False,
-    override_enable_deletion=None,
-    recycle_pods=True,
-):
+    thread_pool_size: int,
+    take_over: bool = False,
+    caller: str | None = None,
+    all_callers: Sequence[str] | None = None,
+    wait_for_namespace: bool = False,
+    no_dry_run_skip_compare: bool = False,
+    override_enable_deletion: bool | None = None,
+    recycle_pods: bool = True,
+) -> list[dict[str, Any]]:
     """
     Realize the current state to the desired state.
 
@@ -1160,7 +1168,9 @@ def validate_planned_data(ri: ResourceInventory, oc_map: ClusterMap) -> None:
 
 
 @retry(exceptions=(ValidationError), max_attempts=200)
-def validate_realized_data(actions: Iterable[dict[str, str]], oc_map: ClusterMap):
+def validate_realized_data(
+    actions: Iterable[dict[str, str]], oc_map: ClusterMap
+) -> None:
     """
     Validate the realized desired state.
 
@@ -1274,7 +1284,9 @@ def validate_realized_data(actions: Iterable[dict[str, str]], oc_map: ClusterMap
                     raise ValidationError(name)
 
 
-def follow_logs(oc_map, actions, io_dir):
+def follow_logs(
+    oc_map: ClusterMap, actions: Iterable[Mapping[str, Any]], io_dir: str
+) -> None:
     """
     Collect the logs from the owned pods into files in io_dir.
 
@@ -1295,21 +1307,29 @@ def follow_logs(oc_map, actions, io_dir):
             logging.info(["collecting", cluster, namespace, kind, name])
 
             oc = oc_map.get(cluster)
-            if not oc:
+            if isinstance(oc, OCLogMsg):
                 logging.log(level=oc.log_level, msg=oc.message)
                 continue
 
             if kind == "Job":
                 oc.job_logs(namespace, name, follow=True, output=io_dir)
             if kind == "ClowdJobInvocation":
+                if isinstance(oc, OCLogMsg):
+                    logging.log(level=oc.log_level, msg=oc.message)
+                    continue
                 resource = oc.get(namespace, kind, name=name)
                 jobs = resource.get("status", {}).get("jobMap", {})
                 for jn in jobs:
                     logging.info(["collecting", cluster, namespace, kind, jn])
+                    if isinstance(oc, OCLogMsg):
+                        logging.log(level=oc.log_level, msg=oc.message)
+                        continue
                     oc.job_logs(namespace, jn, follow=True, output=io_dir)
 
 
-def aggregate_shared_resources(namespace_info, shared_resources_type):
+def aggregate_shared_resources(
+    namespace_info: MutableMapping[str, Any], shared_resources_type: str
+) -> None:
     """This function aggregates shared resources of the desired type
     from a shared resources file to the appropriate namespace section."""
     supported_shared_resources_types = [
@@ -1348,15 +1368,13 @@ class HasOpenshiftServiceAccountTokens(Protocol):
 @runtime_checkable
 class HasSharedResourcesOpenShiftResources(Protocol):
     @property
-    def shared_resources(self) -> Sequence[HasOpenShiftResources] | None:
-        pass
+    def shared_resources(self) -> Sequence[HasOpenShiftResources] | None: ...
 
 
 @runtime_checkable
 class HasSharedResourcesOpenshiftServiceAccountTokens(Protocol):
     @property
-    def shared_resources(self) -> Sequence[HasOpenshiftServiceAccountTokens] | None:
-        pass
+    def shared_resources(self) -> Sequence[HasOpenshiftServiceAccountTokens] | None: ...
 
 
 @runtime_checkable

reconcile/openshift_clusterrolebindings.py

@@ -1,5 +1,6 @@
 import contextlib
 import sys
+from collections.abc import Callable
 
 import reconcile.openshift_base as ob
 from reconcile import queries
@@ -7,9 +8,13 @@ from reconcile.utils import (
     expiration,
     gql,
 )
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.openshift_resource import OpenshiftResource as OR
-from reconcile.utils.openshift_resource import ResourceKeyExistsError
+from reconcile.utils.openshift_resource import (
+    ResourceInventory,
+    ResourceKeyExistsError,
+)
 from reconcile.utils.semver_helper import make_semver
 
 ROLES_QUERY = """
@@ -42,7 +47,7 @@ QONTRACT_INTEGRATION = "openshift-clusterrolebindings"
 QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
 
 
-def construct_user_oc_resource(role, user):
+def construct_user_oc_resource(role: str, user: str) -> tuple[OR, str]:
     name = f"{role}-{user}"
     # Note: In OpenShift 4.x this resource is in rbac.authorization.k8s.io/v1
     body = {
@@ -60,7 +65,7 @@ def construct_user_oc_resource(role, user):
     )
 
 
-def construct_sa_oc_resource(role, namespace, sa_name):
+def construct_sa_oc_resource(role: str, namespace: str, sa_name: str) -> tuple[OR, str]:
     name = f"{role}-{namespace}-{sa_name}"
     # Note: In OpenShift 4.x this resource is in rbac.authorization.k8s.io/v1
     body = {
@@ -80,7 +85,9 @@ def construct_sa_oc_resource(role, namespace, sa_name):
     )
 
 
-def fetch_desired_state(ri, oc_map):
+def fetch_desired_state(
+    ri: ResourceInventory | None, oc_map: ob.ClusterMap
+) -> list[dict[str, str]]:
     gqlapi = gql.get_api()
     roles: list[dict] = expiration.filter(gqlapi.query(ROLES_QUERY)["roles"])
     users_desired_state = []
@@ -153,7 +160,13 @@ def fetch_desired_state(ri, oc_map):
 
 
 @defer
-def run(dry_run, thread_pool_size=10, internal=None, use_jump_host=True, defer=None):
+def run(
+    dry_run: bool,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
+    internal: bool | None = None,
+    use_jump_host: bool = True,
+    defer: Callable | None = None,
+) -> None:
     clusters = [
         cluster_info
         for cluster_info in queries.get_clusters()
@@ -169,7 +182,8 @@ def run(dry_run, thread_pool_size=10, internal=None, use_jump_host=True, defer=N
         internal=internal,
         use_jump_host=use_jump_host,
     )
-    defer(oc_map.cleanup)
+    if defer:
+        defer(oc_map.cleanup)
     fetch_desired_state(ri, oc_map)
     ob.publish_metrics(ri, QONTRACT_INTEGRATION)
     ob.realize_data(dry_run, oc_map, ri, thread_pool_size)

reconcile/openshift_groups.py

@@ -25,6 +25,7 @@ from reconcile.utils import (
     expiration,
     gql,
 )
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.oc_map import (
     OCLogMsg,
@@ -256,7 +257,7 @@ def act(diff: Mapping[str, str | None], oc_map: ClusterMap) -> None:
 @defer
 def run(
     dry_run: bool,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     internal: bool | None = None,
     use_jump_host: bool = True,
     defer: Callable | None = None,

reconcile/openshift_limitranges.py

@@ -1,10 +1,15 @@
 import logging
 import sys
+from collections.abc import Callable, Mapping, MutableMapping, Sequence
+from typing import Any
 
 import reconcile.openshift_base as ob
 from reconcile import queries
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
+from reconcile.utils.oc import OC_Map
 from reconcile.utils.openshift_resource import OpenshiftResource as OR
+from reconcile.utils.openshift_resource import ResourceInventory
 from reconcile.utils.semver_helper import make_semver
 
 QONTRACT_INTEGRATION = "openshift-limitranges"
@@ -20,7 +25,9 @@ SUPPORTED_LIMITRANGE_TYPES = (
 )
 
 
-def construct_resources(namespaces):
+def construct_resources(
+    namespaces: Sequence[MutableMapping[str, Any]],
+) -> Sequence[MutableMapping[str, Any]]:
     for namespace in namespaces:
         if "limitRanges" not in namespace:
             logging.warning(
@@ -32,7 +39,7 @@ def construct_resources(namespaces):
         # Get the linked limitRanges schema settings
         limitranges = namespace.get("limitRanges", {})
 
-        body = {
+        body: MutableMapping[str, Any] = {
             "apiVersion": "v1",
             "kind": "LimitRange",
             "metadata": {
@@ -62,7 +69,9 @@ def construct_resources(namespaces):
     return namespaces
 
 
-def add_desired_state(namespaces, ri, oc_map):
+def add_desired_state(
+    namespaces: Sequence[Mapping[str, Any]], ri: ResourceInventory, oc_map: OC_Map
+) -> None:
     for namespace in namespaces:
         cluster = namespace["cluster"]["name"]
         if not oc_map.get(cluster):
@@ -81,14 +90,14 @@ def add_desired_state(namespaces, ri, oc_map):
 
 @defer
 def run(
-    dry_run,
-    thread_pool_size=10,
-    internal=None,
-    use_jump_host=True,
-    take_over=True,
-    defer=None,
-):
-    namespaces = [
+    dry_run: bool,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
+    internal: bool | None = None,
+    use_jump_host: bool = True,
+    take_over: bool = True,
+    defer: Callable | None = None,
+) -> None:
+    namespaces: Sequence[MutableMapping[str, Any]] = [
         namespace_info
         for namespace_info in queries.get_namespaces()
         if namespace_info.get("limitRanges")
@@ -110,7 +119,8 @@ def run(
         internal=internal,
         use_jump_host=use_jump_host,
     )
-    defer(oc_map.cleanup)
+    if defer:
+        defer(oc_map.cleanup)
 
     add_desired_state(namespaces, ri, oc_map)
     ob.publish_metrics(ri, QONTRACT_INTEGRATION)

reconcile/openshift_namespace_labels.py

@@ -3,6 +3,7 @@ import sys
 from collections.abc import (
     Callable,
     Generator,
+    Sequence,
 )
 from threading import Lock
 from typing import Any
@@ -16,6 +17,7 @@ from reconcile.typed_queries.app_interface_vault_settings import (
     get_app_interface_vault_settings,
 )
 from reconcile.typed_queries.namespaces import get_namespaces
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.oc import (
     StatusCodeError,
@@ -151,7 +153,7 @@ class LabelInventory:
         else:
             upd_managed.append(key)
 
-    def reconcile(self):
+    def reconcile(self) -> None:
         """
         Finds new/old/modify labels and sets them in in the inventory under the
         CHANGED key. The managed key store updates are recorded under the
@@ -162,9 +164,21 @@ class LabelInventory:
                 continue
 
             desired = types[DESIRED]
-            managed = self.get(cluster, ns, MANAGED, [])
+            if not isinstance(desired, dict):
+                raise TypeError(
+                    f"Expected dict for desired labels, got {type(desired)}"
+                )
+            managed = self.get(cluster, ns, MANAGED) or []
             current = self.get(cluster, ns, CURRENT, {})
+            if not isinstance(current, dict):
+                raise TypeError(
+                    f"Expected dict for current labels, got {type(current)}"
+                )
             changed = self.setdefault(cluster, ns, CHANGED, {})  # noqa: B909
+            if not isinstance(changed, dict):
+                raise TypeError(
+                    f"Expected dict for changed labels, got {type(changed)}"
+                )
 
             # cleanup managed items
             for k in managed:
@@ -221,7 +235,7 @@ def get_gql_namespaces_in_shard() -> list[NamespaceV1]:
 
 
 def get_desired(
-    inventory: LabelInventory, oc_map: OCMap, namespaces: list[NamespaceV1]
+    inventory: LabelInventory, oc_map: OCMap, namespaces: Sequence[NamespaceV1]
 ) -> None:
     """
     Fill the provided label inventory with every desired info from the
@@ -289,7 +303,9 @@ def get_managed(inventory: LabelInventory, state: State) -> None:
         inventory.set(cluster=cluster, namespace=ns_name, type=MANAGED, labels=managed)
 
 
-def lookup_namespaces(cluster: str, oc_map: OCMap) -> tuple[str, dict[str, Any] | None]:
+def lookup_namespaces(
+    cluster: str, oc_map: OCMap
+) -> tuple[str, list[dict[str, Any]] | None]:
     """
     Retrieve all namespaces from the given cluster
     """
@@ -402,7 +418,7 @@ class NamespaceLabelError(Exception):
 @defer
 def run(
     dry_run: bool,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     internal: bool | None = None,
     use_jump_host: bool = True,
     defer: Callable | None = None,

reconcile/openshift_namespaces.py

@@ -17,6 +17,7 @@ from reconcile.typed_queries.app_interface_vault_settings import (
     get_app_interface_vault_settings,
 )
 from reconcile.typed_queries.namespaces_minimal import get_namespaces_minimal
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.oc_filters import filter_namespaces_by_cluster_and_namespace
 from reconcile.utils.oc_map import (
@@ -141,7 +142,7 @@ def check_results(
 @defer
 def run(
     dry_run: bool,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     internal: bool | None = None,
     use_jump_host: bool = True,
     cluster_name: Sequence[str] | None = None,

reconcile/openshift_network_policies.py

@@ -1,12 +1,16 @@
 import logging
 import sys
+from collections.abc import Callable, Iterable, Mapping
 from textwrap import indent
+from typing import Any
 
 import reconcile.openshift_base as ob
 from reconcile import queries
 from reconcile.utils import gql
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.openshift_resource import OpenshiftResource as OR
+from reconcile.utils.openshift_resource import ResourceInventory
 from reconcile.utils.semver_helper import make_semver
 from reconcile.utils.sharding import is_in_shard
 
@@ -54,7 +58,7 @@ QONTRACT_INTEGRATION = "openshift-network-policies"
 QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
 
 
-def construct_oc_resource(name, source_ns):
+def construct_oc_resource(name: str, source_ns: str) -> OR:
     body = {
         "apiVersion": "networking.k8s.io/v1",
         "kind": "NetworkPolicy",
@@ -82,13 +86,17 @@ def construct_oc_resource(name, source_ns):
     )
 
 
-def fetch_desired_state(namespaces, ri, oc_map):
+def fetch_desired_state(
+    namespaces: Iterable[Mapping[str, Any]],
+    ri: ResourceInventory,
+    oc_map: ob.ClusterMap,
+) -> None:
     for namespace_info in namespaces:
         namespace = namespace_info["name"]
         cluster = namespace_info["cluster"]["name"]
         if not oc_map.get(cluster):
             continue
-        source_namespaces = namespace_info["networkPoliciesAllow"]
+        source_namespaces = namespace_info.get("networkPoliciesAllow") or []
         for source_namespace_info in source_namespaces:
             source_namespace = source_namespace_info["name"]
             source_cluster = source_namespace_info["cluster"]["name"]
@@ -110,11 +118,21 @@ def fetch_desired_state(namespaces, ri, oc_map):
 
 
 @defer
-def run(dry_run, thread_pool_size=10, internal=None, use_jump_host=True, defer=None):
+def run(
+    dry_run: bool,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
+    internal: bool | None = None,
+    use_jump_host: bool = True,
+    defer: Callable | None = None,
+) -> None:
     gqlapi = gql.get_api()
 
     namespaces = []
-    for namespace_info in gqlapi.query(NAMESPACES_QUERY)["namespaces"]:
+    namespaces_query_result = gqlapi.query(NAMESPACES_QUERY)
+    if not namespaces_query_result:
+        return
+
+    for namespace_info in namespaces_query_result["namespaces"]:
         if not namespace_info.get("networkPoliciesAllow"):
             continue
         if ob.is_namespace_deleted(namespace_info):
@@ -136,7 +154,8 @@ def run(dry_run, thread_pool_size=10, internal=None, use_jump_host=True, defer=N
         internal=internal,
         use_jump_host=use_jump_host,
     )
-    defer(oc_map.cleanup)
+    if defer:
+        defer(oc_map.cleanup)
     fetch_desired_state(namespaces, ri, oc_map)
     ob.publish_metrics(ri, QONTRACT_INTEGRATION)
     ob.realize_data(dry_run, oc_map, ri, thread_pool_size)

reconcile/openshift_prometheus_rules.py

@@ -2,6 +2,7 @@ from collections.abc import Iterable
 from typing import Any
 
 import reconcile.openshift_resources_base as orb
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.runtime.integration import DesiredStateShardConfig
 from reconcile.utils.semver_helper import make_semver
 
@@ -12,7 +13,7 @@ PROVIDERS = ["prometheus-rule"]
 
 def run(
     dry_run: bool,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     internal: bool | None = None,
     use_jump_host: bool = True,
     cluster_name: Iterable[str] | None = None,

reconcile/openshift_resourcequotas.py

@@ -1,19 +1,23 @@
 import logging
 import sys
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any
 
 import reconcile.openshift_base as ob
 from reconcile import queries
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.helpers import flatten
 from reconcile.utils.openshift_resource import OpenshiftResource as OR
+from reconcile.utils.openshift_resource import ResourceInventory
 from reconcile.utils.semver_helper import make_semver
 
 QONTRACT_INTEGRATION = "openshift-resourcequotas"
 QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
 
 
-def construct_resource(quota):
-    body = {
+def construct_resource(quota: Mapping[str, Any]) -> OR:
+    body: dict[str, Any] = {
         "apiVersion": "v1",
         "kind": "ResourceQuota",
         "metadata": {"name": quota["name"]},
@@ -31,13 +35,17 @@ def construct_resource(quota):
     )
 
 
-def fetch_desired_state(namespaces, ri, oc_map):
+def fetch_desired_state(
+    namespaces: Iterable[Mapping[str, Any]],
+    ri: ResourceInventory,
+    oc_map: ob.ClusterMap,
+) -> None:
     for namespace_info in namespaces:
         namespace = namespace_info["name"]
         cluster = namespace_info["cluster"]["name"]
         if not oc_map.get(cluster):
             continue
-        quotas = namespace_info["quota"]["quotas"]
+        quotas = (namespace_info.get("quota") or {}).get("quotas") or []
         for quota in quotas:
             quota_name = quota["name"]
             quota_resource = construct_resource(quota)
@@ -48,13 +56,13 @@ def fetch_desired_state(namespaces, ri, oc_map):
 
 @defer
 def run(
-    dry_run,
-    thread_pool_size=10,
-    internal=None,
-    use_jump_host=True,
-    take_over=True,
-    defer=None,
-):
+    dry_run: bool,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
+    internal: bool | None = None,
+    use_jump_host: bool = True,
+    take_over: bool = True,
+    defer: Callable | None = None,
+) -> None:
     namespaces = [
         namespace_info
         for namespace_info in queries.get_namespaces()
@@ -74,7 +82,8 @@ def run(
         internal=internal,
         use_jump_host=use_jump_host,
     )
-    defer(oc_map.cleanup)
+    if defer:
+        defer(oc_map.cleanup)
     fetch_desired_state(namespaces, ri, oc_map)
     ob.publish_metrics(ri, QONTRACT_INTEGRATION)
     ob.realize_data(dry_run, oc_map, ri, thread_pool_size)

reconcile/openshift_resources.py

@@ -3,6 +3,7 @@ from typing import Any
 
 import reconcile.openshift_base as ob
 import reconcile.openshift_resources_base as orb
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.runtime.integration import DesiredStateShardConfig
 from reconcile.utils.semver_helper import make_semver
 
@@ -13,7 +14,7 @@ PROVIDERS = ["resource", "resource-template"]
 
 def run(
     dry_run: bool,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     internal: bool | None = None,
     use_jump_host: bool = True,
     cluster_name: Iterable[str] | None = None,

reconcile/openshift_resources_base.py

@@ -40,6 +40,7 @@ from reconcile.utils import (
     gql,
     openssl,
 )
+from reconcile.utils.constants import DEFAULT_THREAD_POOL_SIZE
 from reconcile.utils.defer import defer
 from reconcile.utils.exceptions import FetchResourceError
 from reconcile.utils.jinja2.utils import (
@@ -899,7 +900,7 @@ def get_namespaces(
 @defer
 def run(
     dry_run: bool,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
     internal: bool | None = None,
     use_jump_host: bool = True,
     providers: Sequence[str] | None = None,
@@ -1094,7 +1095,7 @@ def get_cluster_scoped_resources(
     oc_map: OC_Map,
     clusters: Iterable[str],
     namespaces: Iterable[Mapping[str, Any]] | None = None,
-    thread_pool_size: int = 10,
+    thread_pool_size: int = DEFAULT_THREAD_POOL_SIZE,
 ) -> dict[str, dict[str, dict[str, list[str]]]]:
     """Returns cluster scoped resources for a list of clusters