infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/generators/tasks.py

@@ -21,25 +21,29 @@ from infrahub.generators.models import (
 )
 from infrahub.git.base import extract_repo_file_information
 from infrahub.git.repository import get_initialized_repo
-from infrahub.services import InfrahubServices  # noqa: TC001 needed for prefect flow
+from infrahub.workers.dependencies import get_client, get_workflow
 from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN, REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
 
 if TYPE_CHECKING:
     from collections.abc import Coroutine
 
+    from infrahub_sdk.client import InfrahubClient
+
 
 @flow(
     name="generator-run",
     flow_run_name="Run generator {model.generator_definition.definition_name}",
 )
-async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -> None:
+async def run_generator(model: RequestGeneratorRun) -> None:
     await add_tags(branches=[model.branch_name], nodes=[model.target_id])
 
+    client = get_client()
+
     repository = await get_initialized_repo(
+        client=client,
         repository_id=model.repository_id,
         name=model.repository_name,
-        service=service,
         repository_kind=model.repository_kind,
         commit=model.commit,
     )
@@ -60,7 +64,7 @@ async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -
         repo_directory=repository.directory_root,
         worktree_directory=commit_worktree.directory,
     )
-    generator_instance = await _define_instance(model=model, service=service)
+    generator_instance = await _define_instance(model=model, client=client)
 
     try:
         generator_class = generator_definition.load_class(
@@ -69,7 +73,7 @@ async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -
 
         generator = generator_class(
             query=generator_definition.query,
-            client=service.client,
+            client=client,
             branch=model.branch_name,
             params=model.variables,
             generator_instance=generator_instance.id,
@@ -87,11 +91,9 @@ async def run_generator(model: RequestGeneratorRun, service: InfrahubServices) -
 
 
 @task(name="generator-define-instance", task_run_name="Define Instance", cache_policy=NONE)  # type: ignore[arg-type]
-async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices) -> CoreGeneratorInstance:
+async def _define_instance(model: RequestGeneratorRun, client: InfrahubClient) -> CoreGeneratorInstance:
     if model.generator_instance:
-        instance = await service.client.get(
-            kind=CoreGeneratorInstance, id=model.generator_instance, branch=model.branch_name
-        )
+        instance = await client.get(kind=CoreGeneratorInstance, id=model.generator_instance, branch=model.branch_name)
         instance.status.value = GeneratorInstanceStatus.PENDING.value
         await instance.update(do_full_update=True)
 
@@ -99,7 +101,7 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
         async with lock.registry.get(
             f"{model.target_id}-{model.generator_definition.definition_id}", namespace="generator"
         ):
-            instances = await service.client.filters(
+            instances = await client.filters(
                 kind=CoreGeneratorInstance,
                 definition__ids=[model.generator_definition.definition_id],
                 object__ids=[model.target_id],
@@ -110,7 +112,7 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
                 instance.status.value = GeneratorInstanceStatus.PENDING.value
                 await instance.update(do_full_update=True)
             else:
-                instance = await service.client.create(
+                instance = await client.create(
                     kind=CoreGeneratorInstance,
                     branch=model.branch_name,
                     data={
@@ -125,10 +127,10 @@ async def _define_instance(model: RequestGeneratorRun, service: InfrahubServices
 
 
 @flow(name="generator-definition-run", flow_run_name="Run all generators")
-async def run_generator_definition(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+async def run_generator_definition(branch: str, context: InfrahubContext) -> None:
     await add_tags(branches=[branch])
 
-    generators = await service.client.filters(
+    generators = await get_client().filters(
         kind=InfrahubKind.GENERATORDEFINITION, prefetch_relationships=True, populate_store=True, branch=branch
     )
 
@@ -150,7 +152,7 @@ async def run_generator_definition(branch: str, context: InfrahubContext, servic
 
     for generator_definition in generator_definitions:
         model = RequestGeneratorDefinitionRun(branch=branch, generator_definition=generator_definition)
-        await service.workflow.submit_workflow(
+        await get_workflow().submit_workflow(
             workflow=REQUEST_GENERATOR_DEFINITION_RUN, context=context, parameters={"model": model}
         )
 
@@ -160,11 +162,13 @@ async def run_generator_definition(branch: str, context: InfrahubContext, servic
     flow_run_name="Execute generator {model.generator_definition.definition_name}",
 )
 async def request_generator_definition_run(
-    model: RequestGeneratorDefinitionRun, context: InfrahubContext, service: InfrahubServices
+    model: RequestGeneratorDefinitionRun, context: InfrahubContext
 ) -> State[Any]:
     await add_tags(branches=[model.branch], nodes=[model.generator_definition.definition_id])
 
-    group = await service.client.get(
+    client = get_client()
+
+    group = await client.get(
         kind=InfrahubKind.GENERICGROUP,
         prefetch_relationships=True,
         populate_store=True,
@@ -173,7 +177,7 @@ async def request_generator_definition_run(
     )
     await group.members.fetch()
 
-    existing_instances = await service.client.filters(
+    existing_instances = await client.filters(
         kind=InfrahubKind.GENERATORINSTANCE,
         definition__ids=[model.generator_definition.definition_id],
         include=["object"],
@@ -183,14 +187,14 @@ async def request_generator_definition_run(
     for instance in existing_instances:
         instance_by_member[instance.object.peer.id] = instance.id
 
-    repository = await service.client.get(
+    repository = await client.get(
         kind=InfrahubKind.REPOSITORY,
         branch=model.branch,
         id=model.generator_definition.repository_id,
         raise_when_missing=False,
     )
     if not repository:
-        repository = await service.client.get(
+        repository = await client.get(
             kind=InfrahubKind.READONLYREPOSITORY,
             branch=model.branch,
             id=model.generator_definition.repository_id,
@@ -219,7 +223,7 @@ async def request_generator_definition_run(
             target_name=member.display_label,
         )
         tasks.append(
-            service.workflow.execute_workflow(
+            get_workflow().execute_workflow(
                 workflow=REQUEST_GENERATOR_RUN, context=context, parameters={"model": request_generator_run_model}
             )
         )

infrahub/git/base.py

@@ -33,7 +33,7 @@ from infrahub.git.constants import BRANCHES_DIRECTORY_NAME, COMMITS_DIRECTORY_NA
 from infrahub.git.directory import get_repositories_directory, initialize_repositories_directory
 from infrahub.git.worktree import Worktree
 from infrahub.log import get_logger
-from infrahub.services import InfrahubServices  # noqa: TC001
+from infrahub.workers.dependencies import get_client
 
 if TYPE_CHECKING:
     from infrahub_sdk.branch import BranchData
@@ -153,9 +153,6 @@ class InfrahubRepositoryBase(BaseModel, ABC):
     )
 
     cache_repo: Repo | None = Field(None, description="Internal cache of the GitPython Repo object")
-    service: InfrahubServices = Field(
-        ..., description="Service object with access to the message queue, the database etc.."
-    )
     is_read_only: bool = Field(False, description="If true, changes will not be synced to remote")
 
     internal_status: str = Field("active", description="Internal status: Active, Inactive, Staging")
@@ -169,10 +166,10 @@ class InfrahubRepositoryBase(BaseModel, ABC):
 
     @property
     def sdk(self) -> InfrahubClient:
-        if self.client:
-            return self.client
+        if not self.client:
+            self.client = get_client()
 
-        return self.service.client
+        return self.client
 
     @property
     def default_branch(self) -> str:

infrahub/git/integrator.py

@@ -50,6 +50,7 @@ from infrahub.events.repository_action import CommitUpdatedEvent
 from infrahub.exceptions import CheckError, RepositoryInvalidFileSystemError, TransformError
 from infrahub.git.base import InfrahubRepositoryBase, extract_repo_file_information
 from infrahub.log import get_logger
+from infrahub.workers.dependencies import get_event_service
 from infrahub.workflows.utils import add_tags
 
 if TYPE_CHECKING:
@@ -62,7 +63,6 @@ if TYPE_CHECKING:
 
     from infrahub.artifacts.models import CheckArtifactCreate
     from infrahub.git.models import RequestArtifactGenerate
-    from infrahub.services import InfrahubServices
 
 
 class ArtifactGenerateResult(BaseModel):
@@ -141,8 +141,8 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     """
 
     @classmethod
-    async def init(cls, service: InfrahubServices, commit: str | None = None, **kwargs: Any) -> Self:
-        self = cls(service=service, **kwargs)
+    async def init(cls, commit: str | None = None, **kwargs: Any) -> Self:
+        self = cls(**kwargs)
         log = get_logger()
         try:
             self.validate_local_directories()
@@ -216,7 +216,8 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             raise error
 
         infrahub_branch = registry.get_branch_from_registry(branch=infrahub_branch_name)
-        await self.service.event.send(
+        event_service = await get_event_service()
+        await event_service.send(
             CommitUpdatedEvent(
                 commit=commit,
                 repository_name=self.name,
@@ -436,10 +437,18 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         branch_wt = self.get_worktree(identifier=commit or branch_name)
         log = get_run_logger()
 
-        config_file_name = ".infrahub.yml"
-        config_file = branch_wt.directory / config_file_name
-        if not config_file.is_file():
-            log.debug(f"Unable to find the configuration file {config_file_name}, skipping")
+        # Check for both .infrahub.yml and .infrahub.yaml, prefer .yml if both exist
+        config_file_yml = branch_wt.directory / ".infrahub.yml"
+        config_file_yaml = branch_wt.directory / ".infrahub.yaml"
+
+        if config_file_yml.is_file():
+            config_file = config_file_yml
+            config_file_name = ".infrahub.yml"
+        elif config_file_yaml.is_file():
+            config_file = config_file_yaml
+            config_file_name = ".infrahub.yaml"
+        else:
+            log.debug("Unable to find the configuration file (.infrahub.yml or .infrahub.yaml), skipping")
             return None
 
         config_file_content = config_file.read_text(encoding="utf-8")
@@ -1264,7 +1273,6 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 infrahub_node=InfrahubNode,
             )
             return await transform.run(data=data)
-
         except ModuleNotFoundError as exc:
             error_msg = f"Unable to load the transform file {location}"
             log.error(error_msg)
@@ -1314,11 +1322,11 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             artifact_content = await self.execute_python_transform.with_options(
                 timeout_seconds=transformation.timeout.value
             )(
+                client=self.sdk,
                 branch_name=branch_name,
                 commit=commit,
                 location=transformation_location,
                 data=response,
-                client=self.sdk,
                 convert_query_response=transformation.convert_query_response.value,
             )  # type: ignore[misc]
 
@@ -1374,11 +1382,11 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             )  # type: ignore[misc]
         elif message.transform_type == InfrahubKind.TRANSFORMPYTHON:
             artifact_content = await self.execute_python_transform.with_options(timeout_seconds=message.timeout)(
+                client=self.sdk,
                 branch_name=message.branch_name,
                 commit=message.commit,
                 location=message.transform_location,
                 data=response,
-                client=self.sdk,
                 convert_query_response=message.convert_query_response,
             )  # type: ignore[misc]
 
@@ -1421,7 +1429,8 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             storage_id_previous=previous_storage_id,
         )
 
-        await self.service.event.send(event=event)
+        event_service = await get_event_service()
+        await event_service.send(event=event)
         return ArtifactGenerateResult(changed=True, checksum=checksum, storage_id=storage_id, artifact_id=artifact.id)
 
 

infrahub/git/repository.py

@@ -4,6 +4,8 @@ from typing import TYPE_CHECKING, Any
 
 from git.exc import BadName, GitCommandError
 from infrahub_sdk.exceptions import GraphQLError
+from prefect import task
+from prefect.cache_policies import NONE
 from pydantic import Field
 
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
@@ -12,7 +14,7 @@ from infrahub.git.integrator import InfrahubRepositoryIntegrator
 from infrahub.log import get_logger
 
 if TYPE_CHECKING:
-    from infrahub.services import InfrahubServices
+    from infrahub_sdk.client import InfrahubClient
 
 log = get_logger()
 
@@ -25,10 +27,8 @@ class InfrahubRepository(InfrahubRepositoryIntegrator):
     """
 
     @classmethod
-    async def new(
-        cls, service: InfrahubServices, update_commit_value: bool = True, **kwargs: Any
-    ) -> InfrahubRepository:
-        self = cls(service=service, **kwargs)
+    async def new(cls, update_commit_value: bool = True, **kwargs: Any) -> InfrahubRepository:
+        self = cls(**kwargs)
         await self.create_locally(
             infrahub_branch_name=self.infrahub_branch_name, update_commit_value=update_commit_value
         )
@@ -209,11 +209,11 @@ class InfrahubReadOnlyRepository(InfrahubRepositoryIntegrator):
     ref: str | None = Field(None, description="Ref to track on the external repository")
 
     @classmethod
-    async def new(cls, service: InfrahubServices, **kwargs: Any) -> InfrahubReadOnlyRepository:
+    async def new(cls, **kwargs: Any) -> InfrahubReadOnlyRepository:
         if "ref" not in kwargs or "infrahub_branch_name" not in kwargs:
             raise ValueError("ref and infrahub_branch_name are mandatory to initialize a new Read-Only repository")
 
-        self = cls(service=service, **kwargs)
+        self = cls(**kwargs)
         await self.create_locally(checkout_ref=self.ref, infrahub_branch_name=self.infrahub_branch_name)
         log.info("Created new repository locally.", repository=self.name)
         return self
@@ -248,33 +248,18 @@ class InfrahubReadOnlyRepository(InfrahubRepositoryIntegrator):
         await self.update_commit_value(branch_name=self.infrahub_branch_name, commit=commit)
 
 
+@task(
+    name="Fetch repository commit",
+    description="Retrieve a git repository at a given commit, if it does not already exist locally",
+    cache_policy=NONE,
+)
 async def get_initialized_repo(
-    repository_id: str, name: str, service: InfrahubServices, repository_kind: str, commit: str | None = None
+    client: InfrahubClient, repository_id: str, name: str, repository_kind: str, commit: str | None = None
 ) -> InfrahubReadOnlyRepository | InfrahubRepository:
     if repository_kind == InfrahubKind.REPOSITORY:
-        return await InfrahubRepository.init(
-            id=repository_id, name=name, commit=commit, client=service._client, service=service
-        )
-
-    if repository_kind == InfrahubKind.READONLYREPOSITORY:
-        return await InfrahubReadOnlyRepository.init(
-            id=repository_id, name=name, commit=commit, client=service._client, service=service
-        )
-
-    raise NotImplementedError(f"The repository kind {repository_kind} has not been implemented")
-
-
-async def initialize_repo(
-    location: str, repository_id: str, name: str, service: InfrahubServices, repository_kind: str
-) -> InfrahubReadOnlyRepository | InfrahubRepository:
-    if repository_kind == InfrahubKind.REPOSITORY:
-        return await InfrahubRepository.new(
-            location=location, id=repository_id, name=name, client=service._client, service=service
-        )
+        return await InfrahubRepository.init(id=repository_id, name=name, commit=commit, client=client)
 
     if repository_kind == InfrahubKind.READONLYREPOSITORY:
-        return await InfrahubReadOnlyRepository.new(
-            location=location, id=repository_id, name=name, client=service._client, service=service
-        )
+        return await InfrahubReadOnlyRepository.init(id=repository_id, name=name, commit=commit, client=client)
 
     raise NotImplementedError(f"The repository kind {repository_kind} has not been implemented")