Merge pull request #4884 from opsmill/lgu-migrate-git-respo-add-read-only

Migrate GitRepositoryAddReadOnly to prefect

Author: LucasG0

backend/infrahub/git/models.py

@@ -47,6 +47,18 @@ class GitRepositoryAdd(BaseModel):
     internal_status: str = Field(..., description="Administrative status of the repository")
 
 
+class GitRepositoryAddReadOnly(BaseModel):
+    """Clone and sync an external repository after creation."""
+
+    location: str = Field(..., description="The external URL of the repository")
+    repository_id: str = Field(..., description="The unique ID of the Repository")
+    repository_name: str = Field(..., description="The name of the repository")
+    ref: str = Field(..., description="Ref to track on the external repository")
+    created_by: Optional[str] = Field(default=None, description="The user ID of the user that created the repository")
+    infrahub_branch_name: str = Field(..., description="Infrahub branch on which to sync the remote repository")
+    internal_status: str = Field(..., description="Internal status of the repository")
+
+
 class GitRepositoryPullReadOnly(BaseModel):
     """Update a read-only repository to the latest commit for its ref"""
 

backend/infrahub/git/tasks.py

@@ -14,6 +14,7 @@
 from ..workflows.utils import add_branch_tag
 from .models import (
     GitRepositoryAdd,
+    GitRepositoryAddReadOnly,
     GitRepositoryMerge,
     GitRepositoryPullReadOnly,
     RequestArtifactDefinitionGenerate,
@@ -24,9 +25,13 @@
 log = get_logger()
 
 
-@flow(name="git-repository-add-read-write")
+@flow(
+    name="git-repository-add-read-write",
+    flow_run_name="Adding repository {model.repository_name} in branch {model.infrahub_branch_name}",
+)
 async def add_git_repository(model: GitRepositoryAdd) -> None:
     service = services.service
+    await add_branch_tag(model.infrahub_branch_name)
     async with service.git_report(
         related_node=model.repository_id,
         title=f"Initial import of the repository in branch: {model.infrahub_branch_name}",
@@ -50,6 +55,33 @@ async def add_git_repository(model: GitRepositoryAdd) -> None:
                 await repo.sync()
 
 
+@flow(
+    name="git-repository-add-read-only",
+    flow_run_name="Adding read only repository {model.repository_name} in branch {model.infrahub_branch_name}",
+)
+async def add_git_repository_read_only(model: GitRepositoryAddReadOnly) -> None:
+    service = services.service
+    await add_branch_tag(model.infrahub_branch_name)
+    async with service.git_report(
+        related_node=model.repository_id,
+        title="Adding Repository",
+        created_by=model.created_by,
+    ) as git_report:
+        async with lock.registry.get(name=model.repository_name, namespace="repository"):
+            repo = await InfrahubReadOnlyRepository.new(
+                id=model.repository_id,
+                name=model.repository_name,
+                location=model.location,
+                client=service.client,
+                ref=model.ref,
+                infrahub_branch_name=model.infrahub_branch_name,
+                task_report=git_report,
+            )
+            await repo.import_objects_from_files(infrahub_branch_name=model.infrahub_branch_name)
+            if model.internal_status == RepositoryInternalStatus.ACTIVE.value:
+                await repo.sync_from_remote()
+
+
 @flow(name="git_repositories_create_branch")
 async def create_branch(branch: str, branch_id: str) -> None:
     """Request to the creation of git branches in available repositories."""

backend/infrahub/graphql/mutations/repository.py

@@ -10,12 +10,16 @@
 from infrahub.core.protocols import CoreGenericRepository, CoreReadOnlyRepository, CoreRepository
 from infrahub.core.schema import NodeSchema
 from infrahub.exceptions import ValidationError
-from infrahub.git.models import GitRepositoryAdd, GitRepositoryPullReadOnly
+from infrahub.git.models import GitRepositoryAdd, GitRepositoryAddReadOnly, GitRepositoryPullReadOnly
 from infrahub.graphql.types.common import IdentifierInput
 from infrahub.log import get_logger
 from infrahub.message_bus import messages
 from infrahub.message_bus.messages.git_repository_connectivity import GitRepositoryConnectivityResponse
-from infrahub.workflows.catalogue import GIT_REPOSITORIES_PULL_READ_ONLY, GIT_REPOSITORY_ADD
+from infrahub.workflows.catalogue import (
+    GIT_REPOSITORIES_PULL_READ_ONLY,
+    GIT_REPOSITORY_ADD,
+    GIT_REPOSITORY_ADD_READ_ONLY,
+)
 
 from .main import InfrahubMutationMixin, InfrahubMutationOptions
 
@@ -90,7 +94,7 @@ async def mutate_create(
             authenticated_user = context.account_session.account_id
         if obj.get_kind() == InfrahubKind.READONLYREPOSITORY:
             obj = cast(CoreReadOnlyRepository, obj)
-            message = messages.GitRepositoryAddReadOnly(
+            model = GitRepositoryAddReadOnly(
                 repository_id=obj.id,
                 repository_name=obj.name.value,
                 location=obj.location.value,
@@ -100,7 +104,9 @@ async def mutate_create(
                 created_by=authenticated_user,
             )
             if context.service:
-                await context.service.send(message=message)
+                await context.service.workflow.submit_workflow(
+                    workflow=GIT_REPOSITORY_ADD_READ_ONLY, parameters={"model": model}
+                )
 
         else:
             obj = cast(CoreRepository, obj)

backend/infrahub/message_bus/messages/__init__.py

@@ -17,7 +17,6 @@
 from .git_file_get import GitFileGet, GitFileGetResponse
 from .git_repository_connectivity import GitRepositoryConnectivity
 from .git_repository_importobjects import GitRepositoryImportObjects
-from .git_repository_read_only_add import GitRepositoryAddReadOnly
 from .proposed_change.request_proposedchange_dataintegrity import RequestProposedChangeDataIntegrity
 from .proposed_change.request_proposedchange_refreshartifacts import RequestProposedChangeRefreshArtifacts
 from .proposed_change.request_proposedchange_repositorychecks import RequestProposedChangeRepositoryChecks
@@ -54,7 +53,6 @@
     "git.diff.names_only": GitDiffNamesOnly,
     "git.file.get": GitFileGet,
     "git.repository.connectivity": GitRepositoryConnectivity,
-    "git.repository.add_read_only": GitRepositoryAddReadOnly,
     "git.repository.import_objects": GitRepositoryImportObjects,
     "schema.migration.path": SchemaMigrationPath,
     "schema.validator.path": SchemaValidatorPath,

backend/infrahub/message_bus/messages/git_repository_read_only_add.py

@@ -34,7 +34,6 @@
     "finalize.validator.execution": finalize.validator.execution,
     "git.diff.names_only": git.diff.names_only,
     "git.file.get": git.file.get,
-    "git.repository.add_read_only": git.repository.add_read_only,
     "git.repository.connectivity": git.repository.connectivity,
     "git.repository.import_objects": git.repository.import_objects,
     "refresh.registry.branches": refresh.registry.branches,

backend/infrahub/message_bus/operations/__init__.py

@@ -1,9 +1,7 @@
 from prefect import flow
 
-from infrahub import lock
-from infrahub.core.constants import RepositoryInternalStatus
 from infrahub.exceptions import RepositoryError
-from infrahub.git.repository import InfrahubReadOnlyRepository, InfrahubRepository, get_initialized_repo
+from infrahub.git.repository import InfrahubRepository, get_initialized_repo
 from infrahub.log import get_logger
 from infrahub.message_bus import messages
 from infrahub.message_bus.messages.git_repository_connectivity import (
@@ -15,31 +13,6 @@
 log = get_logger()
 
 
-@flow(name="git-repository-add-read-only")
-async def add_read_only(message: messages.GitRepositoryAddReadOnly, service: InfrahubServices) -> None:
-    log.info(
-        "Cloning and importing read-only repository", repository=message.repository_name, location=message.location
-    )
-    async with service.git_report(
-        related_node=message.repository_id,
-        title="Adding Repository",
-        created_by=message.created_by,
-    ) as git_report:
-        async with lock.registry.get(name=message.repository_name, namespace="repository"):
-            repo = await InfrahubReadOnlyRepository.new(
-                id=message.repository_id,
-                name=message.repository_name,
-                location=message.location,
-                client=service.client,
-                ref=message.ref,
-                infrahub_branch_name=message.infrahub_branch_name,
-                task_report=git_report,
-            )
-            await repo.import_objects_from_files(infrahub_branch_name=message.infrahub_branch_name)
-            if message.internal_status == RepositoryInternalStatus.ACTIVE.value:
-                await repo.sync_from_remote()
-
-
 @flow(name="git-repository-check-connectivity")
 async def connectivity(message: messages.GitRepositoryConnectivity, service: InfrahubServices) -> None:
     response_data = GitRepositoryConnectivityResponseData(message="Successfully accessed repository", success=True)

backend/infrahub/message_bus/operations/git/repository.py

@@ -147,6 +147,15 @@
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+GIT_REPOSITORY_ADD_READ_ONLY = WorkflowDefinition(
+    name="git-repository-add-read-only",
+    type=WorkflowType.INTERNAL,
+    module="infrahub.git.tasks",
+    function="add_git_repository_read_only",
+    branch_support=BranchSupportType.AWARE,
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
 GIT_REPOSITORIES_PULL_READ_ONLY = WorkflowDefinition(
     name="git-repository-pull-read-only",
     type=WorkflowType.INTERNAL,
@@ -263,6 +272,7 @@
     REQUEST_GENERATOR_DEFINITION_RUN,
     UPDATE_GRAPHQL_QUERY_GROUP,
     GIT_REPOSITORY_ADD,
+    GIT_REPOSITORY_ADD_READ_ONLY,
     PROCESS_COMPUTED_MACRO,
     COMPUTED_ATTRIBUTE_SETUP,
     UPDATE_COMPUTED_ATTRIBUTE_TRANSFORM,

backend/infrahub/workflows/catalogue.py

@@ -29,7 +29,7 @@
 
 class TestCreateReadOnlyRepository(TestInfrahubApp):
     def setup_method(self):
-        lock_patcher = patch("infrahub.message_bus.operations.git.repository.lock")
+        lock_patcher = patch("infrahub.git.tasks.lock")
         self.mock_infra_lock = lock_patcher.start()
         self.mock_infra_lock.registry = AsyncMock(spec=InfrahubLockRegistry)
 

backend/tests/integration/git/test_readonly_repository.py

@@ -10,12 +10,16 @@
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
 from infrahub.exceptions import RepositoryError
 from infrahub.git import InfrahubRepository
-from infrahub.git.models import GitRepositoryAdd, GitRepositoryMerge, GitRepositoryPullReadOnly
+from infrahub.git.models import (
+    GitRepositoryAdd,
+    GitRepositoryAddReadOnly,
+    GitRepositoryMerge,
+    GitRepositoryPullReadOnly,
+)
 from infrahub.git.repository import InfrahubReadOnlyRepository
-from infrahub.git.tasks import add_git_repository, pull_read_only
+from infrahub.git.tasks import add_git_repository, add_git_repository_read_only, pull_read_only
 from infrahub.lock import InfrahubLockRegistry
 from infrahub.message_bus import Meta, messages
-from infrahub.message_bus.operations import git
 from infrahub.services import InfrahubServices, services
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from infrahub.workflows.catalogue import GIT_REPOSITORIES_MERGE
@@ -197,25 +201,26 @@ class TestAddReadOnly:
     def setup_method(self):
         self.client = AsyncMock(spec=InfrahubClient)
         self.git_report = AsyncContextManagerMock()
-        self.services = InfrahubServices(client=self.client)
-        self.services.git_report = self.git_report
 
-        lock_patcher = patch("infrahub.message_bus.operations.git.repository.lock")
+        self.original_services = services.service
+        services.service = InfrahubServices(client=self.client)
+        services.service.git_report = self.git_report
+
+        lock_patcher = patch("infrahub.git.tasks.lock")
         self.mock_infra_lock = lock_patcher.start()
         self.mock_infra_lock.registry = AsyncMock(spec=InfrahubLockRegistry)
-        repo_class_patcher = patch(
-            "infrahub.message_bus.operations.git.repository.InfrahubReadOnlyRepository", spec=InfrahubReadOnlyRepository
-        )
+        repo_class_patcher = patch("infrahub.git.tasks.InfrahubReadOnlyRepository", spec=InfrahubReadOnlyRepository)
         self.mock_repo_class = repo_class_patcher.start()
         self.mock_repo = AsyncMock(spec=InfrahubReadOnlyRepository)
         self.mock_repo_class.new.return_value = self.mock_repo
 
     def teardown_method(self):
         patch.stopall()
+        services.service = self.original_services
 
     async def test_git_rpc_add_read_only_success(self, git_upstream_repo_01: dict[str, str]):
         repo_id = str(UUIDT())
-        message = messages.GitRepositoryAddReadOnly(
+        model = GitRepositoryAddReadOnly(
             repository_id=repo_id,
             repository_name=git_upstream_repo_01["name"],
             location=git_upstream_repo_01["path"],
@@ -224,7 +229,7 @@ async def test_git_rpc_add_read_only_success(self, git_upstream_repo_01: dict[st
             internal_status="active",
         )
 
-        await git.repository.add_read_only(message=message, service=self.services)
+        await add_git_repository_read_only(model=model)
 
         self.mock_infra_lock.registry.get(name=git_upstream_repo_01["name"], namespace="repository")
         self.mock_repo_class.new.assert_awaited_once_with(