IFC-279 Allow to define same peer set contraint (#6526)

This change adds a relationship schema attribute and a constraint
validator to check that peers of a relationship have the same set of
related nodes on one or more of their relationships.

Author: gmazoyer

backend/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
+            )

backend/infrahub/core/schema/definitions/internal.py

@@ -754,6 +754,14 @@ def to_dict(self) -> dict[str, Any]:
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
+        SchemaAttribute(
+            name="common_relatives",
+            kind="List",
+            internal_kind=str,
+            optional=True,
+            description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
+            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+        ),
         SchemaAttribute(
             name="order_weight",
             kind="Number",

backend/infrahub/core/schema/generated/relationship_schema.py

@@ -73,6 +73,11 @@ class GeneratedRelationshipSchema(HashableModel):
         description="Defines the maximum objects allowed on the other side of the relationship.",
         json_schema_extra={"update": "validate_constraint"},
     )
+    common_relatives: list[str] | None = Field(
+        default=None,
+        description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
+        json_schema_extra={"update": "validate_constraint"},
+    )
     order_weight: int | None = Field(
         default=None,
         description="Number used to order the relationship in the frontend (table and view). Lowest value will be ordered first.",

backend/infrahub/core/schema/schema_branch.py

@@ -997,6 +997,13 @@ def validate_kinds(self) -> None:
                     raise ValueError(
                         f"{node.kind}: Relationship {rel.name!r} is referring an invalid peer {rel.peer!r}"
                     ) from None
+                if rel.common_relatives:
+                    peer_schema = self.get(name=rel.peer, duplicate=False)
+                    for common_relatives_rel_name in rel.common_relatives:
+                        if common_relatives_rel_name not in peer_schema.relationship_names:
+                            raise ValueError(
+                                f"{node.kind}: Relationship {rel.name!r} set 'common_relatives' with invalid relationship from '{rel.peer}'"
+                            ) from None
 
     def validate_attribute_parameters(self) -> None:
         for name in self.generics.keys():

backend/infrahub/dependencies/builder/constraint/grouped/node_runner.py

@@ -4,6 +4,7 @@
 from ..node.grouped_uniqueness import NodeGroupedUniquenessConstraintDependency
 from ..relationship_manager.count import RelationshipCountConstraintDependency
 from ..relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from ..relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from ..relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 
 
@@ -18,5 +19,6 @@ def build(cls, context: DependencyBuilderContext) -> NodeConstraintRunner:
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),
                 RelationshipProfilesKindConstraintDependency.build(context=context),
+                RelationshipPeerRelativesConstraintDependency.build(context=context),
             ],
         )

backend/infrahub/dependencies/builder/constraint/relationship_manager/peer_relatives.py

@@ -0,0 +1,8 @@
+from infrahub.core.relationship.constraints.peer_relatives import RelationshipPeerRelativesConstraint
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class RelationshipPeerRelativesConstraintDependency(DependencyBuilder[RelationshipPeerRelativesConstraint]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipPeerRelativesConstraint:
+        return RelationshipPeerRelativesConstraint(db=context.db, branch=context.branch)

backend/infrahub/dependencies/registry.py

@@ -3,6 +3,7 @@
 from .builder.constraint.node.uniqueness import NodeAttributeUniquenessConstraintDependency
 from .builder.constraint.relationship_manager.count import RelationshipCountConstraintDependency
 from .builder.constraint.relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from .builder.constraint.relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from .builder.constraint.relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 from .builder.constraint.schema.aggregated import AggregatedSchemaConstraintsDependency
 from .builder.constraint.schema.attribute_regex import SchemaAttributeRegexConstraintDependency
@@ -37,6 +38,7 @@ def build_component_registry() -> ComponentDependencyRegistry:
     component_registry.track_dependency(RelationshipCountConstraintDependency)
     component_registry.track_dependency(RelationshipProfilesKindConstraintDependency)
     component_registry.track_dependency(RelationshipPeerKindConstraintDependency)
+    component_registry.track_dependency(RelationshipPeerRelativesConstraintDependency)
     component_registry.track_dependency(NodeConstraintRunnerDependency)
     component_registry.track_dependency(NodeDeleteValidatorDependency)
     component_registry.track_dependency(IpamKindsGetterDependency)

backend/tests/constants/kind.py

@@ -6,6 +6,7 @@
 DEVICE = "TestingDevice"
 INTERFACE = "TestingInterface"
 INTERFACE_HOLDER = "TestingInterfaceHolder"
+LAG_INTERFACE = "TestingLinkAggegrationInterface"
 LOCATION = "TestingLocation"
 MANUFACTURER = "TestingManufacturer"
 PERSON = "TestingPerson"

backend/tests/functional/constraints/__init__.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import copy
+from typing import TYPE_CHECKING
+
+import pytest
+from infrahub_sdk.exceptions import GraphQLError
+
+from infrahub.core.node import Node
+from tests.constants import TestKind
+from tests.helpers.schema import DEVICE_SCHEMA, load_schema
+from tests.helpers.schema.device import LAG_INTERFACE
+from tests.helpers.test_app import TestInfrahubApp
+
+if TYPE_CHECKING:
+    from infrahub_sdk import InfrahubClient
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.schema import SchemaRoot
+    from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.database import InfrahubDatabase
+
+
+class TestPeerRelativesConstraint(TestInfrahubApp):
+    @pytest.fixture(scope="class", autouse=True)
+    def schema(self, default_branch: Branch, register_internal_schema: SchemaBranch) -> SchemaRoot:
+        schema_with_lag = copy.deepcopy(DEVICE_SCHEMA)
+        schema_with_lag.nodes[0].generate_template = False
+        schema_with_lag.nodes.append(LAG_INTERFACE)
+        return schema_with_lag
+
+    @pytest.fixture(scope="class")
+    async def data(
+        self,
+        db: InfrahubDatabase,
+        initialize_registry: None,
+        client: InfrahubClient,
+        default_branch: Branch,
+        schema: SchemaRoot,
+    ) -> dict[str, Node]:
+        await load_schema(db, schema=schema, update_db=True)
+
+        device_1 = await Node.init(db=db, schema=TestKind.DEVICE)
+        await device_1.new(db=db, name="Foo", manufacturer="Foo Inc.", weight=10, airflow="Front to rear")
+
+        interfaces_1: list[Node] = []
+        interfaces_1_ids: list[str] = []
+        for if_name in ["et-0/0/0", "et-0/0/1", "et-0/0/2", "et-0/0/3"]:
+            interface = await Node.init(db=db, schema=TestKind.PHYSICAL_INTERFACE)
+            await interface.new(db=db, name=if_name, phys_type="QSFP28 (100GE)", device=device_1)
+            await interface.save(db=db)
+            interfaces_1.append(interface)
+            interfaces_1_ids.append(interface.id)
+
+        await device_1.interfaces.update(db=db, data=interfaces_1)  # type: ignore[attr-defined]
+        await device_1.save(db=db)
+
+        device_2 = await Node.init(db=db, schema=TestKind.DEVICE)
+        await device_2.new(db=db, name="Bar", manufacturer="Bar Inc.", weight=10, airflow="Front to rear")
+
+        interfaces_2: list[Node] = []
+        interfaces_2_ids: list[str] = []
+        for if_name in ["et-0/0/0", "et-0/0/1", "et-0/0/2", "et-0/0/3"]:
+            interface = await Node.init(db=db, schema=TestKind.PHYSICAL_INTERFACE)
+            await interface.new(db=db, name=if_name, phys_type="QSFP28 (100GE)", device=device_2)
+            await interface.save(db=db)
+            interfaces_2.append(interface)
+            interfaces_2_ids.append(interface.id)
+
+        await device_2.interfaces.update(db=db, data=interfaces_2)  # type: ignore[attr-defined]
+        await device_2.save(db=db)
+
+        return {"device_1": device_1, "device_2": device_2}
+
+    async def test_create_lag_main(
+        self, db: InfrahubDatabase, data: dict[str, Node], client: InfrahubClient, default_branch: Branch
+    ) -> None:
+        device = await client.get(kind=TestKind.DEVICE, id=data["device_1"].id, branch=default_branch.name)
+        await device.interfaces.fetch()
+
+        lag = await client.create(
+            kind=TestKind.LAG_INTERFACE,
+            name="ae0",
+            device=device,
+            members=[i.peer for i in device.interfaces],  # type: ignore[attr-defined]
+            branch=default_branch.name,
+        )
+        await lag.save()
+
+        assert len(lag.members.peers) == 4
+        assert sorted(lag.members.peer_ids) == sorted([i.id for i in device.interfaces])
+
+    async def test_create_incorrect_lag_main(
+        self, db: InfrahubDatabase, data: dict[str, Node], client: InfrahubClient, default_branch: Branch
+    ) -> None:
+        device_1 = await client.get(kind=TestKind.DEVICE, id=data["device_1"].id, branch=default_branch.name)
+        await device_1.interfaces.fetch()
+        device_2 = await client.get(kind=TestKind.DEVICE, id=data["device_2"].id, branch=default_branch.name)
+        await device_2.interfaces.fetch()
+
+        lag = await client.create(
+            kind=TestKind.LAG_INTERFACE,
+            name="ae1",
+            device=device_1,
+            members=[i.peer for i in list(device_1.interfaces)[:-1] + list(device_2.interfaces)],  # type: ignore[attr-defined]
+            branch=default_branch.name,
+        )
+
+        with pytest.raises(GraphQLError) as exc:
+            await lag.save()
+        assert (
+            "must have the same set of peers for their 'TestingPhysicalInterface.device' relationship"
+            in exc.value.errors[0]["message"]
+        )
+
+    async def test_create_lag_branch(
+        self, db: InfrahubDatabase, data: dict[str, Node], client: InfrahubClient, default_branch: Branch
+    ) -> None:
+        branch = await client.branch.create(branch_name="test-lag")
+
+        device = await client.get(kind=TestKind.DEVICE, id=data["device_2"].id, branch=branch.name)
+        await device.interfaces.fetch()
+
+        lag = await client.create(
+            kind=TestKind.LAG_INTERFACE,
+            name="ae0",
+            device=device,
+            members=[i.peer for i in device.interfaces],  # type: ignore[attr-defined]
+            branch=branch.name,
+        )
+        await lag.save()
+
+        assert len(lag.members.peers) == 4
+        assert sorted(lag.members.peer_ids) == sorted([i.id for i in device.interfaces])
+
+    async def test_create_incorrect_lag_branch(
+        self, db: InfrahubDatabase, data: dict[str, Node], client: InfrahubClient, default_branch: Branch
+    ) -> None:
+        branch = await client.branch.create(branch_name="test-lag-incorrect")
+
+        device_1 = await client.get(kind=TestKind.DEVICE, id=data["device_1"].id, branch=branch.name)
+        await device_1.interfaces.fetch()
+        device_2 = await client.get(kind=TestKind.DEVICE, id=data["device_2"].id, branch=branch.name)
+        await device_2.interfaces.fetch()
+
+        lag = await client.create(
+            kind=TestKind.LAG_INTERFACE,
+            name="ae1",
+            device=device_2,
+            members=[i.peer for i in list(device_1.interfaces)[:-1] + list(device_2.interfaces)[:-1]],  # type: ignore[attr-defined]
+            branch=branch.name,
+        )
+
+        with pytest.raises(GraphQLError) as exc:
+            await lag.save()
+        assert (
+            "must have the same set of peers for their 'TestingPhysicalInterface.device' relationship"
+            in exc.value.errors[0]["message"]
+        )