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

infrahub/graphql/queries/ipam.py

@@ -4,13 +4,14 @@ import ipaddress
 from typing import TYPE_CHECKING, Optional
 
 from graphene import Field, Int, ObjectType, String
+from netaddr import IPSet
 
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.core.query.ipam import get_ip_addresses, get_subnets
 from infrahub.exceptions import NodeNotFoundError, ValidationError
 from infrahub.pools.address import get_available
-from infrahub.pools.prefix import PrefixPool
+from infrahub.pools.prefix import get_next_available_prefix
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -23,18 +24,18 @@ class IPAddressGetNextAvailable(ObjectType):
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         prefix_id: str,
         prefix_length: Optional[int] = None,
     ) -> dict[str, str]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        prefix = await NodeManager.get_one(id=prefix_id, db=context.db, branch=context.branch)
+        prefix = await NodeManager.get_one(id=prefix_id, db=graphql_context.db, branch=graphql_context.branch)
 
         if not prefix:
             raise NodeNotFoundError(
-                branch_name=context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
+                branch_name=graphql_context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
             )
 
         ip_prefix = ipaddress.ip_network(prefix.prefix.value)  # type: ignore[attr-defined]
@@ -43,12 +44,12 @@ class IPAddressGetNextAvailable(ObjectType):
         if not ip_prefix.prefixlen <= prefix_length <= ip_prefix.max_prefixlen:
             raise ValidationError(input_value="Invalid prefix length for current selected prefix")
 
-        namespace = await prefix.ip_namespace.get_peer(db=context.db)  # type: ignore[attr-defined]
+        namespace = await prefix.ip_namespace.get_peer(db=graphql_context.db)  # type: ignore[attr-defined]
         addresses = await get_ip_addresses(
-            db=context.db,
+            db=graphql_context.db,
             ip_prefix=ip_prefix,
             namespace=namespace,
-            branch=context.branch,
+            branch=graphql_context.branch,
         )
 
         available = get_available(
@@ -70,33 +71,35 @@ class IPPrefixGetNextAvailable(ObjectType):
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         prefix_id: str,
         prefix_length: int,
     ) -> dict[str, str]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        prefix = await NodeManager.get_one(id=prefix_id, db=context.db, branch=context.branch)
+        prefix = await NodeManager.get_one(id=prefix_id, db=graphql_context.db, branch=graphql_context.branch)
 
         if not prefix:
             raise NodeNotFoundError(
-                branch_name=context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
+                branch_name=graphql_context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
             )
 
-        namespace = await prefix.ip_namespace.get_peer(db=context.db)  # type: ignore[attr-defined]
+        namespace = await prefix.ip_namespace.get_peer(db=graphql_context.db)  # type: ignore[attr-defined]
         subnets = await get_subnets(
-            db=context.db,
+            db=graphql_context.db,
             ip_prefix=ipaddress.ip_network(prefix.prefix.value),  # type: ignore[attr-defined]
             namespace=namespace,
-            branch=context.branch,
+            branch=graphql_context.branch,
         )
 
-        pool = PrefixPool(prefix.prefix.value)  # type: ignore[attr-defined]
+        pool = IPSet([prefix.prefix.value])
         for subnet in subnets:
-            pool.reserve(subnet=str(subnet.prefix))
+            pool.remove(addr=str(subnet.prefix))
+
+        prefix_ver = ipaddress.ip_network(prefix.prefix.value).version
+        next_available = get_next_available_prefix(pool=pool, prefix_length=prefix_length, prefix_ver=prefix_ver)
 
-        next_available = pool.get(prefixlen=prefix_length)
         return {"prefix": str(next_available)}
 
 
@@ -105,6 +108,7 @@ InfrahubIPAddressGetNextAvailable = Field(
     prefix_id=String(required=True),
     prefix_length=Int(required=False),
     resolver=IPAddressGetNextAvailable.resolve,
+    required=True,
 )
 
 
@@ -113,4 +117,5 @@ InfrahubIPPrefixGetNextAvailable = Field(
     prefix_id=String(required=True),
     prefix_length=Int(required=False),
     resolver=IPPrefixGetNextAvailable.resolve,
+    required=True,
 )

infrahub/graphql/queries/relationship.py

@@ -15,30 +15,30 @@ if TYPE_CHECKING:
 
 
 class Relationships(ObjectType):
-    edges = List(RelationshipNode)
-    count = Int()
+    edges = List(of_type=NonNull(RelationshipNode), required=True)
+    count = Int(required=True)
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         ids: list[str],
         limit: int = 10,
         offset: int = 0,
         excluded_namespaces: Optional[list[str]] = None,
     ) -> dict[str, Any]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         fields = await extract_fields_first_node(info)
         excluded_namespaces = excluded_namespaces or []
 
         response: dict[str, Any] = {"edges": [], "count": None}
 
-        async with context.db.start_session() as db:
+        async with graphql_context.db.start_session() as db:
             query = await RelationshipGetByIdentifierQuery.init(
                 db=db,
-                branch=context.branch,
-                at=context.at,
+                branch=graphql_context.branch,
+                at=graphql_context.at,
                 identifiers=ids,
                 excluded_namespaces=excluded_namespaces,
                 limit=limit,
@@ -74,9 +74,10 @@ class Relationships(ObjectType):
 
 Relationship = Field(
     Relationships,
-    resolver=Relationships.resolve,
-    limit=Int(required=False),
-    offset=Int(required=False),
     ids=List(NonNull(String), required=True),
     excluded_namespaces=List(String),
+    limit=Int(required=False),
+    offset=Int(required=False),
+    resolver=Relationships.resolve,
+    required=True,
 )

infrahub/graphql/queries/resource_manager.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Field, Float, Int, List, ObjectType, String
+from graphene import Field, Float, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node
 
 from infrahub.core import registry
@@ -21,8 +21,10 @@ from infrahub.pools.number import NumberUtilizationGetter
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
+    from infrahub.core.branch import Branch
     from infrahub.core.node import Node
     from infrahub.core.protocols import CoreNode
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.initialization import GraphqlContext
 
@@ -69,19 +71,21 @@ def _validate_pool_type(pool_id: str, pool: CoreNode | None = None) -> CoreNode:
 
 class PoolAllocated(ObjectType):
     count = Field(Int, required=True, description="The number of allocations within the selected pool.")
-    edges = Field(List(of_type=PoolAllocatedEdge, required=True), required=True)
+    edges = Field(List(of_type=NonNull(PoolAllocatedEdge), required=True), required=True)
 
     @staticmethod
-    async def resolve(  # pylint: disable=unused-argument
-        root: dict,
+    async def resolve(
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         pool_id: str,
         resource_id: str,
         offset: int = 0,
         limit: int = 10,
     ) -> dict:
-        context: GraphqlContext = info.context
-        pool: CoreNode | None = await NodeManager.get_one(id=pool_id, db=context.db, branch=context.branch)
+        graphql_context: GraphqlContext = info.context
+        pool: CoreNode | None = await NodeManager.get_one(
+            id=pool_id, db=graphql_context.db, branch=graphql_context.branch
+        )
 
         fields = await extract_fields_first_node(info=info)
 
@@ -90,14 +94,19 @@ class PoolAllocated(ObjectType):
         match pool.get_kind():
             case InfrahubKind.NUMBERPOOL:
                 return await resolve_number_pool_allocation(
-                    db=context.db, context=context, pool=pool, fields=fields, offset=offset, limit=limit
+                    db=graphql_context.db,
+                    graphql_context=graphql_context,
+                    pool=pool,
+                    fields=fields,
+                    offset=offset,
+                    limit=limit,
                 )
             case InfrahubKind.IPPREFIXPOOL:
                 allocated_kinds.append(InfrahubKind.IPPREFIX)
             case InfrahubKind.IPADDRESSPOOL:
                 allocated_kinds.append(InfrahubKind.IPADDRESS)
 
-        resources = await pool.resources.get_peers(db=context.db)  # type: ignore[attr-defined,union-attr]
+        resources = await pool.resources.get_peers(db=graphql_context.db)  # type: ignore[attr-defined,union-attr]
         if resource_id not in resources:
             raise ValidationError(
                 input_value=f"The selected pool_id={pool_id} doesn't contain the requested resource_id={resource_id}"
@@ -106,8 +115,8 @@ class PoolAllocated(ObjectType):
         resource = resources[resource_id]
 
         query = await IPPrefixUtilization.init(
-            db=context.db,
-            at=context.at,
+            db=graphql_context.db,
+            at=graphql_context.at,
             ip_prefixes=[resource],
             allocated_kinds=allocated_kinds,
             offset=offset,
@@ -115,10 +124,10 @@ class PoolAllocated(ObjectType):
         )
         response: dict[str, Any] = {}
         if "count" in fields:
-            response["count"] = await query.count(db=context.db)
+            response["count"] = await query.count(db=graphql_context.db)
 
         if edges := fields.get("edges"):
-            await query.execute(db=context.db)
+            await query.execute(db=graphql_context.db)
 
             node_fields = edges.get("node", {})
 
@@ -146,9 +155,9 @@ class PoolAllocated(ObjectType):
                 if not identifier_query_class:
                     raise ValidationError(input_value=f"This query doesn't get support {pool.get_kind()}")
                 identifier_query = await identifier_query_class.init(
-                    db=context.db, at=context.at, pool_id=pool_id, allocated=allocated_ids
+                    db=graphql_context.db, at=graphql_context.at, pool_id=pool_id, allocated=allocated_ids
                 )
-                await identifier_query.execute(db=context.db)
+                await identifier_query.execute(db=graphql_context.db)
 
                 reservations = {}
                 for result in identifier_query.get_results():
@@ -171,20 +180,22 @@ class PoolUtilization(ObjectType):
     utilization_default_branch = Field(
         Float, required=True, description="The overall utilization of the pool isolated to the default branch."
     )
-    edges = Field(List(of_type=IPPrefixUtilizationEdge, required=True), required=True)
+    edges = Field(List(of_type=NonNull(IPPrefixUtilizationEdge), required=True), required=True)
 
     @staticmethod
-    async def resolve(  # pylint: disable=unused-argument,too-many-branches
-        root: dict,
+    async def resolve(
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         pool_id: str,
     ) -> dict:
-        context: GraphqlContext = info.context
-        db: InfrahubDatabase = context.db
-        pool: CoreNode | None = await NodeManager.get_one(id=pool_id, db=db, branch=context.branch)
+        graphql_context: GraphqlContext = info.context
+        db: InfrahubDatabase = graphql_context.db
+        pool: CoreNode | None = await NodeManager.get_one(id=pool_id, db=db, branch=graphql_context.branch)
         pool = _validate_pool_type(pool_id=pool_id, pool=pool)
         if pool.get_kind() == "CoreNumberPool":
-            return await resolve_number_pool_utilization(db=db, context=context, pool=pool)
+            return await resolve_number_pool_utilization(
+                db=db, at=graphql_context.at, pool=pool, branch=graphql_context.branch
+            )
 
         resources_map: dict[str, Node] = {}
 
@@ -193,7 +204,9 @@ class PoolUtilization(ObjectType):
         except SchemaNotFoundError:
             pass
 
-        utilization_getter = PrefixUtilizationGetter(db=db, ip_prefixes=list(resources_map.values()), at=context.at)
+        utilization_getter = PrefixUtilizationGetter(
+            db=db, ip_prefixes=list(resources_map.values()), at=graphql_context.at
+        )
         fields = await extract_fields_first_node(info=info)
         response: dict[str, Any] = {}
         total_utilization = None
@@ -262,11 +275,11 @@ class PoolUtilization(ObjectType):
 
 
 async def resolve_number_pool_allocation(
-    db: InfrahubDatabase, context: GraphqlContext, pool: CoreNode, fields: dict, offset: int, limit: int
+    db: InfrahubDatabase, graphql_context: GraphqlContext, pool: CoreNode, fields: dict, offset: int, limit: int
 ) -> dict:
     response: dict[str, Any] = {}
     query = await NumberPoolGetAllocated.init(
-        db=db, pool=pool, offset=offset, limit=limit, branch=context.branch, branch_agnostic=True
+        db=db, pool=pool, offset=offset, limit=limit, branch=graphql_context.branch, branch_agnostic=True
     )
 
     if "count" in fields:
@@ -290,8 +303,10 @@ async def resolve_number_pool_allocation(
     return response
 
 
-async def resolve_number_pool_utilization(db: InfrahubDatabase, context: GraphqlContext, pool: CoreNode) -> dict:
-    number_pool = NumberUtilizationGetter(db=db, pool=pool, at=context.at, branch=context.branch)
+async def resolve_number_pool_utilization(
+    db: InfrahubDatabase, pool: CoreNode, at: Timestamp | str | None, branch: Branch
+) -> dict:
+    number_pool = NumberUtilizationGetter(db=db, pool=pool, at=at, branch=branch)
     await number_pool.load_data()
 
     return {
@@ -322,9 +337,10 @@ InfrahubResourcePoolAllocated = Field(
     limit=Int(required=False),
     offset=Int(required=False),
     resolver=PoolAllocated.resolve,
+    required=True,
 )
 
 
 InfrahubResourcePoolUtilization = Field(
-    PoolUtilization, pool_id=String(required=True), resolver=PoolUtilization.resolve
+    PoolUtilization, pool_id=String(required=True), resolver=PoolUtilization.resolve, required=True
 )

infrahub/graphql/queries/search.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ipaddress
 from typing import TYPE_CHECKING, Any, Optional
 
-from graphene import Boolean, Field, Int, List, ObjectType, String
+from graphene import Boolean, Field, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node, is_valid_uuid
 
 from infrahub.core.constants import InfrahubKind
@@ -27,7 +27,7 @@ class NodeEdge(ObjectType):
 
 class NodeEdges(ObjectType):
     count = Field(Int, required=True)
-    edges = Field(List(of_type=NodeEdge, required=True), required=False)
+    edges = Field(List(of_type=NonNull(NodeEdge)), required=True)
 
 
 def _collapse_ipv6(s: str) -> str:
@@ -97,13 +97,13 @@ def _collapse_ipv6(s: str) -> str:
 
 
 async def search_resolver(
-    root: dict,  # pylint: disable=unused-argument
+    root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
     q: str,
     limit: int = 10,
     partial_match: bool = True,
 ) -> dict[str, Any]:
-    context: GraphqlContext = info.context
+    graphql_context: GraphqlContext = info.context
     response: dict[str, Any] = {}
     results: list[CoreNode] = []
 
@@ -111,7 +111,7 @@ async def search_resolver(
 
     if is_valid_uuid(q):
         matching: Optional[CoreNode] = await NodeManager.get_one(
-            db=context.db, branch=context.branch, at=context.at, id=q
+            db=graphql_context.db, branch=graphql_context.branch, at=graphql_context.at, id=q
         )
         if matching:
             results.append(matching)
@@ -124,8 +124,8 @@ async def search_resolver(
 
         for kind in [InfrahubKind.NODE, InfrahubKind.GENERICGROUP]:
             objs = await NodeManager.query(
-                db=context.db,
-                branch=context.branch,
+                db=graphql_context.db,
+                branch=graphql_context.branch,
                 schema=kind,
                 filters={"any__value": q},
                 limit=limit,
@@ -133,7 +133,7 @@ async def search_resolver(
             )
             results.extend(objs)
 
-    if "edges" in fields and len(results) > 0:
+    if "edges" in fields:
         response["edges"] = [{"node": {"id": obj.id, "kind": obj.get_kind()}} for obj in results]
 
     if "count" in fields:
@@ -148,4 +148,5 @@ InfrahubSearchAnywhere = Field(
     limit=Int(required=False),
     partial_match=Boolean(required=False),
     resolver=search_resolver,
+    required=True,
 )

infrahub/graphql/queries/status.py

@@ -2,11 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, Field, List, ObjectType, String
+from graphene import Boolean, Field, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node
 
-from infrahub.services import services
-
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
@@ -30,7 +28,7 @@ class StatusWorkerEdge(ObjectType):
 
 
 class StatusWorkerEdges(ObjectType):
-    edges = Field(List(of_type=StatusWorkerEdge, required=True), required=True)
+    edges = Field(List(of_type=NonNull(StatusWorkerEdge), required=True), required=True)
 
 
 class Status(ObjectType):
@@ -39,15 +37,18 @@ class Status(ObjectType):
 
 
 async def resolve_status(
-    root: dict,  # pylint: disable=unused-argument
+    root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
 ) -> dict:
-    context: GraphqlContext = info.context
-    service = context.service or services.service
+    graphql_context: GraphqlContext = info.context
+    service = graphql_context.service
+    if service is None:
+        raise ValueError("GraphqlContext.service is None")
+
     fields = await extract_fields_first_node(info)
     response: dict[str, Any] = {}
     workers = await service.component.list_workers(
-        branch=str(context.branch.uuid) or context.branch.name, schema_hash=True
+        branch=str(graphql_context.branch.uuid) or graphql_context.branch.name, schema_hash=True
     )
 
     if summary := fields.get("summary"):
@@ -63,4 +64,6 @@ async def resolve_status(
     return response
 
 
-InfrahubStatus = Field(Status, resolver=resolve_status)
+InfrahubStatus = Field(
+    Status, description="Retrieve the status of all infrahub workers.", resolver=resolve_status, required=True
+)

infrahub/graphql/queries/task.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Field, Int, List, ObjectType, String
+from graphene import Field, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node
 from prefect.client.schemas.objects import StateType
 
@@ -17,12 +17,12 @@ if TYPE_CHECKING:
 
 
 class Tasks(ObjectType):
-    edges = List(TaskNodes)
-    count = Int()
+    edges = List(NonNull(TaskNodes), required=True)
+    count = Int(required=True)
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         limit: int = 10,
         offset: int = 0,
@@ -49,7 +49,7 @@ class Tasks(ObjectType):
 
     @staticmethod
     async def resolve_branch_status(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         branch: str,
     ) -> dict[str, Any]:
@@ -72,11 +72,11 @@ class Tasks(ObjectType):
         limit: int | None = None,
         offset: int | None = None,
     ) -> dict[str, Any]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
         fields = await extract_fields_first_node(info)
 
         prefect_tasks = await PrefectTask.query(
-            db=context.db,
+            db=graphql_context.db,
             fields=fields,
             q=q,
             ids=ids,
@@ -97,7 +97,6 @@ class Tasks(ObjectType):
 
 Task = Field(
     Tasks,
-    resolver=Tasks.resolve,
     limit=Int(required=False),
     offset=Int(required=False),
     related_node__ids=List(String),
@@ -106,11 +105,14 @@ Task = Field(
     workflow=List(String),
     ids=List(String),
     q=String(required=False),
+    resolver=Tasks.resolve,
+    required=True,
 )
 
 TaskBranchStatus = Field(
     Tasks,
-    resolver=Tasks.resolve_branch_status,
     branch=String(required=False),
     description="Return the list of all pending or running tasks that can modify the data, for a given branch",
+    resolver=Tasks.resolve_branch_status,
+    required=True,
 )