infrahub-server 1.1.6__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/message_bus/operations/event/branch.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from prefect import flow
 
 from infrahub.core import registry
@@ -7,7 +9,7 @@ from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.log import get_logger
 from infrahub.message_bus import InfrahubMessage, messages
-from infrahub.services import InfrahubServices
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.catalogue import (
     DIFF_UPDATE,
     TRIGGER_ARTIFACT_DEFINITION_GENERATE,
@@ -33,11 +35,13 @@ async def merge(message: messages.EventBranchMerge, service: InfrahubServices) -
 
         await service.workflow.submit_workflow(
             workflow=TRIGGER_ARTIFACT_DEFINITION_GENERATE,
+            context=message.context,
             parameters={"branch": message.target_branch},
         )
 
         await service.workflow.submit_workflow(
             workflow=TRIGGER_GENERATOR_DEFINITION_RUN,
+            context=message.context,
             parameters={"branch": message.target_branch},
         )
 
@@ -49,9 +53,9 @@ async def merge(message: messages.EventBranchMerge, service: InfrahubServices) -
             ):
                 request_diff_update_model = RequestDiffUpdate(branch_name=diff_root.diff_branch_name)
                 await service.workflow.submit_workflow(
-                    workflow=DIFF_UPDATE, parameters={"model": request_diff_update_model}
+                    workflow=DIFF_UPDATE, context=message.context, parameters={"model": request_diff_update_model}
                 )
 
         for event in events:
             event.assign_meta(parent=message)
-            await service.send(message=event)
+            await service.message_bus.send(message=event)

infrahub/message_bus/operations/event/schema.py

@@ -14,4 +14,4 @@ async def update(message: messages.EventSchemaUpdate, service: InfrahubServices)
     msg = messages.RefreshRegistryBranches()
 
     msg.assign_meta(parent=message)
-    await service.send(message=msg)
+    await service.message_bus.send(message=msg)

infrahub/message_bus/operations/event/worker.py

@@ -2,11 +2,8 @@ from prefect import flow
 
 from infrahub.message_bus import messages
 from infrahub.services import InfrahubServices
-from infrahub.workflows.catalogue import WEBHOOK_CONFIGURE
 
 
 @flow(name="event-worker-newprimary-api")
 async def new_primary_api(message: messages.EventWorkerNewPrimaryAPI, service: InfrahubServices) -> None:
     service.log.info("api_worker promoted to primary", worker_id=message.worker_id)
-
-    await service.workflow.submit_workflow(workflow=WEBHOOK_CONFIGURE)

infrahub/message_bus/operations/finalize/validator.py

@@ -67,7 +67,7 @@ async def execution(message: messages.FinalizeValidatorExecution, service: Infra
                 validator_id=message.validator_id,
                 validator_execution_id=message.validator_execution_id,
             )
-            await service.send(message=message, delay=MessageTTL.FIVE)
+            await service.message_bus.send(message=message, delay=MessageTTL.FIVE)
             return
 
         log.info(

infrahub/message_bus/operations/git/file.py

@@ -27,8 +27,8 @@ async def get(message: messages.GitFileGet, service: InfrahubServices) -> None:
     except (FileOutOfRepositoryError, RepositoryFileNotFoundError) as e:
         if message.reply_requested:
             response = GitFileGetResponse(data=GitFileGetResponseData(error_message=e.message, http_code=e.HTTP_CODE))
-            await service.reply(message=response, initiator=message)
+            await service.message_bus.reply_if_initiator_meta(message=response, initiator=message)
     else:
         if message.reply_requested:
             response = GitFileGetResponse(data=GitFileGetResponseData(content=content))
-            await service.reply(message=response, initiator=message)
+            await service.message_bus.reply_if_initiator_meta(message=response, initiator=message)

infrahub/message_bus/operations/git/repository.py

@@ -28,7 +28,7 @@ async def connectivity(message: messages.GitRepositoryConnectivity, service: Inf
         response = GitRepositoryConnectivityResponse(
             data=response_data,
         )
-        await service.reply(message=response, initiator=message)
+        await service.message_bus.reply_if_initiator_meta(message=response, initiator=message)
 
 
 @flow(name="refresh-git-fetch", flow_run_name="Fetch git repository {message.repository_name} on " + WORKER_IDENTITY)

infrahub/message_bus/operations/requests/__init__.py

@@ -1,13 +1,9 @@
 from . import (
-    artifact_definition,
     generator_definition,
     proposed_change,
-    repository,
 )
 
 __all__ = [
-    "artifact_definition",
     "generator_definition",
     "proposed_change",
-    "repository",
 ]

infrahub/message_bus/operations/requests/generator_definition.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from infrahub_sdk.uuidt import UUIDT
 from prefect import flow
 from prefect.logging import get_run_logger
@@ -125,10 +123,10 @@ async def check(message: messages.RequestGeneratorDefinitionCheck, service: Infr
     )
     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,15 @@ 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, 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 +105,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 +125,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 +141,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 +155,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 +165,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 +180,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 +194,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 +243,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 +253,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 +531,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 +540,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 +565,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/__init__.py

@@ -2,12 +2,13 @@ from infrahub.permissions.backend import PermissionBackend
 from infrahub.permissions.local_backend import LocalPermissionBackend
 from infrahub.permissions.manager import PermissionManager
 from infrahub.permissions.report import report_schema_permissions
-from infrahub.permissions.types import AssignedPermissions
+from infrahub.permissions.types import AssignedPermissions, get_global_permission_for_kind
 
 __all__ = [
     "AssignedPermissions",
     "LocalPermissionBackend",
     "PermissionBackend",
     "PermissionManager",
+    "get_global_permission_for_kind",
     "report_schema_permissions",
 ]

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/permissions/types.py

@@ -2,8 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, TypedDict
 
+from infrahub.core.constants import GlobalPermissions, InfrahubKind
+from infrahub.core.schema import NodeSchema
+
 if TYPE_CHECKING:
     from infrahub.core.account import GlobalPermission, ObjectPermission
+    from infrahub.core.schema import MainSchemaTypes
     from infrahub.permissions.constants import BranchRelativePermissionDecision
 
 
@@ -18,3 +22,25 @@ class KindPermissions(TypedDict):
     delete: BranchRelativePermissionDecision
     update: BranchRelativePermissionDecision
     view: BranchRelativePermissionDecision
+
+
+def get_global_permission_for_kind(schema: MainSchemaTypes) -> GlobalPermissions | None:
+    kind_permission_map = {
+        InfrahubKind.GENERICACCOUNT: GlobalPermissions.MANAGE_ACCOUNTS,
+        InfrahubKind.ACCOUNTGROUP: GlobalPermissions.MANAGE_ACCOUNTS,
+        InfrahubKind.ACCOUNTROLE: GlobalPermissions.MANAGE_ACCOUNTS,
+        InfrahubKind.BASEPERMISSION: GlobalPermissions.MANAGE_PERMISSIONS,
+        InfrahubKind.GENERICREPOSITORY: GlobalPermissions.MANAGE_REPOSITORIES,
+    }
+
+    if schema.kind in kind_permission_map:
+        return kind_permission_map[schema.kind]
+
+    if isinstance(schema, NodeSchema):
+        for base in schema.inherit_from:
+            try:
+                return kind_permission_map[base]
+            except KeyError:
+                continue
+
+    return None

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,
+        )