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

reconcile/openshift_namespace_labels.py

@@ -5,11 +5,7 @@ from collections.abc import (
     Generator,
 )
 from threading import Lock
-from typing import (
-    Any,
-    Optional,
-    Union,
-)
+from typing import Any
 
 from kubernetes.client.exceptions import ApiException
 from sretoolbox.utils import threaded
@@ -47,9 +43,9 @@ CURRENT = "current"
 CHANGED = "changed"
 UPDATED_MANAGED = "updated-managed"
 
-Labels = dict[str, Optional[str]]
+Labels = dict[str, str | None]
 LabelKeys = list[str]
-LabelsOrKeys = Union[Labels, LabelKeys]
+LabelsOrKeys = Labels | LabelKeys
 Types = dict[str, LabelsOrKeys]
 
 InternalLabelInventory = dict[str, dict[str, Types]]
@@ -104,8 +100,8 @@ class LabelInventory:
         cluster: str,
         namespace: str,
         type: str,
-        default: Optional[LabelsOrKeys] = None,
-    ) -> Optional[LabelsOrKeys]:
+        default: LabelsOrKeys | None = None,
+    ) -> LabelsOrKeys | None:
         """Get the labels or keys for the given cluster / namespace / type"""
         return self._inv.get(cluster, {}).get(namespace, {}).get(type, default)
 
@@ -168,7 +164,7 @@ class LabelInventory:
             desired = types[DESIRED]
             managed = self.get(cluster, ns, MANAGED, [])
             current = self.get(cluster, ns, CURRENT, {})
-            changed = self.setdefault(cluster, ns, CHANGED, {})
+            changed = self.setdefault(cluster, ns, CHANGED, {})  # noqa: B909
 
             # cleanup managed items
             for k in managed:
@@ -182,21 +178,21 @@ class LabelInventory:
                     if k not in managed:
                         self.update_managed_keys(cluster, ns, k)
                     changed[k] = v
-                else:  # k in current:
-                    if k not in managed:  # conflicting labels
-                        self.add_error(
-                            cluster,
-                            ns,
-                            "Label conflict:"
-                            + f"desired {k}={v} vs "
-                            + f"current {k}={current[k]}",
-                        )
-                    else:
-                        if v != current[k]:
-                            changed[k] = v
+
+                elif k not in managed:  # conflicting labels
+                    self.add_error(
+                        cluster,
+                        ns,
+                        "Label conflict:"
+                        + f"desired {k}={v} vs "
+                        + f"current {k}={current[k]}",
+                    )
+
+                elif v != current[k]:
+                    changed[k] = v
 
             # remove old labels
-            for k, v in current.items():
+            for k, _ in current.items():
                 if k in managed and k not in desired:
                     changed[k] = None
 
@@ -293,9 +289,7 @@ 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, Optional[dict[str, Any]]]:
+def lookup_namespaces(cluster: str, oc_map: OCMap) -> tuple[str, dict[str, Any] | None]:
     """
     Retrieve all namespaces from the given cluster
     """
@@ -410,9 +404,9 @@ class NamespaceLabelError(Exception):
 def run(
     dry_run: bool,
     thread_pool_size: int = 10,
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
-    defer: Optional[Callable] = None,
+    defer: Callable | None = None,
     raise_errors: bool = False,
 ) -> None:
     _LOG.debug("Collecting GQL data ...")

reconcile/openshift_namespaces.py

@@ -4,14 +4,13 @@ from collections.abc import (
     Callable,
     Iterable,
     Mapping,
+    Sequence,
 )
-from typing import (
-    Any,
-    Optional,
-)
+from typing import Any
 
 from sretoolbox.utils import threaded
 
+import reconcile.openshift_base as ob
 from reconcile.gql_definitions.common.namespaces_minimal import NamespaceV1
 from reconcile.status import ExitCodes
 from reconcile.typed_queries.app_interface_vault_settings import (
@@ -41,20 +40,17 @@ DUPLICATES_LOG_MSG = "Found multiple definitions for the namespace {key}"
 
 
 def get_desired_state(namespaces: Iterable[NamespaceV1]) -> list[dict[str, str]]:
-
     desired_state: list[dict[str, str]] = []
     for ns in namespaces:
         state = NS_STATE_PRESENT
         if ns.delete:
             state = NS_STATE_ABSENT
 
-        desired_state.append(
-            {
-                "cluster": ns.cluster.name,
-                "namespace": ns.name,
-                "desired_state": state,
-            }
-        )
+        desired_state.append({
+            "cluster": ns.cluster.name,
+            "namespace": ns.name,
+            "desired_state": state,
+        })
 
     return desired_state
 
@@ -62,7 +58,6 @@ def get_desired_state(namespaces: Iterable[NamespaceV1]) -> list[dict[str, str]]
 def get_shard_namespaces(
     namespaces: Iterable[NamespaceV1],
 ) -> tuple[list[NamespaceV1], bool]:
-
     # Structure holding duplicates by namespace key
     duplicates: dict[str, list[NamespaceV1]] = {}
     # namespace filtered list without duplicates
@@ -116,6 +111,8 @@ def manage_namespaces(spec: Mapping[str, str], oc_map: OCMap, dry_run: bool) ->
     exists = oc.project_exists(namespace)
     action = None
     if not exists and desired_state == NS_STATE_PRESENT:
+        if namespace.startswith("openshift-"):
+            raise ValueError('cannot request a project starting with "openshift-"')
         action = NS_ACTION_CREATE
     elif exists and desired_state == NS_STATE_ABSENT:
         action = NS_ACTION_DELETE
@@ -130,12 +127,12 @@ def check_results(
     desired_state: Iterable[Mapping[str, str]], results: Iterable[Any]
 ) -> bool:
     err = False
-    for s, e in zip(desired_state, results):
+    for s, e in zip(desired_state, results, strict=False):
         if isinstance(e, Exception):
             err = True
             msg = (
                 f'cluster: {s["cluster"]}, namespace: {s["namespace"]}, '
-                f"exception: {str(e)}"
+                f"exception: {e!s}"
             )
             logging.error(msg)
     return err
@@ -145,19 +142,18 @@ def check_results(
 def run(
     dry_run: bool,
     thread_pool_size: int = 10,
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
-    cluster_name: Optional[str] = None,
-    namespace_name: Optional[str] = None,
-    defer: Optional[Callable] = None,
+    cluster_name: Sequence[str] | None = None,
+    namespace_name: Sequence[str] | None = None,
+    defer: Callable | None = None,
 ) -> None:
-
     all_namespaces = get_namespaces_minimal()
     shard_namespaces, duplicates = get_shard_namespaces(all_namespaces)
     namespaces = filter_namespaces_by_cluster_and_namespace(
         namespaces=shard_namespaces,
-        cluster_name=cluster_name,
-        namespace_name=namespace_name,
+        cluster_names=cluster_name,
+        namespace_names=namespace_name,
     )
 
     desired_state = get_desired_state(namespaces)
@@ -178,6 +174,10 @@ def run(
     if defer:
         defer(oc_map.cleanup)
 
+    ob.publish_cluster_desired_metrics_from_state(
+        desired_state, QONTRACT_INTEGRATION, "Namespace"
+    )
+
     results = threaded.run(
         manage_namespaces,
         desired_state,

reconcile/openshift_network_policies.py

@@ -48,9 +48,7 @@ NAMESPACES_QUERY = """
     }
   }
 }
-""" % (
-    indent(queries.JUMPHOST_FIELDS, 8 * " "),
-)
+""" % (indent(queries.JUMPHOST_FIELDS, 8 * " "),)
 
 QONTRACT_INTEGRATION = "openshift-network-policies"
 QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
@@ -96,12 +94,10 @@ def fetch_desired_state(namespaces, ri, oc_map):
             source_cluster = source_namespace_info["cluster"]["name"]
             if cluster != source_cluster:
                 ri.register_error()
-                msg = ("[{}/{}] Network Policy from cluster '{}' not allowed.").format(
-                    cluster, namespace, source_cluster
-                )
+                msg = f"[{cluster}/{namespace}] Network Policy from cluster '{source_cluster}' not allowed."
                 logging.error(msg)
                 continue
-            resource_name = "allow-from-{}-namespace".format(source_namespace)
+            resource_name = f"allow-from-{source_namespace}-namespace"
             oc_resource = construct_oc_resource(resource_name, source_namespace)
             ri.add_desired(
                 cluster,
@@ -115,7 +111,6 @@ 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):
-
     gqlapi = gql.get_api()
 
     namespaces = []
@@ -143,6 +138,7 @@ def run(dry_run, thread_pool_size=10, internal=None, use_jump_host=True, defer=N
     )
     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)
 
     if ri.has_error_registered():

reconcile/openshift_prometheus_rules.py

@@ -0,0 +1,43 @@
+from collections.abc import Iterable
+from typing import Any
+
+import reconcile.openshift_resources_base as orb
+from reconcile.utils.runtime.integration import DesiredStateShardConfig
+from reconcile.utils.semver_helper import make_semver
+
+QONTRACT_INTEGRATION = "openshift-prometheus-rules"
+QONTRACT_INTEGRATION_VERSION = make_semver(1, 0, 0)
+PROVIDERS = ["prometheus-rule"]
+
+
+def run(
+    dry_run: bool,
+    thread_pool_size: int = 10,
+    internal: bool | None = None,
+    use_jump_host: bool = True,
+    cluster_name: Iterable[str] | None = None,
+    exclude_cluster: Iterable[str] | None = None,
+    namespace_name: str | None = None,
+) -> None:
+    orb.QONTRACT_INTEGRATION = QONTRACT_INTEGRATION
+    orb.QONTRACT_INTEGRATION_VERSION = QONTRACT_INTEGRATION_VERSION
+
+    orb.run(
+        dry_run=dry_run,
+        thread_pool_size=thread_pool_size,
+        internal=internal,
+        use_jump_host=use_jump_host,
+        providers=PROVIDERS,
+        cluster_name=cluster_name,
+        exclude_cluster=exclude_cluster,
+        namespace_name=namespace_name,
+        init_api_resources=True,
+    )
+
+
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
+    return orb.early_exit_desired_state(PROVIDERS)
+
+
+def desired_state_shard_config() -> DesiredStateShardConfig:
+    return orb.desired_state_shard_config()

reconcile/openshift_resourcequotas.py

@@ -1,10 +1,10 @@
-import collections
 import logging
 import sys
 
 import reconcile.openshift_base as ob
 from reconcile import queries
 from reconcile.utils.defer import defer
+from reconcile.utils.helpers import flatten
 from reconcile.utils.openshift_resource import OpenshiftResource as OR
 from reconcile.utils.semver_helper import make_semver
 
@@ -12,20 +12,6 @@ QONTRACT_INTEGRATION = "openshift-resourcequotas"
 QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
 
 
-# Copied with love from https://stackoverflow.com/questions/6027558
-def flatten(d, parent_key="", sep="."):
-    items = []
-    for k, v in d.items():
-        if v is None:
-            continue
-        new_key = parent_key + sep + k if parent_key else k
-        if isinstance(v, collections.MutableMapping):
-            items.extend(flatten(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, str(v)))
-    return dict(items)
-
-
 def construct_resource(quota):
     body = {
         "apiVersion": "v1",
@@ -69,7 +55,6 @@ def run(
     take_over=True,
     defer=None,
 ):
-
     namespaces = [
         namespace_info
         for namespace_info in queries.get_namespaces()
@@ -91,6 +76,7 @@ def run(
     )
     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)
 
     if ri.has_error_registered():

reconcile/openshift_resources.py

@@ -1,3 +1,4 @@
+from collections.abc import Iterable
 from typing import Any
 
 import reconcile.openshift_base as ob
@@ -7,18 +8,18 @@ from reconcile.utils.semver_helper import make_semver
 
 QONTRACT_INTEGRATION = "openshift_resources"
 QONTRACT_INTEGRATION_VERSION = make_semver(1, 9, 3)
-PROVIDERS = ["resource", "resource-template", "prometheus-rule"]
+PROVIDERS = ["resource", "resource-template"]
 
 
 def run(
-    dry_run,
-    thread_pool_size=10,
-    internal=None,
-    use_jump_host=True,
-    cluster_name=None,
-    namespace_name=None,
-    defer=None,
-):
+    dry_run: bool,
+    thread_pool_size: int = 10,
+    internal: bool | None = None,
+    use_jump_host: bool = True,
+    cluster_name: Iterable[str] | None = None,
+    exclude_cluster: Iterable[str] | None = None,
+    namespace_name: str | None = None,
+) -> None:
     orb.QONTRACT_INTEGRATION = QONTRACT_INTEGRATION
     orb.QONTRACT_INTEGRATION_VERSION = QONTRACT_INTEGRATION_VERSION
 
@@ -29,6 +30,7 @@ def run(
         use_jump_host=use_jump_host,
         providers=PROVIDERS,
         cluster_name=cluster_name,
+        exclude_cluster=exclude_cluster,
         namespace_name=namespace_name,
         init_api_resources=True,
     )
@@ -39,7 +41,7 @@ def run(
         ob.check_unused_resource_types(ri)
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     return orb.early_exit_desired_state(PROVIDERS)