qontract-reconcile 0.10.2.dev44__tar.gz → 0.10.2.dev46__tar.gz

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qontract-reconcile
-Version: 0.10.2.dev44
+Version: 0.10.2.dev46
 Summary: Collection of tools to reconcile services with their desired state as defined in the app-interface DB.
 Project-URL: homepage, https://github.com/app-sre/qontract-reconcile
 Project-URL: repository, https://github.com/app-sre/qontract-reconcile

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/external_resources/aws.py

@@ -1,9 +1,11 @@
+import re
 from abc import ABC, abstractmethod
 from typing import Any
 
 from reconcile.external_resources.model import (
     ExternalResource,
     ExternalResourceKey,
+    ExternalResourceModuleConfiguration,
     ExternalResourcesInventory,
 )
 from reconcile.utils.external_resource_spec import (
@@ -21,10 +23,18 @@ class AWSResourceFactory(ABC):
         self.secret_reader = secret_reader
 
     @abstractmethod
-    def resolve(self, spec: ExternalResourceSpec) -> dict[str, Any]: ...
+    def resolve(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> dict[str, Any]: ...
 
     @abstractmethod
-    def validate(self, resource: ExternalResource) -> None: ...
+    def validate(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None: ...
 
     def find_linked_resources(
         self, spec: ExternalResourceSpec
@@ -35,10 +45,18 @@ class AWSResourceFactory(ABC):
 
 
 class AWSDefaultResourceFactory(AWSResourceFactory):
-    def resolve(self, spec: ExternalResourceSpec) -> dict[str, Any]:
+    def resolve(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> dict[str, Any]:
         return ResourceValueResolver(spec=spec, identifier_as_value=True).resolve()
 
-    def validate(self, resource: ExternalResource) -> None: ...
+    def validate(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None: ...
 
 
 class AWSElasticacheFactory(AWSDefaultResourceFactory):
@@ -49,7 +67,11 @@ class AWSElasticacheFactory(AWSDefaultResourceFactory):
             "aws", provisioner, "elasticache", identifier
         )
 
-    def resolve(self, spec: ExternalResourceSpec) -> dict[str, Any]:
+    def resolve(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> dict[str, Any]:
         """Resolve the elasticache resource specification and translate some attributes to AWS >= 5.60.0 provider format."""
         rvr = ResourceValueResolver(spec=spec, identifier_as_value=True)
         data = rvr.resolve()
@@ -70,7 +92,11 @@ class AWSElasticacheFactory(AWSDefaultResourceFactory):
 
         return data
 
-    def validate(self, resource: ExternalResource) -> None:
+    def validate(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None:
         """Validate the elasticache resource specification."""
         data = resource.data
         if data.get("parameter_group"):
@@ -96,6 +122,8 @@ class AWSElasticacheFactory(AWSDefaultResourceFactory):
 
 
 class AWSRdsFactory(AWSDefaultResourceFactory):
+    TIMEOUT_RE = re.compile(r"^\d+m$")
+
     def _get_source_db_spec(
         self, provisioner: str, identifier: str
     ) -> ExternalResourceSpec:
@@ -110,7 +138,11 @@ class AWSRdsFactory(AWSDefaultResourceFactory):
             "aws", provisioner, "kms", identifier
         )
 
-    def resolve(self, spec: ExternalResourceSpec) -> dict[str, Any]:
+    def resolve(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> dict[str, Any]:
         rvr = ResourceValueResolver(spec=spec, identifier_as_value=True)
         data = rvr.resolve()
 
@@ -126,7 +158,7 @@ class AWSRdsFactory(AWSDefaultResourceFactory):
             sourcedb_spec = self._get_source_db_spec(
                 spec.provisioner_name, data["replica_source"]
             )
-            sourcedb = self.resolve(sourcedb_spec)
+            sourcedb = self.resolve(sourcedb_spec, module_conf)
             sourcedb_region = (
                 sourcedb.get("region", None)
                 or sourcedb_spec.provisioner["resources_default_region"]
@@ -142,9 +174,59 @@ class AWSRdsFactory(AWSDefaultResourceFactory):
                 spec.provisioner_name, kms_key_id
             ).identifier
 
+        # If not timeouts are set, set default timeouts according to the module reconcile timeout configuration
+        # 5 minutes are substracted to let terraform finish gracefully before the Job is killed.
+        if "timeouts" not in data:
+            data["timeouts"] = {
+                "create": f"{module_conf.reconcile_timeout_minutes - 5}m",
+                "update": f"{module_conf.reconcile_timeout_minutes - 5}m",
+                "delete": f"{module_conf.reconcile_timeout_minutes - 5}m",
+            }
         return data
 
-    def validate(self, resource: ExternalResource) -> None: ...
+    def _get_timeout_minutes(
+        self,
+        timeout: str,
+    ) -> int:
+        if not re.match(AWSRdsFactory.TIMEOUT_RE, timeout):
+            raise ValueError(
+                f"Invalid RDS instance timeout format: {timeout}. Specify timeout in minutes(m)."
+            )
+        return int(timeout[:-1])
+
+    def _validate_timeouts(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None:
+        timeouts = resource.data.get("timeouts")
+        if not timeouts:
+            return
+
+        if not isinstance(timeouts, dict):
+            raise ValueError(
+                "Timeouts must be a dictionary with 'create', 'update' and/or 'delete' keys."
+            )
+
+        allowed_keys = {"create", "update", "delete"}
+        if unknown_keys := timeouts.keys() - allowed_keys:
+            raise ValueError(
+                f"Timeouts must be a dictionary with 'create', 'update' and/or 'delete' keys. Offending keys: {unknown_keys}."
+            )
+
+        for option, timeout in timeouts.items():
+            timeout_minutes = self._get_timeout_minutes(timeout)
+            if timeout_minutes >= module_conf.reconcile_timeout_minutes:
+                raise ValueError(
+                    f"RDS instance {option} timeout value {timeout_minutes} must be lower than the module reconcile_timeout_minutes value {module_conf.reconcile_timeout_minutes}."
+                )
+
+    def validate(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None:
+        self._validate_timeouts(resource, module_conf)
 
     def find_linked_resources(
         self, spec: ExternalResourceSpec
@@ -166,7 +248,11 @@ class AWSMskFactory(AWSDefaultResourceFactory):
             "aws", provisioner, "msk", identifier
         )
 
-    def resolve(self, spec: ExternalResourceSpec) -> dict[str, Any]:
+    def resolve(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> dict[str, Any]:
         rvr = ResourceValueResolver(spec=spec, identifier_as_value=True)
         data = rvr.resolve()
         data["output_prefix"] = spec.output_prefix
@@ -188,7 +274,11 @@ class AWSMskFactory(AWSDefaultResourceFactory):
             del data["users"]
         return data
 
-    def validate(self, resource: ExternalResource) -> None:
+    def validate(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None:
         data = resource.data
         if (
             data["number_of_broker_nodes"]

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/external_resources/factories.py

@@ -15,6 +15,7 @@ from reconcile.external_resources.meta import QONTRACT_INTEGRATION
 from reconcile.external_resources.model import (
     ExternalResource,
     ExternalResourceKey,
+    ExternalResourceModuleConfiguration,
     ExternalResourceProvision,
     ExternalResourcesInventory,
     ModuleInventory,
@@ -55,11 +56,19 @@ class ObjectFactory(Generic[T]):
 
 class ExternalResourceFactory(ABC):
     @abstractmethod
-    def create_external_resource(self, spec: ExternalResourceSpec) -> ExternalResource:
+    def create_external_resource(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> ExternalResource:
         pass
 
     @abstractmethod
-    def validate_external_resource(self, resource: ExternalResource) -> None:
+    def validate_external_resource(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None:
         pass
 
     def find_linked_resources(
@@ -121,9 +130,13 @@ class AWSExternalResourceFactory(ExternalResourceFactory):
         self.er_inventory = er_inventory
         self.secret_reader = secret_reader
 
-    def create_external_resource(self, spec: ExternalResourceSpec) -> ExternalResource:
+    def create_external_resource(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> ExternalResource:
         f = self.resource_factories.get_factory(spec.provider)
-        data = f.resolve(spec)
+        data = f.resolve(spec, module_conf)
         data["tags"] = spec.tags(integration=QONTRACT_INTEGRATION)
         data["default_tags"] = AWS_DEFAULT_TAGS
 
@@ -152,9 +165,13 @@ class AWSExternalResourceFactory(ExternalResourceFactory):
 
         return ExternalResource(data=data, provision=provision)
 
-    def validate_external_resource(self, resource: ExternalResource) -> None:
+    def validate_external_resource(
+        self,
+        resource: ExternalResource,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> None:
         f = self.resource_factories.get_factory(resource.provision.provider)
-        f.validate(resource)
+        f.validate(resource, module_conf)
 
     def find_linked_resources(
         self, spec: ExternalResourceSpec

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/external_resources/manager.py

@@ -197,8 +197,11 @@ class ExternalResourcesManager:
             if spec.marked_to_delete:
                 continue
             module = self.module_inventory.get_from_spec(spec)
+            module_conf = ExternalResourceModuleConfiguration.resolve_configuration(
+                module, spec, self.settings
+            )
             try:
-                resource = self._build_external_resource(spec)
+                resource = self._build_external_resource(spec, module_conf)
             except ExternalResourceValidationError as e:
                 self.errors[key] = e
                 continue
@@ -208,9 +211,7 @@ class ExternalResourcesManager:
                 resource_hash=resource.hash(),
                 input=resource.json(),
                 action=Action.APPLY,
-                module_configuration=ExternalResourceModuleConfiguration.resolve_configuration(
-                    module, spec, self.settings
-                ),
+                module_configuration=module_conf,
                 linked_resources=self._find_linked_resources(spec),
             )
             r.add(reconciliation)
@@ -362,10 +363,14 @@ class ExternalResourcesManager:
                 )
                 self.state_mgr.update_resource_status(key, ResourceStatus.CREATED)
 
-    def _build_external_resource(self, spec: ExternalResourceSpec) -> ExternalResource:
+    def _build_external_resource(
+        self,
+        spec: ExternalResourceSpec,
+        module_conf: ExternalResourceModuleConfiguration,
+    ) -> ExternalResource:
         f = self.factories.get_factory(spec.provision_provider)
-        resource = f.create_external_resource(spec)
-        f.validate_external_resource(resource)
+        resource = f.create_external_resource(spec, module_conf)
+        f.validate_external_resource(resource, module_conf)
         return resource
 
     def _find_linked_resources(

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/external_resources/model.py

@@ -18,7 +18,6 @@ from reconcile.gql_definitions.external_resources.external_resources_modules imp
     ExternalResourcesModuleV1,
 )
 from reconcile.gql_definitions.external_resources.external_resources_namespaces import (
-    ExternalResourcesModuleOverridesV1,
     NamespaceTerraformProviderResourceAWSV1,
     NamespaceTerraformResourceElastiCacheV1,
     NamespaceTerraformResourceKMSV1,
@@ -29,6 +28,10 @@ from reconcile.gql_definitions.external_resources.external_resources_namespaces
 from reconcile.gql_definitions.external_resources.external_resources_settings import (
     ExternalResourcesSettingsV1,
 )
+from reconcile.gql_definitions.external_resources.fragments.external_resources_module_overrides import (
+    ExternalResourcesModuleOverrides,
+)
+from reconcile.gql_definitions.fragments.deplopy_resources import DeployResourcesFields
 from reconcile.utils.exceptions import FetchResourceError
 from reconcile.utils.external_resource_spec import (
     ExternalResourceSpec,
@@ -220,6 +223,38 @@ def load_module_inventory(
     })
 
 
+class ResourcesSpec(BaseModel, frozen=True):
+    cpu: str | None = None
+    memory: str | None = None
+
+
+class Resources(BaseModel, frozen=True):
+    """Hashable class to store module resources in reconciliations.
+    Default values are used as a fallback for existent objects that were
+    created without container resources, hence they don't have mem/cpu resources
+    in the ERv2 State. Eventually, all resources will have resources assignments
+    from the module spec, module_overrides, or app-interface settings.
+    """
+
+    requests: ResourcesSpec = ResourcesSpec()
+    limits: ResourcesSpec = ResourcesSpec()
+
+    @staticmethod
+    def from_deploy_resources_fields(fields: DeployResourcesFields) -> "Resources":
+        """Create Resource obect from GQL DeployResourcesFields.
+
+        DeployResourceFields can not be used directly as it not hashable."""
+        return Resources(
+            requests=ResourcesSpec(
+                cpu=fields.requests.cpu, memory=fields.requests.memory
+            ),
+            limits=ResourcesSpec(
+                cpu=fields.limits.cpu,
+                memory=fields.limits.memory,
+            ),
+        )
+
+
 class ExternalResourceModuleConfiguration(BaseModel, frozen=True):
     image: str = ""
     version: str = ""
@@ -227,6 +262,7 @@ class ExternalResourceModuleConfiguration(BaseModel, frozen=True):
     reconcile_timeout_minutes: int = -1000
     outputs_secret_image: str = ""
     outputs_secret_version: str = ""
+    resources: Resources = Resources()
 
     @property
     def image_version(self) -> str:
@@ -244,13 +280,14 @@ class ExternalResourceModuleConfiguration(BaseModel, frozen=True):
     ) -> "ExternalResourceModuleConfiguration":
         module_overrides = spec.metadata.get(
             "module_overrides"
-        ) or ExternalResourcesModuleOverridesV1(
+        ) or ExternalResourcesModuleOverrides(
             module_type=None,
             image=None,
             version=None,
             reconcile_timeout_minutes=None,
             outputs_secret_image=None,
             outputs_secret_version=None,
+            resources=None,
         )
 
         return ExternalResourceModuleConfiguration(
@@ -265,6 +302,11 @@ class ExternalResourceModuleConfiguration(BaseModel, frozen=True):
             outputs_secret_version=module_overrides.outputs_secret_version
             or module.outputs_secret_version
             or settings.outputs_secret_version,
+            resources=Resources.from_deploy_resources_fields(
+                module_overrides.resources
+                or module.resources
+                or settings.module_default_resources
+            ),
         )
 
 

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/external_resources/reconciler.py

@@ -14,6 +14,7 @@ from kubernetes.client import (
     V1ObjectMeta,
     V1PodSpec,
     V1PodTemplateSpec,
+    V1ResourceRequirements,
     V1SecretVolumeSource,
     V1Volume,
     V1VolumeMount,
@@ -89,10 +90,19 @@ class ReconciliationK8sJob(K8sJob, BaseModel, frozen=True):
         }
 
     def job_spec(self) -> V1JobSpec:
+        assert self.reconciliation.module_configuration.resources is not None
         job_container = V1Container(
             name="job",
             image=self.reconciliation.module_configuration.image_version,
             image_pull_policy="Always",
+            resources=V1ResourceRequirements(
+                requests=self.reconciliation.module_configuration.resources.requests.dict(
+                    exclude_none=True
+                ),
+                limits=self.reconciliation.module_configuration.resources.limits.dict(
+                    exclude_none=True
+                ),
+            ),
             env=[
                 V1EnvVar(
                     name="DRY_RUN",

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/external_resources/state.py

@@ -11,6 +11,8 @@ from reconcile.external_resources.model import (
     ExternalResourceModuleConfiguration,
     Reconciliation,
     ReconciliationStatus,
+    Resources,
+    ResourcesSpec,
     ResourceStatus,
 )
 from reconcile.utils.aws_api_typed.api import AWSApi
@@ -73,10 +75,48 @@ class DynamoDBStateAdapter:
     MODCONF_VERSION = "version"
     MODCONF_DRIFT_MINS = "drift_detection_minutes"
     MODCONF_TIMEOUT_MINS = "timeout_minutes"
+    MODCONF_RESOURCES = "resources"
+    MODCONF_RESOURCES_REQUESTS = "requests"
+    MODCONF_RESOURCES_REQUESTS_CPU = "cpu"
+    MODCONF_RESOURCES_REQUESTS_MEMORY = "memory"
+    MODCONF_RESOURCES_LIMITS = "limits"
+    MODCONF_RESOURCES_LIMITS_CPU = "cpu"
+    MODCONF_RESOURCES_LIMITS_MEMORY = "memory"
 
     def _get_value(self, item: Mapping[str, Any], key: str, type: str = "S") -> Any:
+        if item[key][type] == "None":
+            return None
         return item[key][type]
 
+    def _build_resources(self, modconf: Mapping[str, Any]) -> Resources | None:
+        if self.MODCONF_RESOURCES not in modconf:
+            return Resources()
+        mc_resources = self._get_value(modconf, self.MODCONF_RESOURCES, type="M")
+        mc_resources_requests = self._get_value(
+            mc_resources, self.MODCONF_RESOURCES_REQUESTS, type="M"
+        )
+        mc_resources_limits = self._get_value(
+            mc_resources, self.MODCONF_RESOURCES_LIMITS, type="M"
+        )
+        return Resources(
+            requests=ResourcesSpec(
+                cpu=self._get_value(
+                    mc_resources_requests, self.MODCONF_RESOURCES_REQUESTS_CPU
+                ),
+                memory=self._get_value(
+                    mc_resources_requests, self.MODCONF_RESOURCES_REQUESTS_MEMORY
+                ),
+            ),
+            limits=ResourcesSpec(
+                cpu=self._get_value(
+                    mc_resources_limits, self.MODCONF_RESOURCES_LIMITS_CPU
+                ),
+                memory=self._get_value(
+                    mc_resources_limits, self.MODCONF_RESOURCES_LIMITS_MEMORY
+                ),
+            ),
+        )
+
     def deserialize(
         self,
         item: Mapping[str, Any],
@@ -116,6 +156,7 @@ class DynamoDBStateAdapter:
                     reconcile_timeout_minutes=self._get_value(
                         modconf, self.MODCONF_TIMEOUT_MINS, type="N"
                     ),
+                    resources=self._build_resources(modconf),
                 ),
             )
 
@@ -164,7 +205,39 @@ class DynamoDBStateAdapter:
                                     state.reconciliation.module_configuration.reconcile_timeout_minutes
                                 )
                             },
-                        }
+                            self.MODCONF_RESOURCES: {
+                                "M": {
+                                    self.MODCONF_RESOURCES_REQUESTS: {
+                                        "M": {
+                                            self.MODCONF_RESOURCES_REQUESTS_CPU: {
+                                                "S": str(
+                                                    state.reconciliation.module_configuration.resources.requests.cpu
+                                                )
+                                            },
+                                            self.MODCONF_RESOURCES_REQUESTS_MEMORY: {
+                                                "S": str(
+                                                    state.reconciliation.module_configuration.resources.requests.memory
+                                                )
+                                            },
+                                        }
+                                    },
+                                    self.MODCONF_RESOURCES_LIMITS: {
+                                        "M": {
+                                            self.MODCONF_RESOURCES_LIMITS_CPU: {
+                                                "S": str(
+                                                    state.reconciliation.module_configuration.resources.limits.cpu
+                                                )
+                                            },
+                                            self.MODCONF_RESOURCES_LIMITS_MEMORY: {
+                                                "S": str(
+                                                    state.reconciliation.module_configuration.resources.limits.memory
+                                                )
+                                            },
+                                        }
+                                    },
+                                }
+                            },
+                        },
                     },
                 }
             },

{qontract_reconcile-0.10.2.dev44 → qontract_reconcile-0.10.2.dev46}/reconcile/gql_definitions/external_resources/external_resources_modules.py

@@ -17,8 +17,21 @@ from pydantic import (  # noqa: F401 # pylint: disable=W0611
     Json,
 )
 
+from reconcile.gql_definitions.fragments.deplopy_resources import DeployResourcesFields
+
 
 DEFINITION = """
+fragment DeployResourcesFields on DeployResources_v1 {
+  requests {
+    cpu
+    memory
+  }
+  limits {
+    cpu
+    memory
+  }
+}
+
 query ExternalResourcesModules {
     modules: external_resources_modules_v1 {
         provision_provider
@@ -31,6 +44,9 @@ query ExternalResourcesModules {
         outputs_secret_sync
         outputs_secret_image
         outputs_secret_version
+        resources {
+          ... DeployResourcesFields
+        }
     }
 }
 """
@@ -53,6 +69,7 @@ class ExternalResourcesModuleV1(ConfiguredBaseModel):
     outputs_secret_sync: bool = Field(..., alias="outputs_secret_sync")
     outputs_secret_image: Optional[str] = Field(..., alias="outputs_secret_image")
     outputs_secret_version: Optional[str] = Field(..., alias="outputs_secret_version")
+    resources: Optional[DeployResourcesFields] = Field(..., alias="resources")
 
 
 class ExternalResourcesModulesQueryData(ConfiguredBaseModel):