infrahub-server 1.3.0a0__py3-none-any.whl → 1.3.0b2__py3-none-any.whl

infrahub/core/node/__init__.py

@@ -16,6 +16,7 @@ from infrahub.core.constants import (
     BranchSupportType,
     ComputedAttributeKind,
     InfrahubKind,
+    NumberPoolType,
     RelationshipCardinality,
     RelationshipKind,
 )
@@ -30,6 +31,7 @@ from infrahub.core.schema import (
     RelationshipSchema,
     TemplateSchema,
 )
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
 from infrahub.types import ATTRIBUTE_TYPES
@@ -254,6 +256,12 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         within the create code.
         """
 
+        number_pool_parameters: NumberPoolParameters | None = None
+        if attribute.schema.kind == "NumberPool" and isinstance(attribute.schema.parameters, NumberPoolParameters):
+            attribute.from_pool = {"id": attribute.schema.parameters.number_pool_id}
+            attribute.is_default = False
+            number_pool_parameters = attribute.schema.parameters
+
         if not attribute.from_pool:
             return
 
@@ -262,19 +270,25 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 db=db, id=attribute.from_pool["id"], kind=CoreNumberPool
             )
         except NodeNotFoundError:
-            errors.append(
-                ValidationError(
-                    {f"{attribute.name}.from_pool": f"The pool requested {attribute.from_pool} was not found."}
+            if number_pool_parameters:
+                number_pool = await self._create_number_pool(
+                    db=db, attribute=attribute, number_pool_parameters=number_pool_parameters
                 )
-            )
-            return
+
+            else:
+                errors.append(
+                    ValidationError(
+                        {f"{attribute.name}.from_pool": f"The pool requested {attribute.from_pool} was not found."}
+                    )
+                )
+                return
 
         if (
             number_pool.node.value in [self._schema.kind] + self._schema.inherit_from
             and number_pool.node_attribute.value == attribute.name
         ):
             try:
-                next_free = await number_pool.get_resource(db=db, branch=self._branch, node=self)
+                next_free = await number_pool.get_resource(db=db, branch=self._branch, node=self, attribute=attribute)
             except PoolExhaustedError:
                 errors.append(
                     ValidationError({f"{attribute.name}.from_pool": f"The pool {number_pool.node.value} is exhausted."})
@@ -292,6 +306,36 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 )
             )
 
+    async def _create_number_pool(
+        self, db: InfrahubDatabase, attribute: BaseAttribute, number_pool_parameters: NumberPoolParameters
+    ) -> CoreNumberPool:
+        schema = db.schema.get_node_schema(name="CoreNumberPool", duplicate=False)
+
+        pool_node = self._schema.kind
+        schema_attribute = self._schema.get_attribute(attribute.schema.name)
+        if schema_attribute.inherited:
+            for generic_name in self._schema.inherit_from:
+                generic_node = db.schema.get_generic_schema(name=generic_name, duplicate=False)
+                if attribute.schema.name in generic_node.attribute_names:
+                    pool_node = generic_node.kind
+                    break
+
+        number_pool = await Node.init(db=db, schema=schema, branch=self._branch)
+        await number_pool.new(
+            db=db,
+            id=number_pool_parameters.number_pool_id,
+            name=f"{pool_node}.{attribute.schema.name} [{number_pool_parameters.number_pool_id}]",
+            node=pool_node,
+            node_attribute=attribute.schema.name,
+            start_range=number_pool_parameters.start_range,
+            end_range=number_pool_parameters.end_range,
+            pool_type=NumberPoolType.SCHEMA.value,
+        )
+        await number_pool.save(db=db)
+        # Do a lookup of the number pool to get the correct mapped type from the registry
+        # without this we don't get access to the .get_resource() method.
+        return await registry.manager.get_one_by_id_or_default_filter(db=db, id=number_pool.id, kind=CoreNumberPool)
+
     async def handle_object_template(self, fields: dict, db: InfrahubDatabase, errors: list) -> None:
         """Fill the `fields` parameters with values from an object template if one is in use."""
         object_template_field = fields.get(OBJECT_TEMPLATE_RELATIONSHIP_NAME)
@@ -376,6 +420,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                             self._computed_jinja2_attributes.append(mandatory_attr)
                             continue
 
+                        if mandatory_attribute.kind == "NumberPool":
+                            continue
+
                     errors.append(
                         ValidationError({mandatory_attr: f"{mandatory_attr} is mandatory for {self.get_kind()}"})
                     )
@@ -392,6 +439,21 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         # -------------------------------------------
         # Generate Attribute and Relationship and assign them
         # -------------------------------------------
+        errors.extend(await self._process_fields_relationships(fields=fields, db=db))
+        errors.extend(await self._process_fields_attributes(fields=fields, db=db))
+
+        if errors:
+            raise ValidationError(errors)
+
+        # Check if any post processor have been defined
+        # A processor can be used for example to assigne a default value
+        for name in self._attributes + self._relationships:
+            if hasattr(self, f"process_{name}"):
+                await getattr(self, f"process_{name}")(db=db)
+
+    async def _process_fields_relationships(self, fields: dict, db: InfrahubDatabase) -> list[ValidationError]:
+        errors: list[ValidationError] = []
+
         for rel_schema in self._schema.relationships:
             self._relationships.append(rel_schema.name)
 
@@ -413,6 +475,11 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             except ValidationError as exc:
                 errors.append(exc)
 
+        return errors
+
+    async def _process_fields_attributes(self, fields: dict, db: InfrahubDatabase) -> list[ValidationError]:
+        errors: list[ValidationError] = []
+
         for attr_schema in self._schema.attributes:
             self._attributes.append(attr_schema.name)
             if not self._existing and attr_schema.name in self._computed_jinja2_attributes:
@@ -441,14 +508,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             except ValidationError as exc:
                 errors.append(exc)
 
-        if errors:
-            raise ValidationError(errors)
-
-        # Check if any post processor have been defined
-        # A processor can be used for example to assigne a default value
-        for name in self._attributes + self._relationships:
-            if hasattr(self, f"process_{name}"):
-                await getattr(self, f"process_{name}")(db=db)
+        return errors
 
     async def _process_macros(self, db: InfrahubDatabase) -> None:
         schema_branch = db.schema.get_schema_branch(self._branch.name)

infrahub/core/node/base.py

@@ -52,7 +52,7 @@ class BaseNodeOptions(BaseOptions):
 
 
 class ObjectNodeMeta(BaseNodeMeta):
-    def __new__(mcs, name_, bases, namespace, **options):  # noqa: N804
+    def __new__(mcs, name_, bases, namespace, **options):
         # Note: it's safe to pass options as keyword arguments as they are still type-checked by NodeOptions.
 
         # We create this type, to then overload it with the dataclass attrs

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -81,11 +81,15 @@ class CoreIPAddressPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int | None = None) -> IPAddressType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             ip_prefix = ipaddress.ip_network(resource.prefix.value)  # type: ignore[attr-defined]
             prefix_length = prefixlen or ip_prefix.prefixlen
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -88,11 +88,15 @@ class CoreIPPrefixPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int) -> IPNetworkType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             subnets = await get_subnets(
                 db=db,
                 ip_prefix=ipaddress.ip_network(resource.prefix.value),  # type: ignore[attr-defined]

infrahub/core/node/resource_manager/number_pool.py

@@ -2,22 +2,44 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub.core import registry
 from infrahub.core.query.resource_manager import NumberPoolGetReserved, NumberPoolGetUsed, NumberPoolSetReserved
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.exceptions import PoolExhaustedError
 
 from .. import Node
 
 if TYPE_CHECKING:
+    from infrahub.core.attribute import BaseAttribute
     from infrahub.core.branch import Branch
     from infrahub.database import InfrahubDatabase
 
 
 class CoreNumberPool(Node):
+    def get_attribute_nb_excluded_values(self) -> int:
+        """
+        Returns the number of excluded values for the attribute of the number pool.
+        """
+
+        pool_node = registry.schema.get(name=self.node.value)  # type: ignore [attr-defined]
+        attribute = [attribute for attribute in pool_node.attributes if attribute.name == self.node_attribute.value][0]  # type: ignore [attr-defined]
+        if not isinstance(attribute.parameters, NumberAttributeParameters):
+            return 0
+
+        sum_excluded_values = 0
+        excluded_ranges = attribute.parameters.get_excluded_ranges()
+        for start_range, end_range in excluded_ranges:
+            sum_excluded_values += end_range - start_range + 1
+
+        res = len(attribute.parameters.get_excluded_single_values()) + sum_excluded_values
+        return res
+
     async def get_resource(
         self,
         db: InfrahubDatabase,
         branch: Branch,
         node: Node,
+        attribute: BaseAttribute,
         identifier: str | None = None,
     ) -> int:
         identifier = identifier or node.get_id()
@@ -31,23 +53,24 @@ class CoreNumberPool(Node):
             return reservation
 
         # If we have not returned a value we need to find one if avaiable
-        number = await self.get_next(db=db, branch=branch)
+        number = await self.get_next(db=db, branch=branch, attribute=attribute)
 
         query_set = await NumberPoolSetReserved.init(
             db=db, pool_id=self.get_id(), identifier=identifier, reserved=number
         )
         await query_set.execute(db=db)
-
         return number
 
-    async def get_next(self, db: InfrahubDatabase, branch: Branch) -> int:
+    async def get_next(self, db: InfrahubDatabase, branch: Branch, attribute: BaseAttribute) -> int:
         query = await NumberPoolGetUsed.init(db=db, branch=branch, pool=self, branch_agnostic=True)
         await query.execute(db=db)
         taken = [result.get_as_optional_type("av.value", return_type=int) for result in query.results]
+        parameters = attribute.schema.parameters
         next_number = find_next_free(
             start=self.start_range.value,  # type: ignore[attr-defined]
             end=self.end_range.value,  # type: ignore[attr-defined]
             taken=taken,
+            parameters=parameters if isinstance(parameters, NumberAttributeParameters) else None,
         )
         if next_number is None:
             raise PoolExhaustedError("There are no more values available in this pool.")
@@ -55,12 +78,15 @@ class CoreNumberPool(Node):
         return next_number
 
 
-def find_next_free(start: int, end: int, taken: list[int | None]) -> int | None:
+def find_next_free(
+    start: int, end: int, taken: list[int | None], parameters: NumberAttributeParameters | None
+) -> int | None:
     used_numbers = [number for number in taken if number is not None]
     used_set = set(used_numbers)
 
     for num in range(start, end + 1):
         if num not in used_set:
-            return num
+            if parameters is None or parameters.is_valid_value(num):
+                return num
 
     return None

infrahub/core/node/standard.py

@@ -210,7 +210,12 @@ class StandardNode(BaseModel):
 
     @classmethod
     async def get_list(
-        cls, db: InfrahubDatabase, limit: int = 1000, ids: list[str] | None = None, name: str | None = None, **kwargs
+        cls,
+        db: InfrahubDatabase,
+        limit: int = 1000,
+        ids: list[str] | None = None,
+        name: str | None = None,
+        **kwargs: dict[str, Any],
     ) -> list[Self]:
         query: Query = await StandardNodeGetListQuery.init(
             db=db, node_class=cls, ids=ids, node_name=name, limit=limit, **kwargs

infrahub/core/path.py

@@ -125,7 +125,7 @@ class SchemaPath(InfrahubPath):
         if self.field_name:
             identifier += f"/{self.field_name}"
 
-        if self.property_name and not self.path_type == SchemaPathType.NODE:
+        if self.property_name and self.path_type != SchemaPathType.NODE:
             identifier += f"/{self.property_name}"
 
         return identifier

infrahub/core/protocols.py

@@ -227,6 +227,10 @@ class CoreWebhook(CoreNode):
     validate_certificates: BooleanOptional
 
 
+class CoreWeightedPoolResource(CoreNode):
+    allocation_weight: IntegerOptional
+
+
 class LineageOwner(CoreNode):
     pass
 
@@ -451,6 +455,7 @@ class CoreNumberPool(CoreResourcePool, LineageSource):
     node_attribute: String
     start_range: Integer
     end_range: Integer
+    pool_type: Enum
 
 
 class CoreObjectPermission(CoreBasePermission):
@@ -493,6 +498,11 @@ class CoreRepository(LineageOwner, LineageSource, CoreGenericRepository, CoreTas
     commit: StringOptional
 
 
+class CoreRepositoryGroup(CoreGroup):
+    content: Dropdown
+    repository: RelationshipManager
+
+
 class CoreRepositoryValidator(CoreValidator):
     repository: RelationshipManager
 

infrahub/core/query/node.py

@@ -1469,7 +1469,7 @@ class NodeGetHierarchyQuery(Query):
 
         clean_filters = extract_field_filters(field_name=self.direction.value, filters=self.filters)
 
-        if clean_filters and "id" in clean_filters or "ids" in clean_filters:
+        if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:
             where_clause.append("peer.uuid IN $peer_ids")
             self.params["peer_ids"] = clean_filters.get("ids", [])
             if clean_filters.get("id", None):

infrahub/core/query/relationship.py

@@ -217,8 +217,7 @@ class RelationshipQuery(Query):
         )
         source_query_match = """
             MATCH (s:Node { uuid: $source_id })
-            CALL {
-                WITH s
+            CALL (s) {
                 MATCH (s)-[r:IS_PART_OF]->(:Root)
                 WHERE %(source_filter)s
                 RETURN r.status = "active" AS s_is_active
@@ -246,8 +245,7 @@ class RelationshipQuery(Query):
             )
             destination_query_match = """
             MATCH (d:Node { uuid: $destination_id })
-            CALL {
-                WITH d
+            CALL (d) {
                 MATCH (d)-[r:IS_PART_OF]->(:Root)
                 WHERE %(destination_filter)s
                 RETURN r.status = "active" AS d_is_active
@@ -678,7 +676,7 @@ class RelationshipGetPeerQuery(Query):
         where_clause = ['all(r IN rels WHERE r.status = "active")']
         clean_filters = extract_field_filters(field_name=self.schema.name, filters=self.filters)
 
-        if clean_filters and "id" in clean_filters or "ids" in clean_filters:
+        if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:
             where_clause.append("peer.uuid IN $peer_ids")
             self.params["peer_ids"] = clean_filters.get("ids", [])
             if clean_filters.get("id", None):
@@ -1037,7 +1035,7 @@ class RelationshipDeleteAllQuery(Query):
         self.node_id = node_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
+    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:
         self.params["source_id"] = kwargs["node_id"]
         self.params["branch"] = self.branch.name
 

infrahub/core/query/standard_node.py

@@ -3,28 +3,42 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.query import Query, QueryType
+from infrahub.exceptions import InitializationError
 
 if TYPE_CHECKING:
+    from uuid import UUID
+
     from infrahub.core.node.standard import StandardNode
     from infrahub.database import InfrahubDatabase
 
 
 class StandardNodeQuery(Query):
     def __init__(
-        self, node: StandardNode = None, node_id: str | None = None, node_db_id: int | None = None, **kwargs: Any
-    ):
-        self.node = node
+        self,
+        node: StandardNode | None = None,
+        node_id: UUID | None = None,
+        node_db_id: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._node = node
         self.node_id = node_id
         self.node_db_id = node_db_id
 
-        if not self.node_id and self.node:
+        if not self.node_id and self._node:
             self.node_id = self.node.uuid
 
-        if not self.node_db_id and self.node:
+        if not self.node_db_id and self._node:
             self.node_db_id = self.node.id
 
         super().__init__(**kwargs)
 
+    @property
+    def node(self) -> StandardNode:
+        if self._node:
+            return self._node
+
+        raise InitializationError("The query is not initialized with a node")
+
 
 class RootNodeCreateQuery(StandardNodeQuery):
     name = "standard_node_create"

infrahub/core/relationship/constraints/peer_relatives.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.exceptions import ValidationError
+
+from .interface import RelationshipManagerConstraintInterface
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import RelationshipManager
+
+
+@dataclass
+class NodeToValidate:
+    uuid: str
+    relative_uuids: set[str]
+    schema: NonGenericSchemaTypes
+
+
+class RelationshipPeerRelativesConstraint(RelationshipManagerConstraintInterface):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    async def _check_relationship_peers_relatives(
+        self,
+        relm: RelationshipManager,
+        node_schema: MainSchemaTypes,
+        peers: Mapping[str, Node],
+        relationship_name: str,
+    ) -> None:
+        """Validate that all peers of a given `relm` have the same set of relatives (aka peers) for the given `relationship_name`."""
+        nodes_to_validate: list[NodeToValidate] = []
+
+        for peer in peers.values():
+            peer_schema = peer.get_schema()
+            peer_relm: RelationshipManager = getattr(peer, relationship_name)
+            peer_relm_peers = await peer_relm.get_peers(db=self.db)
+
+            nodes_to_validate.append(
+                NodeToValidate(
+                    uuid=peer.id, relative_uuids={n.id for n in peer_relm_peers.values()}, schema=peer_schema
+                )
+            )
+
+        relative_uuids = nodes_to_validate[0].relative_uuids
+        for node in nodes_to_validate[1:]:
+            if node.relative_uuids != relative_uuids:
+                raise ValidationError(
+                    f"All the elements of the '{relm.name}' relationship on node {node.uuid} ({node_schema.kind}) must have the same set of peers "
+                    f"for their '{node.schema.kind}.{relationship_name}' relationship"
+                )
+
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:
+        if relm.schema.cardinality != RelationshipCardinality.MANY or not relm.schema.common_relatives:
+            return
+
+        peers = await relm.get_peers(db=self.db)
+        if not peers:
+            return
+
+        for rel_name in relm.schema.common_relatives:
+            await self._check_relationship_peers_relatives(
+                relm=relm, node_schema=node_schema, peers=peers, relationship_name=rel_name
+            )

infrahub/core/relationship/model.py

@@ -494,7 +494,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             peer_fields = {
                 key: value
                 for key, value in fields.items()
-                if not key.startswith(PREFIX_PROPERTY) or not key == "__typename"
+                if not key.startswith(PREFIX_PROPERTY) or key != "__typename"
             }
             rel_fields = {
                 key.replace(PREFIX_PROPERTY, ""): value