infrahub-server 1.1.0b2__py3-none-any.whl → 1.1.2__py3-none-any.whl

infrahub/computed_attribute/tasks.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 from datetime import timedelta
 from typing import TYPE_CHECKING, Any
 
-from infrahub_sdk.protocols import CoreNode
+import ujson
+from infrahub_sdk.protocols import CoreNode  # noqa: TC002
 from prefect import flow
 from prefect.automations import AutomationCore
 from prefect.client.orchestration import get_client
@@ -25,7 +28,6 @@ from infrahub.workflows.catalogue import (
     TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
     UPDATE_COMPUTED_ATTRIBUTE_TRANSFORM,
 )
-from infrahub.workflows.constants import TAG_NAMESPACE, WorkflowTag
 from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
 
 from .constants import (
@@ -38,7 +40,10 @@ from .constants import (
 from .models import ComputedAttributeAutomations, PythonTransformComputedAttribute, PythonTransformTarget
 
 if TYPE_CHECKING:
+    import logging
+
     from infrahub.core.schema.computed_attribute import ComputedAttribute
+    from infrahub.services import InfrahubServices
 
 UPDATE_ATTRIBUTE = """
 mutation UpdateAttribute(
@@ -104,10 +109,12 @@ async def process_transform(
             name=transform.repository.peer.name.value,
             service=service,
             repository_kind=transform.repository.peer.typename,
+            commit=repo_node.commit.value,
         )
 
         data = await service.client.query_gql_query(
             name=transform.query.peer.name.value,
+            branch_name=branch_name,
             variables={"id": object_id},
             update_group=True,
             subscribers=[object_id],
@@ -170,7 +177,7 @@ async def update_computed_attribute_value_jinja2(
     log = get_run_logger()
     service = services.service
 
-    await add_tags(branches=[branch_name], nodes=[obj.id], others=[TAG_NAMESPACE, WorkflowTag.DATABASE_CHANGE.render()])
+    await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
 
     macro_definition = MacroDefinition(macro=template_value)
     my_filter = {}
@@ -221,12 +228,15 @@ async def process_jinja2(
     object_id: str,
     computed_attribute_name: str,
     computed_attribute_kind: str,
-    updated_fields: list[str] | None = None,
+    updated_fields: str | None = None,
 ) -> None:
     log = get_run_logger()
     service = services.service
 
     await add_tags(branches=[branch_name])
+    updates: list[str] = []
+    if isinstance(updated_fields, str):
+        updates = ujson.loads(updated_fields)
 
     target_branch_schema = (
         branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
@@ -236,9 +246,7 @@ async def process_jinja2(
 
     computed_macros = [
         attrib
-        for attrib in schema_branch.computed_attributes.get_impacted_jinja2_targets(
-            kind=node_kind, updates=updated_fields
-        )
+        for attrib in schema_branch.computed_attributes.get_impacted_jinja2_targets(kind=node_kind, updates=updates)
         if attrib.kind == computed_attribute_kind and attrib.attribute.name == computed_attribute_name
     ]
     for computed_macro in computed_macros:
@@ -363,6 +371,7 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
                             "object_id": "{{ event.resource['infrahub.node.id'] }}",
                             "computed_attribute_name": computed_attribute.attribute.name,
                             "computed_attribute_kind": computed_attribute.kind,
+                            "updated_fields": "{{ event.payload['fields'] | tojson }}",
                         },
                         job_variables={},
                     )
@@ -426,6 +435,7 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
                                 "object_id": "{{ event.resource['infrahub.node.id'] }}",
                                 "computed_attribute_name": computed_attribute.attribute.name,
                                 "computed_attribute_kind": computed_attribute.kind,
+                                "updated_fields": "{{ event.payload['fields'] | tojson }}",
                             },
                             job_variables={},
                         )
@@ -464,51 +474,20 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
     flow_run_name="Setup computed attributes for Python transforms in task-manager",
 )
 async def computed_attribute_setup_python(
-    branch_name: str | None = None,  # pylint: disable=unused-argument
+    branch_name: str | None = None,
+    commit: str | None = None,  # pylint: disable=unused-argument
+    trigger_updates: bool = True,
 ) -> None:
     log = get_run_logger()
     service = services.service
 
-    if branch_name:
-        await add_tags(branches=[branch_name])
-
-    await wait_for_schema_to_converge(branch_name=registry.default_branch, service=service, log=log)
-
-    schema_branch = registry.schema.get_schema_branch(name=registry.default_branch)
-
-    transform_attributes = schema_branch.computed_attributes.python_attributes_by_transform
-
-    transform_names = list(transform_attributes.keys())
+    branch_name = branch_name or registry.default_branch
 
-    transforms = await service.client.filters(
-        kind="CoreTransformPython",
-        branch=registry.default_branch,
-        prefetch_relationships=True,
-        populate_store=True,
-        name__values=transform_names,
-    )
+    await add_tags(branches=[branch_name])
 
-    found_transforms_names = [transform.name.value for transform in transforms]
-    for transform_name in transform_names:
-        if transform_name not in found_transforms_names:
-            log.warning(
-                msg=f"The transform {transform_name} is assigned to a computed attribute but the transform could not be found in the database."
-            )
+    await wait_for_schema_to_converge(branch_name=branch_name, service=service, log=log)
 
-    computed_attributes: list[PythonTransformComputedAttribute] = []
-    for transform in transforms:
-        for attribute in transform_attributes[transform.name.value]:
-            computed_attributes.append(
-                PythonTransformComputedAttribute(
-                    name=transform.name.value,
-                    repository_id=transform.repository.peer.id,
-                    repository_name=transform.repository.peer.name.value,
-                    repository_kind=transform.repository.peer.typename,
-                    query_name=transform.query.peer.name.value,
-                    query_models=transform.query.peer.models.value,
-                    computed_attribute=attribute,
-                )
-            )
+    computed_attributes = await _gather_python_transform_attributes(branch_name=branch_name, service=service, log=log)
 
     async with get_client(sync_client=False) as client:
         deployments = {
@@ -531,15 +510,16 @@ async def computed_attribute_setup_python(
 
         automations = await client.read_automations()
         existing_computed_attr_process_automations = ComputedAttributeAutomations.from_prefect(
-            automations=automations, prefix=PROCESS_PYTHON_AUTOMATION_NAME_PREFIX
+            automations=automations, prefix=f"{PROCESS_PYTHON_AUTOMATION_NAME_PREFIX}::{branch_name}::"
         )
         existing_computed_attr_query_automations = ComputedAttributeAutomations.from_prefect(
-            automations=automations, prefix=QUERY_AUTOMATION_NAME_PREFIX
+            automations=automations, prefix=f"{QUERY_AUTOMATION_NAME_PREFIX}::{branch_name}::"
         )
 
+        automations_to_keep = []
         for computed_attribute in computed_attributes:
             log.info(f"processing {computed_attribute.computed_attribute.key_name}")
-            scope = "default"
+            scope = branch_name
 
             automation = AutomationCore(
                 name=PROCESS_AUTOMATION_NAME.format(
@@ -553,7 +533,12 @@ async def computed_attribute_setup_python(
                     posture=Posture.Reactive,
                     expect={"infrahub.node.*"},
                     within=timedelta(0),
-                    match=ResourceSpecification({"infrahub.node.kind": [computed_attribute.computed_attribute.kind]}),
+                    match=ResourceSpecification(
+                        {
+                            "infrahub.node.kind": [computed_attribute.computed_attribute.kind],
+                            "infrahub.branch.name": branch_name,
+                        }
+                    ),
                     threshold=1,
                 ),
                 actions=[
@@ -580,8 +565,10 @@ async def computed_attribute_setup_python(
                 )
                 await client.update_automation(automation_id=existing.id, automation=automation)
                 log.info(f"Process {computed_attribute.computed_attribute.key_name} Updated")
+                automations_to_keep.append(existing.id)
             else:
-                await client.create_automation(automation=automation)
+                automation_id = await client.create_automation(automation=automation)
+                automations_to_keep.append(automation_id)
                 log.info(f"Process {computed_attribute.computed_attribute.key_name} Created")
 
             automation = AutomationCore(
@@ -596,7 +583,12 @@ async def computed_attribute_setup_python(
                     posture=Posture.Reactive,
                     expect={"infrahub.node.*"},
                     within=timedelta(0),
-                    match=ResourceSpecification({"infrahub.node.kind": computed_attribute.query_models}),
+                    match=ResourceSpecification(
+                        {
+                            "infrahub.node.kind": computed_attribute.query_models,
+                            "infrahub.branch.name": branch_name,
+                        }
+                    ),
                     threshold=1,
                 ),
                 actions=[
@@ -620,19 +612,53 @@ async def computed_attribute_setup_python(
                     identifier=computed_attribute.computed_attribute.key_name, scope=scope
                 )
                 await client.update_automation(automation_id=existing.id, automation=automation)
+                automations_to_keep.append(existing.id)
                 log.info(f"Query {computed_attribute.computed_attribute.key_name} Updated")
             else:
-                await client.create_automation(automation=automation)
+                automation_id = await client.create_automation(automation=automation)
+                automations_to_keep.append(automation_id)
                 log.info(f"Query {computed_attribute.computed_attribute.key_name} Created")
 
-            await service.workflow.submit_workflow(
-                workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
-                parameters={
-                    "branch_name": registry.default_branch,
-                    "computed_attribute_name": computed_attribute.computed_attribute.attribute.name,
-                    "computed_attribute_kind": computed_attribute.computed_attribute.kind,
-                },
-            )
+            if trigger_updates:
+                await service.workflow.submit_workflow(
+                    workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+                    parameters={
+                        "branch_name": branch_name,
+                        "computed_attribute_name": computed_attribute.computed_attribute.attribute.name,
+                        "computed_attribute_kind": computed_attribute.computed_attribute.kind,
+                    },
+                )
+
+        automations_to_remove = existing_computed_attr_process_automations.return_obsolete(keep=automations_to_keep)
+        for automation_to_remove in automations_to_remove:
+            await client.delete_automation(automation_id=automation_to_remove)
+
+        automations_to_remove = existing_computed_attr_query_automations.return_obsolete(keep=automations_to_keep)
+        for automation_to_remove in automations_to_remove:
+            await client.delete_automation(automation_id=automation_to_remove)
+
+
+@flow(
+    name="computed-attribute-remove-python",
+    flow_run_name="Remove Python based computed attributes on branch={branch_name}",
+)
+async def computed_attribute_remove_python(
+    branch_name: str,
+) -> None:
+    async with get_client(sync_client=False) as client:
+        automations = await client.read_automations()
+        existing_computed_attr_process_automations = ComputedAttributeAutomations.from_prefect(
+            automations=automations, prefix=f"{PROCESS_PYTHON_AUTOMATION_NAME_PREFIX}::{branch_name}::"
+        )
+        existing_computed_attr_query_automations = ComputedAttributeAutomations.from_prefect(
+            automations=automations, prefix=f"{QUERY_AUTOMATION_NAME_PREFIX}::{branch_name}::"
+        )
+
+        for automation_id in existing_computed_attr_process_automations.all_automation_ids:
+            await client.delete_automation(automation_id=automation_id)
+
+        for automation_id in existing_computed_attr_query_automations.all_automation_ids:
+            await client.delete_automation(automation_id=automation_id)
 
 
 @flow(
@@ -648,7 +674,7 @@ async def query_transform_targets(
     service = services.service
     schema_branch = registry.schema.get_schema_branch(name=branch_name)
     targets = await service.client.execute_graphql(
-        query=GATHER_GRAPHQL_QUERY_SUBSCRIBERS, variables={"members": [object_id]}
+        query=GATHER_GRAPHQL_QUERY_SUBSCRIBERS, variables={"members": [object_id]}, branch_name=branch_name
     )
 
     subscribers: list[PythonTransformTarget] = []
@@ -675,6 +701,55 @@ async def query_transform_targets(
                 )
 
 
+async def _gather_python_transform_attributes(
+    branch_name: str, service: InfrahubServices, log: logging.Logger | logging.LoggerAdapter
+) -> list[PythonTransformComputedAttribute]:
+    schema_branch = registry.schema.get_schema_branch(name=branch_name)
+    branches_with_diff_from_main = registry.get_altered_schema_branches()
+
+    transform_attributes = schema_branch.computed_attributes.python_attributes_by_transform
+
+    transform_names = list(transform_attributes.keys())
+    if not transform_names:
+        return []
+
+    transforms = await service.client.filters(
+        kind="CoreTransformPython",
+        branch=branch_name,
+        prefetch_relationships=True,
+        populate_store=True,
+        name__values=transform_names,
+    )
+
+    found_transforms_names = [transform.name.value for transform in transforms]
+    for transform_name in transform_names:
+        if transform_name not in found_transforms_names:
+            log.warning(
+                msg=f"The transform {transform_name} is assigned to a computed attribute but the transform could not be found in the database."
+            )
+
+    repositories = await service.client.get_list_repositories()
+    computed_attributes: list[PythonTransformComputedAttribute] = []
+    for transform in transforms:
+        for attribute in transform_attributes[transform.name.value]:
+            python_transform_computed_attribute = PythonTransformComputedAttribute(
+                name=transform.name.value,
+                repository_id=transform.repository.peer.id,
+                repository_name=transform.repository.peer.name.value,
+                repository_kind=transform.repository.peer.typename,
+                query_name=transform.query.peer.name.value,
+                query_models=transform.query.peer.models.value,
+                computed_attribute=attribute,
+                default_schema=branch_name not in branches_with_diff_from_main,
+            )
+            python_transform_computed_attribute.populate_branch_commit(
+                repository_data=repositories.get(transform.repository.peer.name.value)
+            )
+            computed_attributes.append(python_transform_computed_attribute)
+
+    return computed_attributes
+
+
 GATHER_GRAPHQL_QUERY_SUBSCRIBERS = """
 query GatherGraphQLQuerySubscribers($members: [ID!]) {
   CoreGraphQLQueryGroup(members__ids: $members) {

infrahub/config.py

@@ -126,6 +126,14 @@ class WorkflowDriver(str, Enum):
     WORKER = "worker"
 
 
+class ExtraLogLevel(str, Enum):
+    CRITICAL = "CRITICAL"
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+    INFO = "INFO"
+    DEBUG = "DEBUG"
+
+
 class MainSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="INFRAHUB_")
     docs_index_path: Path = Field(
@@ -145,6 +153,10 @@ class MainSettings(BaseSettings):
         default=["infrahub.permissions.LocalPermissionBackend"],
         description="List of modules to handle permissions, they will be run in the given order",
     )
+    public_url: Optional[str] = Field(
+        default=None,
+        description="Define the public URL of the Infrahub, might be required for OAuth2 and OIDC depending on your infrastructure.",
+    )
 
     @field_validator("docs_index_path", mode="before")
     @classmethod
@@ -248,10 +260,6 @@ class DevelopmentSettings(BaseSettings):
 
     model_config = SettingsConfigDict(env_prefix="INFRAHUB_DEV_")
 
-    frontend_url: Optional[str] = Field(
-        default=None,
-        description="Define the URL of the frontend, useful for OAuth2 development when the frontend and backend use different ports.",
-    )
     frontend_redirect_sso: bool = Field(
         default=False,
         description="Indicates of the frontend should be responsible for the SSO redirection",
@@ -318,6 +326,12 @@ class WorkflowSettings(BaseSettings):
     tls_enabled: bool = Field(default=False, description="Indicates if TLS is enabled for the connection")
     driver: WorkflowDriver = WorkflowDriver.WORKER
     default_worker_type: str = "infrahubasync"
+    extra_loggers: list[str] = Field(
+        default_factory=list, description="A list of additional logger that will be captured during task execution."
+    )
+    extra_log_level: ExtraLogLevel = Field(
+        default=ExtraLogLevel.INFO, description="Log level applied to all extra loggers."
+    )
     worker_polling_interval: int = Field(
         default=2, ge=1, le=30, description="Specify how often the worker should poll the server for tasks (sec)"
     )

infrahub/core/account.py

@@ -6,13 +6,13 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 from typing_extensions import Self
 
 from infrahub.core.constants import InfrahubKind, PermissionDecision
-from infrahub.core.query import Query
+from infrahub.core.query import Query, QueryType
 from infrahub.core.registry import registry
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.database import InfrahubDatabase
-    from infrahub.permissions.constants import AssignedPermissions
+    from infrahub.permissions import AssignedPermissions
 
 
 # pylint: disable=redefined-builtin
@@ -35,15 +35,7 @@ class GlobalPermission:
         if len(parts) != 3 and parts[0] != "global":
             raise ValueError(f"{input} is not a valid format for a Global permission")
 
-        # FIXME there is probably a better way to convert the decision
-        decision = PermissionDecision.DENY
-        if parts[2] == "allow_default":
-            decision = PermissionDecision.ALLOW_DEFAULT
-        elif parts[2] == "allow_all":
-            decision = PermissionDecision.ALLOW_ALL
-        elif parts[2] == "allow_other":
-            decision = PermissionDecision.ALLOW_OTHER
-        return cls(action=str(parts[1]), decision=decision)
+        return cls(action=parts[1], decision=PermissionDecision[parts[2].upper()])
 
 
 @dataclass
@@ -62,6 +54,7 @@ class ObjectPermission:
 
 class AccountGlobalPermissionQuery(Query):
     name: str = "account_global_permissions"
+    type: QueryType = QueryType.READ
 
     def __init__(self, account_id: str, **kwargs: Any):
         self.account_id = account_id
@@ -176,6 +169,7 @@ class AccountGlobalPermissionQuery(Query):
 
 class AccountObjectPermissionQuery(Query):
     name: str = "account_object_permissions"
+    type: QueryType = QueryType.READ
 
     def __init__(self, account_id: str, **kwargs: Any):
         self.account_id = account_id
@@ -327,6 +321,7 @@ async def fetch_permissions(account_id: str, db: InfrahubDatabase, branch: Branc
 
 class AccountRoleGlobalPermissionQuery(Query):
     name: str = "account_role_global_permissions"
+    type: QueryType = QueryType.READ
 
     def __init__(self, role_id: str, **kwargs: Any):
         self.role_id = role_id
@@ -416,6 +411,7 @@ class AccountRoleGlobalPermissionQuery(Query):
 
 class AccountRoleObjectPermissionQuery(Query):
     name: str = "account_role_object_permissions"
+    type: QueryType = QueryType.READ
 
     def __init__(self, role_id: str, **kwargs: Any):
         self.role_id = role_id
@@ -542,6 +538,7 @@ async def fetch_role_permissions(role_id: str, db: InfrahubDatabase, branch: Bra
 
 class AccountTokenValidateQuery(Query):
     name: str = "account_token_validate"
+    type: QueryType = QueryType.READ
 
     def __init__(self, token: str, **kwargs: Any):
         self.token = token

infrahub/core/attribute.py

@@ -666,6 +666,21 @@ class Integer(BaseAttribute):
     value: int
     from_pool: Optional[str] = None
 
+    @classmethod
+    def validate_format(cls, value: Any, name: str, schema: AttributeSchema) -> None:
+        """
+        Make sure boolean objects are not accepted as value. Need to override `validate_format`
+        as `isinstance(True, int)` is True.
+        """
+
+        value_to_check = value
+        if schema.enum and isinstance(value, Enum):
+            value_to_check = value.value
+
+        # Note that we might want to do this check directly in parent function.
+        if value_to_check.__class__ != cls.type:
+            raise ValidationError({name: f"{value} is not a valid {schema.kind}"})
+
 
 class IntegerOptional(Integer):
     value: Optional[int]

infrahub/core/branch/constants.py

@@ -0,0 +1,2 @@
+AUTOMATION_NAME_CREATE = "Trigger-branch-create-events"
+AUTOMATION_NAME_REMOVE = "Trigger-branch-remove-events"

infrahub/core/branch/models.py

@@ -8,8 +8,9 @@ from pydantic import Field, field_validator
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
 )
-from infrahub.core.models import SchemaBranchHash  # noqa: TCH001
+from infrahub.core.models import SchemaBranchHash  # noqa: TC001
 from infrahub.core.node.standard import StandardNode
+from infrahub.core.query import QueryType
 from infrahub.core.query.branch import (
     DeleteBranchRelationshipsQuery,
     GetAllBranchInternalRelationshipQuery,
@@ -139,7 +140,7 @@ class Branch(StandardNode):  # pylint: disable=too-many-public-methods
 
         params = {"name": name}
 
-        results = await db.execute_query(query=query, params=params, name="branch_get_by_name")
+        results = await db.execute_query(query=query, params=params, name="branch_get_by_name", type=QueryType.READ)
 
         if len(results) == 0:
             raise BranchNotFoundError(identifier=name)