infrahub-server 1.3.7__py3-none-any.whl → 1.4.0__py3-none-any.whl

infrahub/workers/dependencies.py

@@ -0,0 +1,143 @@
+from typing import Any
+
+from fast_depends import Depends, inject
+from infrahub_sdk.client import InfrahubClient
+from infrahub_sdk.config import Config
+
+from infrahub import config
+from infrahub.components import ComponentType
+from infrahub.constants.environment import INSTALLATION_TYPE
+from infrahub.database import InfrahubDatabase, get_db
+from infrahub.services.adapters.cache import InfrahubCache
+from infrahub.services.adapters.event import InfrahubEventService
+from infrahub.services.adapters.http import InfrahubHTTP
+from infrahub.services.adapters.http.httpx import HttpxAdapter
+from infrahub.services.adapters.message_bus import InfrahubMessageBus
+from infrahub.services.adapters.workflow import InfrahubWorkflow
+from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
+from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
+from infrahub.services.component import InfrahubComponent
+
+_singletons: dict[str, Any] = {}
+
+
+def set_component_type(component_type: ComponentType) -> None:
+    if "component_type" not in _singletons:
+        _singletons["component_type"] = component_type
+
+
+def get_component_type() -> ComponentType:
+    try:
+        return _singletons["component_type"]
+    except KeyError as exc:
+        raise ValueError("Component type is not set. It needs to be initialized before working with services.") from exc
+
+
+def build_client() -> InfrahubClient:
+    return InfrahubClient(config=Config(address=config.SETTINGS.main.internal_address, retry_on_failure=True))
+
+
+@inject
+def get_client(client: InfrahubClient = Depends(build_client)) -> InfrahubClient:  # noqa: B008
+    return client
+
+
+def build_installation_type() -> str:
+    return INSTALLATION_TYPE
+
+
+@inject
+def get_installation_type(installation_type: str = Depends(build_installation_type)) -> str:
+    return installation_type
+
+
+async def build_database() -> InfrahubDatabase:
+    if "database" not in _singletons:
+        _singletons["database"] = InfrahubDatabase(driver=await get_db(retry=5))
+    return _singletons["database"]
+
+
+@inject
+async def get_database(database: InfrahubDatabase = Depends(build_database)) -> InfrahubDatabase:  # noqa: B008
+    return database
+
+
+async def build_cache() -> InfrahubCache:
+    if "cache" not in _singletons:
+        _singletons["cache"] = config.OVERRIDE.cache or await InfrahubCache.new_from_driver(
+            driver=config.SETTINGS.cache.driver
+        )
+    return _singletons["cache"]
+
+
+@inject
+async def get_cache(cache: InfrahubCache = Depends(build_cache)) -> InfrahubCache:  # noqa: B008
+    return cache
+
+
+async def build_message_bus() -> InfrahubMessageBus:
+    if "message_bus" not in _singletons:
+        _singletons["message_bus"] = config.OVERRIDE.message_bus or (
+            await InfrahubMessageBus.new_from_driver(
+                component_type=get_component_type(), driver=config.SETTINGS.broker.driver
+            )
+        )
+    return _singletons["message_bus"]
+
+
+@inject
+async def get_message_bus(message_bus: InfrahubMessageBus = Depends(build_message_bus)) -> InfrahubMessageBus:  # noqa: B008
+    return message_bus
+
+
+async def build_event_service() -> InfrahubEventService:
+    if "event_service" not in _singletons:
+        _singletons["event_service"] = InfrahubEventService(message_bus=await get_message_bus())
+    return _singletons["event_service"]
+
+
+@inject
+async def get_event_service(event_service: InfrahubEventService = Depends(build_event_service)) -> InfrahubEventService:  # noqa: B008
+    return event_service
+
+
+def build_workflow() -> InfrahubWorkflow:
+    if "workflow" not in _singletons:
+        _singletons["workflow"] = config.OVERRIDE.workflow or (
+            WorkflowWorkerExecution()
+            if config.SETTINGS.workflow.driver == config.WorkflowDriver.WORKER
+            else WorkflowLocalExecution()
+        )
+    return _singletons["workflow"]
+
+
+@inject
+def get_workflow(workflow: InfrahubWorkflow = Depends(build_workflow)) -> InfrahubWorkflow:  # noqa: B008
+    return workflow
+
+
+def build_http_service() -> InfrahubHTTP:
+    if "http_service" not in _singletons:
+        _singletons["http_service"] = HttpxAdapter()
+    return _singletons["http_service"]
+
+
+@inject
+def get_http(http_service: InfrahubHTTP = Depends(build_http_service)) -> InfrahubHTTP:  # noqa: B008
+    return http_service
+
+
+async def build_component() -> InfrahubComponent:
+    if "component" not in _singletons:
+        _singletons["component"] = await InfrahubComponent.new(
+            cache=await get_cache(),
+            component_type=get_component_type(),
+            db=await get_database(),
+            message_bus=await get_message_bus(),
+        )
+    return _singletons["component"]
+
+
+@inject
+async def get_component(component: InfrahubComponent = Depends(build_component)) -> InfrahubComponent:  # noqa: B008
+    return component

infrahub/workers/infrahub_async.py

@@ -18,17 +18,19 @@ from infrahub import config
 from infrahub.components import ComponentType
 from infrahub.core import registry
 from infrahub.core.initialization import initialization
-from infrahub.database import InfrahubDatabase, get_db
 from infrahub.dependencies.registry import build_component_registry
 from infrahub.git import initialize_repositories_directory
 from infrahub.lock import initialize_lock
 from infrahub.services import InfrahubServices
-from infrahub.services.adapters.cache import InfrahubCache
-from infrahub.services.adapters.message_bus import InfrahubMessageBus
-from infrahub.services.adapters.workflow import InfrahubWorkflow
-from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
-from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
 from infrahub.trace import configure_trace
+from infrahub.workers.dependencies import (
+    get_cache,
+    get_component,
+    get_database,
+    get_message_bus,
+    get_workflow,
+    set_component_type,
+)
 from infrahub.workers.utils import inject_service_parameter, load_flow_function
 from infrahub.workflows.models import TASK_RESULT_STORAGE_NAME
 
@@ -63,6 +65,7 @@ class InfrahubWorkerAsync(BaseWorker):
     _logo_url = "https://example.com/logo"
     _description = "Infrahub worker designed to run the flow in the main async loop."
     service: InfrahubServices  # keep a reference to `service` so we can inject it within flows parameters.
+    component_type = ComponentType.GIT_AGENT
 
     async def setup(
         self,
@@ -115,6 +118,7 @@ class InfrahubWorkerAsync(BaseWorker):
             )
         )
 
+        set_component_type(component_type=self.component_type)
         await self._init_services(client=client)
 
         if not registry.schema_has_been_initialized():
@@ -141,22 +145,18 @@ class InfrahubWorkerAsync(BaseWorker):
         entrypoint: str = configuration._related_objects["deployment"].entrypoint
 
         file_path, flow_name = entrypoint.split(":")
-        file_path.replace("/", ".")
-        module_path = file_path.replace("backend/", "").replace(".py", "").replace("/", ".")
+        module_path = file_path.removeprefix("backend/").removesuffix(".py").replace("/", ".")
         flow_func = load_flow_function(module_path=module_path, flow_name=flow_name)
         inject_service_parameter(func=flow_func, parameters=flow_run.parameters, service=self.service)
         flow_run_logger.debug("Validating parameters")
         params = flow_func.validate_parameters(parameters=flow_run.parameters)
 
         if task_status:
-            task_status.started()
+            task_status.started(True)
 
         await run_flow_async(flow=flow_func, flow_run=flow_run, parameters=params, return_type="state")
 
-        return InfrahubWorkerAsyncResult(
-            status_code=0,
-            identifier=str(flow_run.id),
-        )
+        return InfrahubWorkerAsyncResult(status_code=0, identifier=str(flow_run.id))
 
     def _init_logger(self) -> None:
         """Initialize loggers to use the API handle provided by Prefect."""
@@ -182,41 +182,17 @@ class InfrahubWorkerAsync(BaseWorker):
 
         return client
 
-    async def _init_database(self) -> InfrahubDatabase:
-        return InfrahubDatabase(driver=await get_db(retry=1))
-
-    async def _init_workflow(self) -> InfrahubWorkflow:
-        return config.OVERRIDE.workflow or (
-            WorkflowWorkerExecution()
-            if config.SETTINGS.workflow.driver == config.WorkflowDriver.WORKER
-            else WorkflowLocalExecution()
-        )
-
-    async def _init_message_bus(self, component_type: ComponentType) -> InfrahubMessageBus:
-        return config.OVERRIDE.message_bus or (
-            await InfrahubMessageBus.new_from_driver(
-                component_type=component_type, driver=config.SETTINGS.broker.driver
-            )
-        )
-
-    async def _init_cache(self) -> InfrahubCache:
-        return config.OVERRIDE.cache or (await InfrahubCache.new_from_driver(driver=config.SETTINGS.cache.driver))
-
     async def _init_services(self, client: InfrahubClient) -> None:
-        component_type = ComponentType.GIT_AGENT
         client = await self._init_infrahub_client(client=client)
-        database = await self._init_database()
-        workflow = await self._init_workflow()
-        message_bus = await self._init_message_bus(component_type=component_type)
-        cache = await self._init_cache()
 
         service = await InfrahubServices.new(
-            cache=cache,
+            cache=await get_cache(),
             client=client,
-            database=database,
-            message_bus=message_bus,
-            workflow=workflow,
-            component_type=component_type,
+            database=await get_database(),
+            message_bus=await get_message_bus(),
+            workflow=get_workflow(),
+            component=await get_component(),
+            component_type=self.component_type,
         )
 
         self.service = service

infrahub/workflows/catalogue.py

@@ -1,5 +1,7 @@
 import random
 
+from fast_depends import Depends, inject
+
 from .constants import WorkflowTag, WorkflowType
 from .models import WorkerPoolDefinition, WorkflowDefinition
 
@@ -529,9 +531,9 @@ VALIDATE_SCHEMA_NUMBER_POOLS = WorkflowDefinition(
 )
 
 
-worker_pools = [INFRAHUB_WORKER_POOL]
+WORKER_POOLS = [INFRAHUB_WORKER_POOL]
 
-workflows = [
+WORKFLOWS = [
     ACTION_ADD_NODE_TO_GROUP,
     ACTION_RUN_GENERATOR,
     ACTION_RUN_GENERATOR_GROUP_EVENT,
@@ -603,3 +605,15 @@ workflows = [
     WEBHOOK_DELETE_AUTOMATION,
     WEBHOOK_PROCESS,
 ]
+
+
+# Use this dependency injection mechanism to easily add new workflows within infrahub-enterprise
+def build_workflows_definitions() -> list[WorkflowDefinition]:
+    return WORKFLOWS
+
+
+@inject
+def get_workflows(
+    workflows: list[WorkflowDefinition] = Depends(build_workflows_definitions),  # noqa: B008
+) -> list[WorkflowDefinition]:
+    return workflows

infrahub/workflows/initialization.py

@@ -11,19 +11,20 @@ from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.trigger.models import TriggerType
 from infrahub.trigger.setup import setup_triggers
 
-from .catalogue import worker_pools, workflows
+from .catalogue import WORKER_POOLS, get_workflows
 from .models import TASK_RESULT_STORAGE_NAME
 
 
 @task(name="task-manager-setup-worker-pools", task_run_name="Setup Worker pools", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_worker_pools(client: PrefectClient) -> None:
     log = get_run_logger()
-    for worker in worker_pools:
+    for worker in WORKER_POOLS:
         wp = WorkPoolCreate(
             name=worker.name,
             type=worker.worker_type or config.SETTINGS.workflow.default_worker_type,
             description=worker.description,
         )
+
         try:
             await client.create_work_pool(work_pool=wp, overwrite=True)
             log.info(f"Work pool {worker.name} created successfully ... ")
@@ -34,10 +35,10 @@ async def setup_worker_pools(client: PrefectClient) -> None:
 @task(name="task-manager-setup-deployments", task_run_name="Setup Deployments", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_deployments(client: PrefectClient) -> None:
     log = get_run_logger()
-    for workflow in workflows:
+    for workflow in get_workflows():
         # For now the workpool is hardcoded but
         # later we need to make it dynamic to have a different worker based on the type of the workflow
-        work_pool = worker_pools[0]
+        work_pool = WORKER_POOLS[0]
         await workflow.save(client=client, work_pool=work_pool)
         log.info(f"Flow {workflow.name}, created successfully ... ")
 

infrahub/workflows/models.py

@@ -51,6 +51,8 @@ class WorkflowDefinition(BaseModel):
 
     @property
     def entrypoint(self) -> str:
+        if self.type == WorkflowType.USER:
+            return f"{self.module}:{self.function}"
         return f"backend/{self.module.replace('.', '/')}:{self.function}"
 
     @property

infrahub_sdk/client.py

@@ -790,7 +790,7 @@ class InfrahubClient(BaseClient):
         async def process_page(page_offset: int, page_number: int) -> tuple[dict, ProcessRelationsNode]:
             """Process a single page of results."""
             query_data = await InfrahubNode(client=self, schema=schema, branch=branch).generate_query_data(
-                offset=offset or page_offset,
+                offset=page_offset if offset is None else offset,
                 limit=limit or pagination_size,
                 filters=filters,
                 include=include,
@@ -1954,7 +1954,7 @@ class InfrahubClientSync(BaseClient):
         def process_page(page_offset: int, page_number: int) -> tuple[dict, ProcessRelationsNodeSync]:
             """Process a single page of results."""
             query_data = InfrahubNodeSync(client=self, schema=schema, branch=branch).generate_query_data(
-                offset=offset or page_offset,
+                offset=page_offset if offset is None else offset,
                 limit=limit or pagination_size,
                 filters=filters,
                 include=include,

infrahub_sdk/ctl/repository.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
 from typing import Optional
 
 import typer
 import yaml
+from copier import run_copy
 from pydantic import ValidationError
 from rich.console import Console
 from rich.table import Table
@@ -165,3 +167,52 @@ async def list(
         )
 
     console.print(table)
+
+
+@app.command()
+async def init(
+    directory: Path = typer.Argument(help="Directory path for the new project."),
+    template: str = typer.Option(
+        default="https://github.com/opsmill/infrahub-template.git",
+        help="Template to use for the new repository. Can be a local path or a git repository URL.",
+    ),
+    data: Optional[Path] = typer.Option(default=None, help="Path to YAML file containing answers to CLI prompt."),
+    vcs_ref: Optional[str] = typer.Option(
+        default="HEAD",
+        help="VCS reference to use for the template. Defaults to HEAD.",
+    ),
+    trust: Optional[bool] = typer.Option(
+        default=False,
+        help="Trust the template repository. If set, the template will be cloned without verification.",
+    ),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Initialize a new Infrahub repository."""
+
+    config_data = None
+    if data:
+        try:
+            with Path.open(data, encoding="utf-8") as file:
+                config_data = yaml.safe_load(file)
+            typer.echo(f"Loaded config: {config_data}")
+        except Exception as exc:
+            typer.echo(f"Error loading YAML file: {exc}", err=True)
+            raise typer.Exit(code=1)
+
+    # Allow template to be a local path or a URL
+    template_source = template or ""
+    if template and Path(template).exists():
+        template_source = str(Path(template).resolve())
+
+    try:
+        await asyncio.to_thread(
+            run_copy,
+            template_source,
+            str(directory),
+            data=config_data,
+            vcs_ref=vcs_ref,
+            unsafe=trust,
+        )
+    except Exception as e:
+        typer.echo(f"Error running copier: {e}", err=True)
+        raise typer.Exit(code=1)

infrahub_sdk/ctl/schema.py

@@ -36,7 +36,7 @@ def validate_schema_content_and_exit(client: InfrahubClient, schemas: list[Schem
     has_error: bool = False
     for schema_file in schemas:
         try:
-            client.schema.validate(data=schema_file.content)
+            client.schema.validate(data=schema_file.payload)
         except ValidationError as exc:
             console.print(f"[red]Schema not valid, found '{len(exc.errors())}' error(s) in {schema_file.location}")
             has_error = True
@@ -48,7 +48,7 @@ def validate_schema_content_and_exit(client: InfrahubClient, schemas: list[Schem
         raise typer.Exit(1)
 
 
-def display_schema_load_errors(response: dict[str, Any], schemas_data: list[dict]) -> None:
+def display_schema_load_errors(response: dict[str, Any], schemas_data: list[SchemaFile]) -> None:
     console.print("[red]Unable to load the schema:")
     if "detail" not in response:
         handle_non_detail_errors(response=response)
@@ -87,7 +87,7 @@ def handle_non_detail_errors(response: dict[str, Any]) -> None:
     if "error" in response:
         console.print(f"  {response.get('error')}")
     elif "errors" in response:
-        for error in response.get("errors"):
+        for error in response["errors"]:
             console.print(f"  {error.get('message')}")
     else:
         console.print(f"  '{response}'")
@@ -97,9 +97,9 @@ def valid_error_path(loc_path: list[Any]) -> bool:
     return len(loc_path) >= 6 and loc_path[0] == "body" and loc_path[1] == "schemas"
 
 
-def get_node(schemas_data: list[dict], schema_index: int, node_index: int) -> dict | None:
-    if schema_index < len(schemas_data) and node_index < len(schemas_data[schema_index].content["nodes"]):
-        return schemas_data[schema_index].content["nodes"][node_index]
+def get_node(schemas_data: list[SchemaFile], schema_index: int, node_index: int) -> dict | None:
+    if schema_index < len(schemas_data) and node_index < len(schemas_data[schema_index].payload["nodes"]):
+        return schemas_data[schema_index].payload["nodes"][node_index]
     return None
 
 
@@ -122,7 +122,7 @@ async def load(
     validate_schema_content_and_exit(client=client, schemas=schemas_data)
 
     start_time = time.time()
-    response = await client.schema.load(schemas=[item.content for item in schemas_data], branch=branch)
+    response = await client.schema.load(schemas=[item.payload for item in schemas_data], branch=branch)
     loading_time = time.time() - start_time
 
     if response.errors:
@@ -170,10 +170,10 @@ async def check(
     client = initialize_client()
     validate_schema_content_and_exit(client=client, schemas=schemas_data)
 
-    success, response = await client.schema.check(schemas=[item.content for item in schemas_data], branch=branch)
+    success, response = await client.schema.check(schemas=[item.payload for item in schemas_data], branch=branch)
 
     if not success:
-        display_schema_load_errors(response=response, schemas_data=schemas_data)
+        display_schema_load_errors(response=response or {}, schemas_data=schemas_data)
     else:
         for schema_file in schemas_data:
             console.print(f"[green] schema '{schema_file.location}' is Valid!")

infrahub_sdk/node/node.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from copy import copy
+from copy import copy, deepcopy
 from typing import TYPE_CHECKING, Any
 
 from ..constants import InfrahubClientMode
@@ -397,7 +397,7 @@ class InfrahubNodeBase:
             "edges": {"node": {"id": None, "hfid": None, "display_label": None, "__typename": None}},
         }
 
-        data["@filters"] = filters or {}
+        data["@filters"] = deepcopy(filters) if filters is not None else {}
 
         if order:
             data["@filters"]["order"] = order

infrahub_sdk/pytest_plugin/items/graphql_query.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 class InfrahubGraphQLQueryItem(InfrahubItem):
     def validate_resource_config(self) -> None:
-        # Resource name does not need to match against infrahub repo config
+        # Resource name does not need to match against Infrahub repository configuration
         return
 
     def execute_query(self) -> Any:

infrahub_sdk/schema/repository.py

@@ -24,7 +24,7 @@ ResourceClass = TypeVar("ResourceClass")
 
 
 class InfrahubRepositoryConfigElement(BaseModel):
-    """Class to regroup all elements of the infrahub configuration for a repository for typing purpose."""
+    """Class to regroup all elements of the Infrahub configuration for a repository for typing purpose."""
 
 
 class InfrahubRepositoryArtifactDefinitionConfig(InfrahubRepositoryConfigElement):

infrahub_sdk/testing/docker.py

@@ -13,7 +13,7 @@ INFRAHUB_VERSION = os.getenv("INFRAHUB_TESTING_IMAGE_VER")
 
 def skip_version(min_infrahub_version: str | None = None, max_infrahub_version: str | None = None) -> bool:
     """
-    Check if a test should be skipped depending on infrahub version.
+    Check if a test should be skipped depending on Infrahub version.
     """
     if INFRAHUB_VERSION is None:
         return True

infrahub_sdk/utils.py

@@ -95,7 +95,7 @@ def decode_json(response: httpx.Response) -> dict:
     try:
         return response.json()
     except json.decoder.JSONDecodeError as exc:
-        raise JsonDecodeError(content=response.text, url=response.url) from exc
+        raise JsonDecodeError(content=response.text, url=str(response.url)) from exc
 
 
 def generate_uuid() -> str:
@@ -232,7 +232,7 @@ def get_branch(branch: str | None = None, directory: str | Path = ".") -> str:
     if branch:
         return branch
 
-    repo = GitRepoManager(directory)
+    repo = GitRepoManager(root_directory=str(directory))
     return str(repo.active_branch)
 
 

{infrahub_server-1.3.7.dist-info → infrahub_server-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.3.7
+Version: 1.4.0
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: Apache-2.0
 Author: OpsMill
@@ -19,9 +19,11 @@ Requires-Dist: asgi-correlation-id (==4.2.0)
 Requires-Dist: authlib (==1.3.2)
 Requires-Dist: bcrypt (>=4.1,<4.2)
 Requires-Dist: boto3 (==1.34.129)
+Requires-Dist: copier (>=9.8.0,<10.0.0)
 Requires-Dist: dulwich (>=0.22.7,<0.23.0)
 Requires-Dist: email-validator (>=2.1,<2.2)
-Requires-Dist: fastapi (>=0.115,<0.116)
+Requires-Dist: fast-depends (>=2.4.12,<3.0.0)
+Requires-Dist: fastapi (==0.116.1)
 Requires-Dist: fastapi-storages (>=0.3,<0.4)
 Requires-Dist: gitpython (>=3,<4)
 Requires-Dist: graphene (>=3.4,<3.5)
@@ -38,8 +40,8 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (==1.28.1)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (==1.28.1)
 Requires-Dist: opentelemetry-instrumentation-aio-pika (==0.49b1)
 Requires-Dist: opentelemetry-instrumentation-fastapi (==0.49b1)
-Requires-Dist: prefect (==3.4.1)
-Requires-Dist: prefect-redis (==0.2.2)
+Requires-Dist: prefect (==3.4.13)
+Requires-Dist: prefect-redis (==0.2.4)
 Requires-Dist: pyarrow (>=14,<15)
 Requires-Dist: pydantic (>=2.10,<2.11)
 Requires-Dist: pydantic-settings (>=2.8,<2.9)
@@ -47,7 +49,7 @@ Requires-Dist: pyjwt (>=2.8,<2.9)
 Requires-Dist: pytest (>=7.4,<7.5)
 Requires-Dist: python-multipart (==0.0.18)
 Requires-Dist: pyyaml (>=6,<7)
-Requires-Dist: redis[hiredis] (>=5.0.0,<6.0.0)
+Requires-Dist: redis[hiredis] (>=6.0.0,<7.0.0)
 Requires-Dist: rich (>=13,<14)
 Requires-Dist: starlette-exporter (>=0.23,<0.24)
 Requires-Dist: structlog (==24.1.0)