infrahub-server 1.1.9__py3-none-any.whl → 1.2.0__py3-none-any.whl

infrahub/message_bus/operations/requests/generator_definition.py

@@ -1,14 +1,14 @@
-from typing import Optional
-
+from infrahub_sdk.protocols import CoreGeneratorValidator
 from infrahub_sdk.uuidt import UUIDT
 from prefect import flow
 from prefect.logging import get_run_logger
 
-from infrahub.core.constants import InfrahubKind, ValidatorConclusion, ValidatorState
+from infrahub.core.constants import InfrahubKind
 from infrahub.core.timestamp import Timestamp
 from infrahub.message_bus import InfrahubMessage, Meta, messages
 from infrahub.message_bus.types import KVTTL
 from infrahub.services import InfrahubServices
+from infrahub.validators.tasks import start_validator
 from infrahub.workflows.utils import add_tags
 
 
@@ -29,31 +29,26 @@ async def check(message: messages.RequestGeneratorDefinitionCheck, service: Infr
 
     await proposed_change.validations.fetch()
 
-    validator = None
+    previous_validator: CoreGeneratorValidator | None = None
     for relationship in proposed_change.validations.peers:
         existing_validator = relationship.peer
         if (
             existing_validator.typename == InfrahubKind.GENERATORVALIDATOR
             and existing_validator.definition.id == message.generator_definition.definition_id
         ):
-            validator = existing_validator
-
-    if validator:
-        validator.conclusion.value = ValidatorConclusion.UNKNOWN.value
-        validator.state.value = ValidatorState.QUEUED.value
-        validator.started_at.value = ""
-        validator.completed_at.value = ""
-        await validator.save()
-    else:
-        validator = await service.client.create(
-            kind=InfrahubKind.GENERATORVALIDATOR,
-            data={
-                "label": validator_name,
-                "proposed_change": message.proposed_change,
-                "definition": message.generator_definition.definition_id,
-            },
-        )
-        await validator.save()
+            previous_validator = existing_validator
+
+    validator = await start_validator(
+        service=service,
+        validator=previous_validator,
+        validator_type=CoreGeneratorValidator,
+        proposed_change=message.proposed_change,
+        data={
+            "label": validator_name,
+            "definition": message.generator_definition.definition_id,
+        },
+        context=message.context,
+    )
 
     group = await service.client.get(
         kind=InfrahubKind.GENERICGROUP,
@@ -92,6 +87,7 @@ async def check(message: messages.RequestGeneratorDefinitionCheck, service: Infr
             log.info(f"Trigger execution of {message.generator_definition.definition_name} for {member.display_label}")
             events.append(
                 messages.CheckGeneratorRun(
+                    context=message.context,
                     generator_definition=message.generator_definition,
                     generator_instance=generator_instance,
                     commit=repository.source_commit,
@@ -121,14 +117,16 @@ async def check(message: messages.RequestGeneratorDefinitionCheck, service: Infr
             validator_id=validator.id,
             validator_execution_id=validator_execution_id,
             validator_type=InfrahubKind.GENERATORVALIDATOR,
+            context=message.context,
+            proposed_change=message.proposed_change,
         )
     )
     for event in events:
         event.assign_meta(parent=message)
-        await service.send(message=event)
+        await service.message_bus.send(message=event)
 
 
-def _run_generator(instance_id: Optional[str], managed_branch: bool, impacted_instances: list[str]) -> bool:
+def _run_generator(instance_id: str | None, managed_branch: bool, impacted_instances: list[str]) -> bool:
     """Returns a boolean to indicate if a generator instance needs to be executed
     Will return true if:
         * The instance_id wasn't set which could be that it's a new object that doesn't have a previous generator instance

infrahub/message_bus/operations/requests/proposed_change.py

@@ -11,6 +11,7 @@ from infrahub.core.constants import CheckType, InfrahubKind, RepositoryInternalS
 from infrahub.core.diff.coordinator import DiffCoordinator
 from infrahub.core.registry import registry
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.git.models import TriggerRepositoryInternalChecks
 from infrahub.git.repository import InfrahubRepository
 from infrahub.message_bus import InfrahubMessage, messages
 from infrahub.message_bus.types import (
@@ -20,6 +21,7 @@ from infrahub.message_bus.types import (
     ProposedChangeSubscriber,
 )
 from infrahub.proposed_change.models import (
+    RequestArtifactDefinitionCheck,
     RequestProposedChangeDataIntegrity,
     RequestProposedChangeRepositoryChecks,
     RequestProposedChangeRunGenerators,
@@ -28,6 +30,8 @@ from infrahub.proposed_change.models import (
 )
 from infrahub.services import InfrahubServices  # noqa: TC001
 from infrahub.workflows.catalogue import (
+    GIT_REPOSITORY_INTERNAL_CHECKS_TRIGGER,
+    REQUEST_ARTIFACT_DEFINITION_CHECK,
     REQUEST_PROPOSED_CHANGE_DATA_INTEGRITY,
     REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS,
     REQUEST_PROPOSED_CHANGE_RUN_GENERATORS,
@@ -74,17 +78,17 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
     ):
         for repo in repositories:
             if not repo.read_only and repo.internal_status == RepositoryInternalStatus.ACTIVE.value:
-                events.append(
-                    messages.RequestRepositoryChecks(
-                        proposed_change=message.proposed_change,
-                        repository=repo.repository_id,
-                        source_branch=repo.source_branch,
-                        target_branch=repo.destination_branch,
-                    )
+                model = TriggerRepositoryInternalChecks(
+                    proposed_change=message.proposed_change,
+                    repository=repo.repository_id,
+                    source_branch=repo.source_branch,
+                    target_branch=repo.destination_branch,
+                )
+                await service.workflow.submit_workflow(
+                    workflow=GIT_REPOSITORY_INTERNAL_CHECKS_TRIGGER,
+                    context=message.context,
+                    parameters={"model": model},
                 )
-        for event in events:
-            event.assign_meta(parent=message)
-            await service.send(message=event)
         return
 
     await _gather_repository_repository_diffs(repositories=repositories, service=service)
@@ -103,6 +107,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
     if message.check_type is CheckType.ARTIFACT:
         events.append(
             messages.RequestProposedChangeRefreshArtifacts(
+                context=message.context,
                 proposed_change=message.proposed_change,
                 source_branch=message.source_branch,
                 source_branch_sync_with_git=message.source_branch_sync_with_git,
@@ -122,7 +127,9 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             do_repository_checks=message.check_type is CheckType.ALL,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_PROPOSED_CHANGE_RUN_GENERATORS, parameters={"model": model_proposed_change_run_generator}
+            workflow=REQUEST_PROPOSED_CHANGE_RUN_GENERATORS,
+            context=message.context,
+            parameters={"model": model_proposed_change_run_generator},
         )
 
     if message.check_type in [CheckType.ALL, CheckType.DATA] and branch_diff.has_node_changes(
@@ -136,7 +143,9 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             branch_diff=branch_diff,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_PROPOSED_CHANGE_DATA_INTEGRITY, parameters={"model": model_proposed_change_data_integrity}
+            workflow=REQUEST_PROPOSED_CHANGE_DATA_INTEGRITY,
+            context=message.context,
+            parameters={"model": model_proposed_change_data_integrity},
         )
 
     if message.check_type in [CheckType.REPOSITORY, CheckType.USER]:
@@ -148,7 +157,9 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             branch_diff=branch_diff,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS, parameters={"model": model_proposed_change_repo_checks}
+            workflow=REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS,
+            context=message.context,
+            parameters={"model": model_proposed_change_repo_checks},
         )
 
     if message.check_type in [CheckType.ALL, CheckType.SCHEMA] and branch_diff.has_data_changes(
@@ -156,6 +167,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
     ):
         await service.workflow.submit_workflow(
             workflow=REQUEST_PROPOSED_CHANGE_SCHEMA_INTEGRITY,
+            context=message.context,
             parameters={
                 "model": RequestProposedChangeSchemaIntegrity(
                     proposed_change=message.proposed_change,
@@ -170,6 +182,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
     if message.check_type in [CheckType.ALL, CheckType.TEST]:
         await service.workflow.submit_workflow(
             workflow=REQUEST_PROPOSED_CHANGE_USER_TESTS,
+            context=message.context,
             parameters={
                 "model": RequestProposedChangeUserTests(
                     proposed_change=message.proposed_change,
@@ -183,7 +196,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
 
     for event in events:
         event.assign_meta(parent=message)
-        await service.send(message=event)
+        await service.message_bus.send(message=event)
 
 
 @flow(
@@ -232,7 +245,8 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
 
         if select:
             log.info(f"Trigger processing of {artifact_definition.definition_name}")
-            msg = messages.RequestArtifactDefinitionCheck(
+            model = RequestArtifactDefinitionCheck(
+                context=message.context,
                 artifact_definition=artifact_definition,
                 branch_diff=message.branch_diff,
                 proposed_change=message.proposed_change,
@@ -241,8 +255,7 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
                 destination_branch=message.destination_branch,
             )
 
-            msg.assign_meta(parent=message)
-            await service.send(message=msg)
+            await service.workflow.submit_workflow(REQUEST_ARTIFACT_DEFINITION_CHECK, parameters={"model": model})
 
 
 GATHER_ARTIFACT_DEFINITIONS = """
@@ -520,7 +533,7 @@ async def _get_proposed_change_repositories(
     return _parse_proposed_change_repositories(message=message, source=source_all, destination=destination_all)
 
 
-@task(name="proposed-change-validate-repository-conflicts", task_run_name="Validate conflicts on repository")
+@task(name="proposed-change-validate-repository-conflicts", task_run_name="Validate conflicts on repository")  # type: ignore[arg-type]
 async def _validate_repository_merge_conflicts(
     repositories: list[ProposedChangeRepository], service: InfrahubServices
 ) -> bool:
@@ -529,7 +542,10 @@ async def _validate_repository_merge_conflicts(
     for repo in repositories:
         if repo.has_diff and not repo.is_staging:
             git_repo = await InfrahubRepository.init(
-                id=repo.repository_id, name=repo.repository_name, client=service.client
+                id=repo.repository_id,
+                name=repo.repository_name,
+                client=service.client,
+                service=service,
             )
             async with lock.registry.get(name=repo.repository_name, namespace="repository"):
                 repo.conflicts = await git_repo.get_conflicts(
@@ -551,7 +567,10 @@ async def _gather_repository_repository_diffs(
         if repo.has_diff and repo.source_commit and repo.destination_commit:
             # TODO we need to find a way to return all files in the repo if the repo is new
             git_repo = await InfrahubRepository.init(
-                id=repo.repository_id, name=repo.repository_name, client=service.client
+                id=repo.repository_id,
+                name=repo.repository_name,
+                client=service.client,
+                service=service,
             )
 
             files_changed: list[str] = []

infrahub/message_bus/operations/send/echo.py

@@ -10,4 +10,4 @@ async def request(message: messages.SendEchoRequest, service: InfrahubServices)
     service.log.info(f"Received message: {message.message}")
     if message.reply_requested:
         response = SendEchoRequestResponse(data=SendEchoRequestResponseData(response=f"Reply to: {message.message}"))
-        await service.reply(message=response, initiator=message)
+        await service.message_bus.reply_if_initiator_meta(message=response, initiator=message)

infrahub/message_bus/types.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
 from infrahub.exceptions import NodeNotFoundError
 
-SCHEMA_CHANGE = re.compile("^Schema[A-Z]")
+SCHEMA_CHANGE = re.compile(r"^Schema[A-Z]")
 
 
 class MessageTTL(int, Enum):

infrahub/permissions/globals.py

@@ -0,0 +1,15 @@
+from infrahub.core.account import GlobalPermission
+from infrahub.core.constants import GLOBAL_BRANCH_NAME, GlobalPermissions, PermissionDecision
+from infrahub.core.registry import registry
+
+
+def define_global_permission_from_branch(permission: GlobalPermissions, branch_name: str) -> GlobalPermission:
+    if branch_name in (GLOBAL_BRANCH_NAME, registry.default_branch):
+        decision = PermissionDecision.ALLOW_DEFAULT
+    else:
+        decision = PermissionDecision.ALLOW_OTHER
+
+    return GlobalPermission(
+        action=permission.value,
+        decision=decision.value,
+    )

infrahub/pools/number.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from infrahub.core.query.resource_manager import NumberPoolGetAllocated
 from infrahub.core.registry import registry
@@ -20,9 +20,7 @@ class UsedNumber:
 
 
 class NumberUtilizationGetter:
-    def __init__(
-        self, db: InfrahubDatabase, pool: CoreNode, branch: Branch, at: Optional[Union[Timestamp, str]] = None
-    ) -> None:
+    def __init__(self, db: InfrahubDatabase, pool: CoreNode, branch: Branch, at: Timestamp | str | None = None) -> None:
         self.db = db
         self.at = at
         self.pool = pool

infrahub/pools/prefix.py

@@ -1,174 +1,38 @@
 from __future__ import annotations
 
 import ipaddress
-from collections import OrderedDict, defaultdict
-from ipaddress import IPv4Network, IPv6Network
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Literal
 
+from netaddr import IPSet
 
-class PrefixPool:
-    """
-    Class to automatically manage Prefixes and help to carve out sub-prefixes
-    """
-
-    def __init__(self, network: str) -> None:
-        self.network = ipaddress.ip_network(network)
-
-        # Define biggest and smallest possible masks
-        self.mask_biggest = self.network.prefixlen + 1
-        if self.network.version == 4:
-            self.mask_smallest = 32
-        else:
-            self.mask_smallest = 128
-
-        self.available_subnets = defaultdict(list)
-        self.sub_by_key: dict[str, Optional[str]] = OrderedDict()
-        self.sub_by_id: dict[str, str] = OrderedDict()
-
-        # Save the top level available subnet
-        for subnet in list(self.network.subnets(new_prefix=self.mask_biggest)):
-            self.available_subnets[self.mask_biggest].append(str(subnet))
-
-    def reserve(self, subnet: str, identifier: Optional[str] = None) -> bool:
-        """
-        Indicate that a specific subnet is already reserved/used
-        """
-
-        # TODO Add check to make sure the subnet provided has the right size
-        sub = ipaddress.ip_network(subnet)
-
-        if int(sub.prefixlen) <= int(self.network.prefixlen):
-            raise ValueError(f"{subnet} do not have the right size ({sub.prefixlen},{self.network.prefixlen})")
-
-        if sub.supernet(new_prefix=self.network.prefixlen) != self.network:
-            raise ValueError(f"{subnet} is not part of this network")
-
-        # Check first if this ID as already done a reservation
-        if identifier and identifier in self.sub_by_id.keys():
-            if self.sub_by_id[identifier] == str(sub):
-                return True
-            raise ValueError(
-                f"this identifier ({identifier}) is already used but for a different resource ({self.sub_by_id[identifier]})"
-            )
-
-        if identifier and str(sub) in self.sub_by_key.keys():
-            raise ValueError(f"this subnet is already reserved but not with this identifier ({identifier})")
-
-        if str(sub) in self.sub_by_key.keys():
-            self.remove_subnet_from_available_list(sub)
-            return True
-
-        # Check if the subnet itself is available
-        # if available reserve and return
-        if subnet in self.available_subnets[sub.prefixlen]:
-            if identifier:
-                self.sub_by_id[identifier] = subnet
-                self.sub_by_key[subnet] = identifier
-            else:
-                self.sub_by_key[subnet] = None
-
-            self.remove_subnet_from_available_list(sub)
-            return True
-
-        # If not reserved already, check if the subnet is available
-        # start at sublen and check all available subnet
-        # increase 1 by 1 until we find the closer supernet available
-        # break it down and keep track of the other available subnets
+if TYPE_CHECKING:
+    from infrahub.core.ipam.constants import IPNetworkType
 
-        for sublen in range(sub.prefixlen - 1, self.network.prefixlen, -1):
-            supernet = sub.supernet(new_prefix=sublen)
-            if str(supernet) in self.available_subnets[sublen]:
-                self.split_supernet(supernet=supernet, subnet=sub)
-                return self.reserve(subnet=subnet, identifier=identifier)
 
-        return False
+def get_next_available_prefix(pool: IPSet, prefix_length: int, prefix_ver: Literal[4, 6] = 4) -> IPNetworkType:
+    """Get the next available prefix of a given prefix length from an IPSet.
 
-    def get(self, prefixlen: int, identifier: Optional[str] = None) -> Union[IPv4Network, IPv6Network]:
-        """Return the next available Subnet."""
+    Args:
+        pool: netaddr IPSet object with available subnets
+        prefix_length: length of the desired prefix
+        prefix_ver: IPSet can contain a mix of IPv4 and IPv6 subnets. This parameter specifies the IP version of prefix to acquire.
 
-        clean_prefixlen = int(prefixlen)
-
-        if identifier and identifier in self.sub_by_id.keys():
-            net = ipaddress.ip_network(self.sub_by_id[identifier])
-            if net.prefixlen == clean_prefixlen:
-                return net
-            raise ValueError()
-
-        if len(self.available_subnets[clean_prefixlen]) != 0:
-            sub = self.available_subnets[clean_prefixlen][0]
-            self.reserve(subnet=sub, identifier=identifier)
-            return ipaddress.ip_network(sub)
-
-        # if a subnet of this size is not available
-        # we need to find the closest subnet available and split it
-        for i in range(clean_prefixlen - 1, self.mask_biggest - 1, -1):
-            if len(self.available_subnets[i]) != 0:
-                supernet = ipaddress.ip_network(self.available_subnets[i][0])
-                # supernet available, will split it
-                subs = supernet.subnets(new_prefix=clean_prefixlen)
-                next_sub: Union[IPv4Network, IPv6Network] = next(subs)  # type: ignore[assignment]
-                self.split_supernet(supernet=supernet, subnet=next_sub)
-                self.reserve(subnet=str(next_sub), identifier=identifier)
-                return next_sub
-
-        raise IndexError("No More subnet available")
-
-    def get_nbr_available_subnets(self) -> dict[int, int]:
-        tmp = {}
-        for i in range(self.mask_biggest, self.mask_smallest + 1):
-            tmp[i] = len(self.available_subnets[i])
-
-        return tmp
-
-    def check_if_already_allocated(self, identifier: str) -> bool:
-        """
-        Check if a subnet has already been allocated based on an identifier
-
-        Need to add the same capability based on Network address
-        If both identifier and subnet are provided, identifier take precedence
-        """
-        if identifier in self.sub_by_id.keys():
-            return True
-        return False
-
-    def split_supernet(
-        self, supernet: Union[IPv4Network, IPv6Network], subnet: Union[IPv4Network, IPv6Network]
-    ) -> None:
-        """Split a supernet into smaller networks"""
-
-        # TODO ensure subnet is small than supernet
-        # TODO ensure that subnet is part of supernet
-        parent_net = supernet
-        for i in range(supernet.prefixlen + 1, subnet.prefixlen + 1):
-            tmp_net: list[Union[IPv4Network, IPv6Network]] = list(parent_net.subnets(new_prefix=i))
-
-            if i == subnet.prefixlen:
-                for net in tmp_net:
-                    self.available_subnets[i].append(str(net))
-            else:
-                if subnet.subnet_of(other=tmp_net[0]):  # type: ignore[arg-type]
-                    parent = 0
-                    other = 1
-                else:
-                    parent = 1
-                    other = 0
-
-                parent_net = tmp_net[parent]
-                self.available_subnets[i].append(str(tmp_net[other]))
-
-        self.remove_subnet_from_available_list(supernet)
-
-    def remove_subnet_from_available_list(self, subnet: Union[IPv4Network, IPv6Network]) -> None:
-        """Remove a subnet from the list of available Subnet."""
-        try:
-            idx = self.available_subnets[subnet.prefixlen].index(str(subnet))
-            del self.available_subnets[subnet.prefixlen][idx]
-        except ValueError:
-            # Already removed
-            pass
-
-        # if idx:
-        #     return True
-        # except:
-        #     log.warn("Unable to remove %s from list of available subnets" % str(subnet))
-        #     return False
+    Raises:
+        ValueError: If there are no available subnets in the pool
+    """
+    prefix_ver_map = {
+        4: ipaddress.IPv4Network,
+        6: ipaddress.IPv6Network,
+    }
+
+    filtered_pool = IPSet([])
+    for subnet in pool.iter_cidrs():
+        if isinstance(ipaddress.ip_network(str(subnet)), prefix_ver_map[prefix_ver]):
+            filtered_pool.add(subnet)
+
+    for cidr in filtered_pool.iter_cidrs():
+        if cidr.prefixlen <= prefix_length:
+            next_available = ipaddress.ip_network(f"{cidr.network}/{prefix_length}")
+            return next_available
+
+    raise ValueError("No available subnets in pool")

infrahub/prefect_server/app.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, FastAPI
+from prefect.server.api.server import create_app
+
+from . import events
+
+router = APIRouter(prefix="/infrahub")
+
+router.include_router(events.router)
+
+
+def create_infrahub_prefect() -> FastAPI:
+    app = create_app()
+    api_app: FastAPI = app.__dict__["api_app"]
+    api_app.include_router(router=router)
+
+    return app

infrahub/prefect_server/database.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prefect.server.events.schemas.events import ReceivedEvent
+from prefect.server.events.storage import INTERACTIVE_PAGE_SIZE
+from prefect.server.events.storage.database import raw_count_events, read_events
+
+if TYPE_CHECKING:
+    from prefect.server.events.filters import EventFilter
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+async def query_events(
+    session: AsyncSession, filter: EventFilter, page_size: int = INTERACTIVE_PAGE_SIZE, offset: int | None = None
+) -> tuple[list[ReceivedEvent], int]:
+    count = await raw_count_events(session, filter)  # type: ignore[attr-defined]
+    page = await read_events(session, filter, limit=page_size, offset=offset)  # type: ignore[attr-defined]
+    events = [ReceivedEvent.model_validate(e, from_attributes=True) for e in page]
+    return events, count

infrahub/prefect_server/events.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from fastapi.param_functions import Depends
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+
+from .database import query_events
+from .models import InfrahubEventfilterInput, InfrahubEventPage
+
+router = APIRouter(prefix="/events", tags=["Infrahub"])
+
+
+@router.post(
+    "/filter",
+)
+async def read_events(
+    event_filter: InfrahubEventfilterInput,
+    db: PrefectDBInterface = Depends(provide_database_interface),  # noqa: B008
+) -> InfrahubEventPage:
+    event_filter.filter.set_prefix()
+
+    async with db.session_context() as session:
+        events, total = await query_events(
+            session=session, filter=event_filter.filter, page_size=event_filter.limit, offset=event_filter.offset
+        )
+
+        return InfrahubEventPage(
+            events=events,
+            total=total,
+        )

infrahub/prefect_server/models.py

@@ -0,0 +1,46 @@
+from typing import TYPE_CHECKING, Sequence, cast
+
+from prefect.server.database import PrefectDBInterface, db_injector
+from prefect.server.events.filters import EventFilter, EventNameFilter, EventOrder, EventRelatedFilter
+from prefect.server.events.schemas.events import ReceivedEvent
+from prefect.server.utilities.schemas import PrefectBaseModel
+from pydantic import BaseModel, Field
+
+if TYPE_CHECKING:
+    from sqlalchemy.sql.expression import ColumnExpressionArgument
+
+
+class InfrahubEventFilter(EventFilter):
+    matching_related: list[EventRelatedFilter] = Field(default_factory=list)
+
+    def set_prefix(self) -> None:
+        if self.event:
+            if self.event.prefix is not None and "infrahub." not in self.event.prefix:
+                self.event.prefix.append("infrahub.")
+        else:
+            self.event = EventNameFilter(prefix=["infrahub."], name=[], exclude_prefix=None, exclude_name=None)
+
+    @db_injector
+    def build_where_clauses(self, db: PrefectDBInterface) -> Sequence["ColumnExpressionArgument[bool]"]:
+        result = cast(list["ColumnExpressionArgument[bool]"], super().build_where_clauses())
+        top_level_filter = self._scoped_event_resources(db)
+        for matching_related in self.matching_related:
+            matching_related._top_level_filter = top_level_filter
+            result.extend(matching_related.build_where_clauses())
+
+        return result
+
+    @classmethod
+    def default(cls) -> "InfrahubEventFilter":
+        return cls(event=None, any_resource=None, resource=None, related=None, order=EventOrder.DESC)
+
+
+class InfrahubEventPage(PrefectBaseModel):
+    events: list[ReceivedEvent] = Field(..., description="The Events matching the query")
+    total: int = Field(..., description="The total number of matching Events")
+
+
+class InfrahubEventfilterInput(BaseModel):
+    limit: int = Field(default=50)
+    filter: InfrahubEventFilter = Field(default_factory=InfrahubEventFilter.default)
+    offset: int | None = Field(default=None)

infrahub/proposed_change/models.py

@@ -1,6 +1,8 @@
-from pydantic import Field
+from pydantic import BaseModel, ConfigDict, Field
 
+from infrahub.context import InfrahubContext
 from infrahub.message_bus.messages.proposed_change.base_with_diff import BaseProposedChangeWithDiffMessage
+from infrahub.message_bus.types import ProposedChangeArtifactDefinition, ProposedChangeBranchDiff
 
 
 class RequestProposedChangeDataIntegrity(BaseProposedChangeWithDiffMessage):
@@ -26,3 +28,18 @@ class RequestProposedChangeSchemaIntegrity(BaseProposedChangeWithDiffMessage):
 
 class RequestProposedChangeUserTests(BaseProposedChangeWithDiffMessage):
     """Sent trigger to run tests (smoke, units, integrations) for a proposed change."""
+
+
+class RequestArtifactDefinitionCheck(BaseModel):
+    """Sent to validate the generation of artifacts in relation to a proposed change."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    artifact_definition: ProposedChangeArtifactDefinition = Field(..., description="The Artifact Definition")
+    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    source_branch: str = Field(..., description="The source branch")
+    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
+    destination_branch: str = Field(..., description="The target branch")
+
+    context: InfrahubContext = Field(..., description="The context of the task")