infrahub-server 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/actions/tasks.py

@@ -1,17 +1,114 @@
 from __future__ import annotations
 
-from infrahub_sdk.graphql import Mutation
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any
+
+from infrahub_sdk.graphql import Mutation, Query
+from infrahub_sdk.types import Order
 from prefect import flow
 
 from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.constants import InfrahubKind
+from infrahub.generators.models import (
+    GeneratorDefinitionModel,
+    RequestGeneratorRun,
+)
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.trigger.models import TriggerType
 from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_workflow
+from infrahub.workflows.catalogue import REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
 
 from .gather import gather_trigger_action_rules
 from .models import EventGroupMember  # noqa: TC001  needed for prefect flow
 
+if TYPE_CHECKING:
+    from infrahub_sdk.client import InfrahubClient
+    from infrahub_sdk.node import InfrahubNode
+
+
+def get_generator_run_query(definition_id: str, target_ids: list[str]) -> Query:
+    return Query(
+        name=InfrahubKind.GENERATORDEFINITION,
+        query={
+            InfrahubKind.GENERATORDEFINITION: {
+                "@filters": {
+                    "ids": [definition_id],
+                },
+                "edges": {
+                    "node": {
+                        "id": None,
+                        "name": {
+                            "value": None,
+                        },
+                        "class_name": {
+                            "value": None,
+                        },
+                        "file_path": {
+                            "value": None,
+                        },
+                        "query": {
+                            "node": {
+                                "name": {
+                                    "value": None,
+                                },
+                            },
+                        },
+                        "convert_query_response": {
+                            "value": None,
+                        },
+                        "parameters": {
+                            "value": None,
+                        },
+                        "execute_in_proposed_change": {
+                            "value": None,
+                        },
+                        "execute_after_merge": {
+                            "value": None,
+                        },
+                        "targets": {
+                            "node": {
+                                "id": None,
+                                "members": {
+                                    "@filters": {
+                                        "ids": target_ids,
+                                    },
+                                    "edges": {
+                                        "node": {
+                                            "__typename": None,
+                                            "id": None,
+                                            "display_label": None,
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "repository": {
+                            "node": {
+                                "__typename": None,
+                                "id": None,
+                                "name": {
+                                    "value": None,
+                                },
+                                f"... on {InfrahubKind.REPOSITORY}": {
+                                    "commit": {
+                                        "value": None,
+                                    },
+                                },
+                                f"... on {InfrahubKind.READONLYREPOSITORY}": {
+                                    "commit": {
+                                        "value": None,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    )
+
 
 @flow(
     name="action-add-node-to-group",
@@ -65,12 +162,19 @@ async def run_generator(
     branch_name: str,
     node_ids: list[str],
     generator_definition_id: str,
-    context: InfrahubContext,  # noqa: ARG001
-    service: InfrahubServices,
+    context: InfrahubContext,
+    service: InfrahubServices,  # noqa: ARG001
 ) -> None:
     await add_tags(branches=[branch_name], nodes=node_ids + [generator_definition_id])
-    await _run_generator(
-        branch_name=branch_name, generator_definition_id=generator_definition_id, node_ids=node_ids, service=service
+
+    client = get_client()
+
+    await _run_generators(
+        branch_name=branch_name,
+        node_ids=node_ids,
+        generator_definition_id=generator_definition_id,
+        client=client,
+        context=context,
     )
 
 
@@ -82,13 +186,20 @@ async def run_generator_group_event(
     branch_name: str,
     members: list[EventGroupMember],
     generator_definition_id: str,
-    context: InfrahubContext,  # noqa: ARG001
-    service: InfrahubServices,
+    context: InfrahubContext,
+    service: InfrahubServices,  # noqa: ARG001
 ) -> None:
     node_ids = [node.id for node in members]
     await add_tags(branches=[branch_name], nodes=node_ids + [generator_definition_id])
-    await _run_generator(
-        branch_name=branch_name, generator_definition_id=generator_definition_id, node_ids=node_ids, service=service
+
+    client = get_client()
+
+    await _run_generators(
+        branch_name=branch_name,
+        node_ids=node_ids,
+        generator_definition_id=generator_definition_id,
+        client=client,
+        context=context,
     )
 
 
@@ -104,16 +215,97 @@ async def configure_action_rules(
     )  # type: ignore[misc]
 
 
-async def _run_generator(
+async def _get_targets(
+    branch_name: str,
+    targets: list[dict[str, Any]],
+    client: InfrahubClient,
+) -> dict[str, dict[str, InfrahubNode]]:
+    """Get the targets per kind in order to extract the variables."""
+
+    targets_per_kind: dict[str, dict[str, InfrahubNode]] = defaultdict(dict)
+
+    for target in targets:
+        targets_per_kind[target["node"]["__typename"]][target["node"]["id"]] = None
+
+    for kind, values in targets_per_kind.items():
+        nodes = await client.filters(
+            kind=kind, branch=branch_name, ids=list(values.keys()), populate_store=False, order=Order(disable=True)
+        )
+        for node in nodes:
+            targets_per_kind[kind][node.id] = node
+
+    return targets_per_kind
+
+
+async def _run_generators(
     branch_name: str,
     node_ids: list[str],
     generator_definition_id: str,
-    service: InfrahubServices,
+    client: InfrahubClient,
+    context: InfrahubContext | None = None,
 ) -> None:
-    mutation = Mutation(
-        mutation="CoreGeneratorDefinitionRun",
-        input_data={"data": {"id": generator_definition_id, "nodes": node_ids}},
-        query={"ok": None},
+    """Fetch generator metadata and submit per-target runs.
+
+    Args:
+        branch_name: Branch on which to execute.
+        node_ids: Node IDs to run against (restricts selection if provided).
+        generator_definition_id: Generator definition to execute.
+        client: InfrahubClient to query additional data.
+        context: Execution context passed to downstream workflow submissions.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the generator definition is not found or none of the requested
+            targets are members of the target group.
+    """
+    response = await client.execute_graphql(
+        query=get_generator_run_query(definition_id=generator_definition_id, target_ids=node_ids).render(),
+        branch_name=branch_name,
     )
+    if not response[InfrahubKind.GENERATORDEFINITION]["edges"]:
+        raise ValueError(f"Generator definition {generator_definition_id} not found")
 
-    await service.client.execute_graphql(query=mutation.render(), branch_name=branch_name)
+    data = response[InfrahubKind.GENERATORDEFINITION]["edges"][0]["node"]
+
+    if not data["targets"]["node"]["members"]["edges"]:
+        raise ValueError(f"Target {node_ids[0]} is not part of the group {data['targets']['node']['id']}")
+
+    targets = data["targets"]["node"]["members"]["edges"]
+
+    targets_per_kind = await _get_targets(branch_name=branch_name, targets=targets, client=client)
+
+    workflow = get_workflow()
+
+    for target in targets:
+        node: InfrahubNode | None = None
+        if data["parameters"]["value"]:
+            node = targets_per_kind[target["node"]["__typename"]][target["node"]["id"]]
+
+        request_generator_run_model = RequestGeneratorRun(
+            generator_definition=GeneratorDefinitionModel(
+                definition_id=generator_definition_id,
+                definition_name=data["name"]["value"],
+                class_name=data["class_name"]["value"],
+                file_path=data["file_path"]["value"],
+                query_name=data["query"]["node"]["name"]["value"],
+                convert_query_response=data["convert_query_response"]["value"],
+                group_id=data["targets"]["node"]["id"],
+                parameters=data["parameters"]["value"],
+                execute_in_proposed_change=data["execute_in_proposed_change"]["value"],
+                execute_after_merge=data["execute_after_merge"]["value"],
+            ),
+            commit=data["repository"]["node"]["commit"]["value"],
+            repository_id=data["repository"]["node"]["id"],
+            repository_name=data["repository"]["node"]["name"]["value"],
+            repository_kind=data["repository"]["node"]["__typename"],
+            branch_name=branch_name,
+            query=data["query"]["node"]["name"]["value"],
+            variables=await node.extract(params=data["parameters"]["value"]) if node else {},
+            target_id=target["node"]["id"],
+            target_name=target["node"]["display_label"],
+        )
+        await workflow.submit_workflow(
+            workflow=REQUEST_GENERATOR_RUN, context=context, parameters={"model": request_generator_run_model}
+        )

infrahub/api/artifact.py

@@ -15,6 +15,7 @@ from infrahub.api.dependencies import (
 )
 from infrahub.core import registry
 from infrahub.core.account import ObjectPermission
+from infrahub.core.branch.needs_rebase_status import check_need_rebase_status
 from infrahub.core.constants import GLOBAL_BRANCH_NAME, InfrahubKind, PermissionAction
 from infrahub.core.protocols import CoreArtifactDefinition
 from infrahub.database import InfrahubDatabase  # noqa: TC001
@@ -74,6 +75,8 @@ async def generate_artifact(
     permission_manager: PermissionManager = Depends(get_permission_manager),
     context: InfrahubContext = Depends(get_context),
 ) -> None:
+    check_need_rebase_status(branch_params.branch)
+
     permission_decision = (
         PermissionDecisionFlag.ALLOW_DEFAULT
         if branch_params.branch.name in (GLOBAL_BRANCH_NAME, registry.default_branch)

infrahub/api/diff/diff.py

@@ -52,7 +52,7 @@ async def get_diff_files(
     for branch_name, items in diff_files.items():
         for item in items:
             repository_id = item.repository.get_id()
-            display_label = await item.repository.render_display_label(db=db)
+            display_label = await item.repository.get_display_label(db=db)
             if repository_id not in response[branch_name]:
                 response[branch_name][repository_id] = BranchDiffRepository(
                     id=repository_id,

infrahub/api/internal.py

@@ -161,6 +161,8 @@ class SearchResultAPI(BaseModel):
 async def search_docs(
     query: str, limit: int | None = None, _: AccountSession = Depends(get_current_user)
 ) -> list[SearchResultAPI]:
+    if not query:
+        return []
     smart_query = smart_queries(query)
     search_results = search_docs_loader.heading_index.search(smart_query)
     heading_results = [

infrahub/api/query.py

@@ -24,6 +24,7 @@ from infrahub.graphql.metrics import (
     GRAPHQL_RESPONSE_SIZE_METRICS,
     GRAPHQL_TOP_LEVEL_QUERIES_METRICS,
 )
+from infrahub.graphql.middleware import raise_on_mutation_on_branch_needing_rebase
 from infrahub.graphql.utils import extract_data
 from infrahub.groups.models import RequestGraphQLQueryGroupUpdate
 from infrahub.log import get_logger
@@ -98,6 +99,7 @@ async def execute_query(
             context_value=gql_params.context,
             root_value=None,
             variable_values=params,
+            middleware=[raise_on_mutation_on_branch_needing_rebase],
         )
 
     data = extract_data(query_name=gql_query.name.value, result=result)

infrahub/api/schema.py

@@ -18,6 +18,7 @@ from infrahub.api.exceptions import SchemaNotValidError
 from infrahub.core import registry
 from infrahub.core.account import GlobalPermission
 from infrahub.core.branch import Branch  # noqa: TC001
+from infrahub.core.branch.needs_rebase_status import check_need_rebase_status
 from infrahub.core.constants import GLOBAL_BRANCH_NAME, GlobalPermissions, PermissionDecision
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.models import (  # noqa: TC001
@@ -25,7 +26,15 @@ from infrahub.core.models import (  # noqa: TC001
     SchemaDiff,
     SchemaUpdateValidationResult,
 )
-from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema, ProfileSchema, SchemaRoot, TemplateSchema
+from infrahub.core.schema import (
+    GenericSchema,
+    MainSchemaTypes,
+    NodeSchema,
+    ProfileSchema,
+    SchemaRoot,
+    SchemaWarning,
+    TemplateSchema,
+)
 from infrahub.core.schema.constants import SchemaNamespace  # noqa: TC001
 from infrahub.core.validators.models.validate_migration import (
     SchemaValidateMigrationData,
@@ -129,6 +138,9 @@ class SchemaUpdate(BaseModel):
     hash: str = Field(..., description="The new hash for the entire schema")
     previous_hash: str = Field(..., description="The previous hash for the entire schema")
     diff: SchemaDiff = Field(..., description="The modifications to the schema")
+    warnings: list[SchemaWarning] = Field(
+        default_factory=list, description="Warnings encountered while loading the schema"
+    )
 
     @computed_field
     def schema_updated(self) -> bool:
@@ -287,6 +299,8 @@ async def load_schema(
     permission_manager: PermissionManager = Depends(get_permission_manager),
     context: InfrahubContext = Depends(get_context),
 ) -> SchemaUpdate:
+    check_need_rebase_status(branch)
+
     permission_manager.raise_for_permission(
         permission=define_global_permission_from_branch(
             permission=GlobalPermissions.MANAGE_SCHEMA, branch_name=branch.name
@@ -304,8 +318,10 @@ async def load_schema(
     log.info("schema_load_request", branch=branch.name)
 
     errors: list[str] = []
+    warnings: list[SchemaWarning] = []
     for schema in schemas.schemas:
         errors += schema.validate_namespaces()
+        warnings += schema.gather_warnings()
 
     if errors:
         raise SchemaNotValidError(message=", ".join(errors))
@@ -399,7 +415,7 @@ async def load_schema(
     )
     await service.event.send(event=event)
 
-    return SchemaUpdate(hash=updated_hash, previous_hash=original_hash, diff=result.diff)
+    return SchemaUpdate(hash=updated_hash, previous_hash=original_hash, diff=result.diff, warnings=warnings)
 
 
 @router.post("/check")
@@ -414,8 +430,10 @@ async def check_schema(
     log.info("schema_check_request", branch=branch.name)
 
     errors: list[str] = []
+    warnings: list[SchemaWarning] = []
     for schema in schemas.schemas:
         errors += schema.validate_namespaces()
+        warnings += schema.gather_warnings()
 
     if errors:
         raise SchemaNotValidError(message=", ".join(errors))
@@ -442,4 +460,10 @@ async def check_schema(
     if error_messages:
         raise SchemaNotValidError(message=",\n".join(error_messages))
 
-    return JSONResponse(status_code=202, content={"diff": result.diff.model_dump()})
+    return JSONResponse(
+        status_code=202,
+        content={
+            "diff": result.diff.model_dump(),
+            "warnings": [warning.model_dump(mode="json") for warning in warnings],
+        },
+    )

infrahub/auth.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import uuid
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
@@ -88,7 +88,7 @@ async def authenticate_with_password(
     if not valid_credentials:
         raise AuthorizationError("Incorrect password")
 
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
     refresh_expires = now + timedelta(seconds=config.SETTINGS.security.refresh_token_lifetime)
 
     session_id = await create_db_refresh_token(db=db, account_id=account.id, expiration=refresh_expires)
@@ -149,7 +149,7 @@ async def signin_sso_account(db: InfrahubDatabase, account_name: str, sso_groups
                 await group.members.add(db=db, data=account)
                 await group.members.save(db=db)
 
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
     refresh_expires = now + timedelta(seconds=config.SETTINGS.security.refresh_token_lifetime)
     session_id = await create_db_refresh_token(db=db, account_id=account.id, expiration=refresh_expires)
     access_token = generate_access_token(account_id=account.id, session_id=session_id)
@@ -158,7 +158,7 @@ async def signin_sso_account(db: InfrahubDatabase, account_name: str, sso_groups
 
 
 def generate_access_token(account_id: str, session_id: uuid.UUID) -> str:
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
 
     access_expires = now + timedelta(seconds=config.SETTINGS.security.access_token_lifetime)
     access_data = {
@@ -175,7 +175,7 @@ def generate_access_token(account_id: str, session_id: uuid.UUID) -> str:
 
 
 def generate_refresh_token(account_id: str, session_id: uuid.UUID, expiration: datetime) -> str:
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
 
     refresh_data = {
         "sub": account_id,

infrahub/cli/__init__.py

@@ -7,6 +7,7 @@ from infrahub.core.initialization import initialization
 from ..workers.dependencies import get_database
 from .context import CliContext
 from .db import app as db_app
+from .dev import app as dev_app
 from .events import app as events_app
 from .git_agent import app as git_app
 from .server import app as server_app
@@ -27,6 +28,7 @@ app.add_typer(git_app, name="git-agent", hidden=True)
 app.add_typer(db_app, name="db")
 app.add_typer(events_app, name="events", help="Interact with the events system.", hidden=True)
 app.add_typer(tasks_app, name="tasks", hidden=True)
+app.add_typer(dev_app, name="dev", help="Internal development commands.")
 app.command(name="upgrade")(upgrade_cmd)