infrahub-server 1.3.7__py3-none-any.whl → 1.4.0__py3-none-any.whl

infrahub/core/schema/definitions/core/__init__.py

@@ -35,7 +35,14 @@ from .group import (
     core_repository_group,
     core_standard_group,
 )
-from .ipam import builtin_ip_address, builtin_ip_prefix, builtin_ipam, core_ipam_namespace
+from .ipam import (
+    builtin_ip_address,
+    builtin_ip_prefix,
+    builtin_ipam,
+    core_ipam_namespace,
+    internal_ipam_ip_prefix_available,
+    internal_ipam_ip_range_available,
+)
 from .lineage import lineage_owner, lineage_source
 from .menu import generic_menu_item, menu_item
 from .permission import (
@@ -172,6 +179,8 @@ core_models_mixed: dict[str, list] = {
         core_object_permission,
         core_account_role,
         core_account_group,
+        internal_ipam_ip_prefix_available,
+        internal_ipam_ip_range_available,
     ],
 }
 

infrahub/core/schema/definitions/core/ipam.py

@@ -59,7 +59,7 @@ builtin_ip_prefix = GenericSchema(
     name="IPPrefix",
     label="IP Prefix",
     namespace="Builtin",
-    description="IPv6 or IPv4 prefix also referred as network",
+    description="IPv4 or IPv6 prefix also referred as network",
     include_in_menu=False,
     default_filter="prefix__value",
     order_by=["prefix__version", "prefix__binary_address", "prefix__prefixlen"],
@@ -142,7 +142,7 @@ builtin_ip_address = GenericSchema(
     name="IPAddress",
     label="IP Address",
     namespace="Builtin",
-    description="IPv6 or IPv4 address",
+    description="IPv4 or IPv6 address",
     include_in_menu=False,
     default_filter="address__value",
     order_by=["address__version", "address__binary_address"],
@@ -176,6 +176,32 @@ builtin_ip_address = GenericSchema(
     ],
 )
 
+internal_ipam_ip_range_available = NodeSchema(
+    name="IPRangeAvailable",
+    label="Available IP Range",
+    namespace="Internal",
+    description="Range of IPv4 or IPv6 addresses which has not been allocated yet",
+    include_in_menu=False,
+    display_labels=["address__value", "last_address__value"],
+    branch=BranchSupportType.AWARE,
+    inherit_from=[InfrahubKind.IPADDRESS],
+    generate_profile=False,
+    attributes=[Attr(name="last_address", kind="IPHost", branch=BranchSupportType.AWARE, order_weight=2000)],
+)
+
+internal_ipam_ip_prefix_available = NodeSchema(
+    name="IPPrefixAvailable",
+    label="Available IP Prefix",
+    namespace="Internal",
+    description="IPv4 or IPv6 prefix also referred as network which has not been allocated yet",
+    include_in_menu=False,
+    display_labels=["prefix__value"],
+    branch=BranchSupportType.AWARE,
+    inherit_from=[InfrahubKind.IPPREFIX],
+    generate_profile=False,
+)
+
+
 core_ipam_namespace = NodeSchema(
     name="Namespace",
     namespace="Ipam",

infrahub/core/schema/definitions/core/propose_change.py

@@ -38,6 +38,9 @@ core_proposed_change = NodeSchema(
             default_value=ProposedChangeState.OPEN.value,
             optional=True,
         ),
+        Attr(name="is_draft", kind="Boolean", optional=False, default_value=False),
+        # Ideally we should support some "runtime-attribute" that could not even be stored in the database.
+        Attr(name="total_comments", kind="Number", optional=True, read_only=True),
     ],
     relationships=[
         Rel(
@@ -48,6 +51,17 @@ core_proposed_change = NodeSchema(
             kind=RelKind.ATTRIBUTE,
             branch=BranchSupportType.AGNOSTIC,
             identifier="coreaccount__proposedchange_approved_by",
+            read_only=True,
+        ),
+        Rel(
+            name="rejected_by",
+            peer=InfrahubKind.GENERICACCOUNT,
+            optional=True,
+            cardinality=Cardinality.MANY,
+            kind=RelKind.ATTRIBUTE,
+            branch=BranchSupportType.AGNOSTIC,
+            identifier="coreaccount__proposedchange_rejected_by",
+            read_only=True,
         ),
         Rel(
             name="reviewers",
@@ -66,6 +80,7 @@ core_proposed_change = NodeSchema(
             kind=RelKind.ATTRIBUTE,
             branch=BranchSupportType.AGNOSTIC,
             identifier="coreaccount__proposedchange_created_by",
+            read_only=True,
         ),
         Rel(
             name="comments",

infrahub/core/schema/definitions/core/webhook.py

@@ -120,6 +120,9 @@ core_custom_webhook = NodeSchema(
     branch=BranchSupportType.AGNOSTIC,
     generate_profile=False,
     inherit_from=[InfrahubKind.WEBHOOK, InfrahubKind.TASKTARGET],
+    attributes=[
+        Attr(name="shared_key", kind="Password", unique=False, optional=True, order_weight=4000),
+    ],
     relationships=[
         Rel(
             name="transformation",

infrahub/core/schema/definitions/internal.py

@@ -487,7 +487,7 @@ attribute_schema = SchemaNode(
             kind="Text",
             description="Defines the type of the attribute.",
             enum=ATTRIBUTE_KIND_LABELS,
-            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="enum",

infrahub/core/schema/generated/attribute_schema.py

@@ -31,7 +31,7 @@ class GeneratedAttributeSchema(HashableModel):
         json_schema_extra={"update": "migration_required"},
     )
     kind: str = Field(
-        ..., description="Defines the type of the attribute.", json_schema_extra={"update": "validate_constraint"}
+        ..., description="Defines the type of the attribute.", json_schema_extra={"update": "migration_required"}
     )
     enum: list | None = Field(
         default=None,

infrahub/core/schema/generic_schema.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub.core.constants import InfrahubKind
+
 from .generated.genericnode_schema import GeneratedGenericSchema
 
 if TYPE_CHECKING:
@@ -28,6 +30,14 @@ class GenericSchema(GeneratedGenericSchema):
     def is_template_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return self.kind == InfrahubKind.IPPREFIX
+
+    @property
+    def is_ip_address(self) -> bool:
+        return self.kind == InfrahubKind.IPADDRESS
+
     def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Branch | str | None = None) -> GenericSchema:  # noqa: ARG002
         if self.hierarchical:
             return self

infrahub/core/schema/manager.py

@@ -93,6 +93,15 @@ class SchemaManager(NodeManager):
 
         raise ValueError("The selected node is not of type NodeSchema")
 
+    def get_generic_schema(
+        self, name: str, branch: Branch | str | None = None, duplicate: bool = True
+    ) -> GenericSchema:
+        schema = self.get(name=name, branch=branch, duplicate=duplicate)
+        if isinstance(schema, GenericSchema):
+            return schema
+
+        raise ValueError("The selected node is not of type GenericSchema")
+
     def get_profile_schema(
         self, name: str, branch: Branch | str | None = None, duplicate: bool = True
     ) -> ProfileSchema:
@@ -122,7 +131,7 @@ class SchemaManager(NodeManager):
 
         return self._branches[branch_name].get_all(duplicate=duplicate)
 
-    async def get_full_safe(self, branch: Branch | str | None = None) -> dict[str, NodeSchema | GenericSchema]:
+    async def get_full_safe(self, branch: Branch | str | None = None) -> dict[str, MainSchemaTypes]:
         await lock.registry.local_schema_wait()
 
         return self.get_full(branch=branch)

infrahub/core/schema/node_schema.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from infrahub.core.constants import AllowOverrideType, InfrahubKind
+from infrahub.core.constants import AllowOverrideType, InfrahubKind, RelationshipKind
 
 from .generated.node_schema import GeneratedNodeSchema
 from .generic_schema import GenericSchema
@@ -29,6 +29,16 @@ class NodeSchema(GeneratedNodeSchema):
     def is_template_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        """Return whether a node is a derivative of built-in IP prefixes."""
+        return InfrahubKind.IPPREFIX in self.inherit_from
+
+    @property
+    def is_ip_address(self) -> bool:
+        """Return whether a node is a derivative of built-in IP addreses."""
+        return InfrahubKind.IPADDRESS in self.inherit_from
+
     def validate_inheritance(self, interface: GenericSchema) -> None:
         """Perform checks specific to inheritance from Generics.
 
@@ -53,21 +63,19 @@ class NodeSchema(GeneratedNodeSchema):
                         f"{self.kind}.{attribute.name} inherited from {interface.namespace}{interface.name} must be the same kind "
                         f'["{interface_attr.kind}", "{attribute.kind}"]'
                     )
-                if attribute.optional != interface_attr.optional:
-                    raise ValueError(
-                        f"{self.kind}.{attribute.name} inherited from {interface.namespace}{interface.name} must have the same value for property "
-                        f'"optional" ["{interface_attr.optional}", "{attribute.optional}"]'
-                    )
 
         for relationship in self.relationships:
-            if (
-                relationship.name in interface.relationship_names
-                and not relationship.inherited
-                and interface.get_relationship(relationship.name).allow_override == AllowOverrideType.NONE
-            ):
-                raise ValueError(
-                    f"{self.kind}'s relationship {relationship.name} inherited from {interface.kind} cannot be overriden"
-                )
+            if relationship.name in interface.relationship_names and not relationship.inherited:
+                interface_relationship = interface.get_relationship(relationship.name)
+                if interface_relationship.allow_override == AllowOverrideType.NONE:
+                    raise ValueError(
+                        f"{self.kind}'s relationship {relationship.name} inherited from {interface.kind} cannot be overriden"
+                    )
+                if relationship.kind != RelationshipKind.HIERARCHY and relationship.peer != interface_relationship.peer:
+                    raise ValueError(
+                        f"{self.kind}'s relationship {relationship.name} inherited from {interface.kind} must have the same peer "
+                        f"({interface_relationship.peer} != {relationship.peer})"
+                    )
 
     def inherit_from_interface(self, interface: GenericSchema) -> None:
         existing_inherited_attributes: dict[str, int] = {
@@ -137,11 +145,3 @@ class NodeSchema(GeneratedNodeSchema):
         if self.namespace not in ["Schema", "Internal"] and InfrahubKind.GENERICGROUP not in self.inherit_from:
             labels.append(InfrahubKind.NODE)
         return labels
-
-    def is_ip_prefix(self) -> bool:
-        """Return whether a node is a derivative of built-in IP prefixes."""
-        return InfrahubKind.IPPREFIX in self.inherit_from
-
-    def is_ip_address(self) -> bool:
-        """Return whether a node is a derivative of built-in IP addreses."""
-        return InfrahubKind.IPADDRESS in self.inherit_from

infrahub/core/schema/profile_schema.py

@@ -28,6 +28,14 @@ class ProfileSchema(BaseNodeSchema):
     def is_template_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return False
+
+    @property
+    def is_ip_address(self) -> bool:
+        return False
+
     def get_labels(self) -> list[str]:
         """Return the labels for this object, composed of the kind
         and the list of Generic this object is inheriting from."""

infrahub/core/schema/schema_branch.py

@@ -119,7 +119,7 @@ class SchemaBranch:
     def template_names(self) -> list[str]:
         return list(self.templates.keys())
 
-    def get_all_kind_id_map(self, nodes_and_generics_only: bool = False) -> dict[str, str]:
+    def get_all_kind_id_map(self, nodes_and_generics_only: bool = False) -> dict[str, str | None]:
         kind_id_map = {}
         if nodes_and_generics_only:
             names = self.node_names + self.generic_names_without_templates
@@ -226,8 +226,8 @@ class SchemaBranch:
     def update(self, schema: SchemaBranch) -> None:
         """Update another SchemaBranch into this one."""
 
-        local_kinds = list(self.nodes.keys()) + list(self.generics.keys())
-        other_kinds = list(schema.nodes.keys()) + list(schema.generics.keys())
+        local_kinds = self.all_names
+        other_kinds = schema.all_names
 
         in_both, _, other_only = compare_lists(list1=local_kinds, list2=other_kinds)
 
@@ -441,7 +441,7 @@ class SchemaBranch:
         return list(all_schemas.values())
 
     def get_schemas_by_rel_identifier(self, identifier: str) -> list[MainSchemaTypes]:
-        nodes: list[RelationshipSchema] = []
+        nodes: list[MainSchemaTypes] = []
         for node_name in list(self.nodes.keys()) + list(self.generics.keys()):
             node = self.get(name=node_name, duplicate=False)
             rel = node.get_relationship_by_identifier(id=identifier, raise_on_error=False)
@@ -660,7 +660,7 @@ class SchemaBranch:
                     and not (
                         schema_attribute_path.relationship_schema.name == "ip_namespace"
                         and isinstance(node_schema, NodeSchema)
-                        and (node_schema.is_ip_address() or node_schema.is_ip_prefix())
+                        and (node_schema.is_ip_address or node_schema.is_ip_prefix)
                     )
                 ):
                     raise ValueError(
@@ -1447,7 +1447,8 @@ class SchemaBranch:
                 node.validate_inheritance(interface=generic_kind_schema)
 
                 # Store the list of node referencing a specific generics
-                generics_used_by[generic_kind].append(node.kind)
+                if node.namespace != "Internal":
+                    generics_used_by[generic_kind].append(node.kind)
                 node.inherit_from_interface(interface=generic_kind_schema)
 
             if len(generic_with_hierarchical_support) > 1:
@@ -1925,7 +1926,10 @@ class SchemaBranch:
         for node_name in self.node_names + self.generic_names:
             node = self.get(name=node_name, duplicate=False)
 
-            if node.namespace in RESTRICTED_NAMESPACES:
+            if node.namespace in RESTRICTED_NAMESPACES and node.kind not in (
+                InfrahubKind.IPRANGEAVAILABLE,
+                InfrahubKind.IPPREFIXAVAILABLE,
+            ):
                 continue
 
             profiles_rel_settings: dict[str, Any] = {

infrahub/core/schema/template_schema.py

@@ -27,6 +27,14 @@ class TemplateSchema(BaseNodeSchema):
     def is_template_schema(self) -> bool:
         return True
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return False
+
+    @property
+    def is_ip_address(self) -> bool:
+        return False
+
     def get_labels(self) -> list[str]:
         """Return the labels for this object, composed of the kind and the list of Generic this object is inheriting from."""
 

infrahub/core/validators/attribute/kind.py

@@ -65,8 +65,12 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             if value in (None, NULL_VALUE):
                 continue
             try:
+                attr_value = result.get("attribute_value")
                 infrahub_attribute_class.validate_format(
-                    value=result.get("attribute_value"), name=self.attribute_schema.name, schema=self.attribute_schema
+                    value=attr_value, name=self.attribute_schema.name, schema=self.attribute_schema
+                )
+                infrahub_attribute_class.validate_content(
+                    value=attr_value, name=self.attribute_schema.name, schema=self.attribute_schema
                 )
             except ValidationError:
                 grouped_data_paths.add_data_path(

infrahub/core/validators/checks_runner.py

@@ -6,7 +6,7 @@ from infrahub_sdk.protocols import CoreValidator
 from infrahub.context import InfrahubContext
 from infrahub.core.constants import ValidatorConclusion, ValidatorState
 from infrahub.core.timestamp import Timestamp
-from infrahub.services import InfrahubServices
+from infrahub.services.adapters.event import InfrahubEventService
 from infrahub.validators.events import send_failed_validator, send_passed_validator
 
 
@@ -14,7 +14,7 @@ async def run_checks_and_update_validator(
     checks: list[Coroutine[Any, None, ValidatorConclusion]],
     validator: CoreValidator,
     context: InfrahubContext,
-    service: InfrahubServices,
+    event_service: InfrahubEventService,
     proposed_change_id: str,
 ) -> None:
     """
@@ -38,7 +38,7 @@ async def run_checks_and_update_validator(
             failed_early = True
             await validator.save()
             await send_failed_validator(
-                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+                event_service=event_service, validator=validator, proposed_change_id=proposed_change_id, context=context
             )
             # Continue to iterate to wait for the end of all checks
 
@@ -52,9 +52,9 @@ async def run_checks_and_update_validator(
     if not failed_early:
         if validator.conclusion.value == ValidatorConclusion.SUCCESS.value:
             await send_passed_validator(
-                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+                event_service=event_service, validator=validator, proposed_change_id=proposed_change_id, context=context
             )
         else:
             await send_failed_validator(
-                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+                event_service=event_service, validator=validator, proposed_change_id=proposed_change_id, context=context
             )

infrahub/core/validators/determiner.py

@@ -98,7 +98,10 @@ class ConstraintValidatorDeterminer:
                 continue
 
             prop_field_update = prop_field_info.json_schema_extra.get("update")
-            if prop_field_update != UpdateSupport.VALIDATE_CONSTRAINT.value:
+            if prop_field_update not in (
+                UpdateSupport.VALIDATE_CONSTRAINT.value,
+                UpdateSupport.MIGRATION_REQUIRED.value,
+            ):
                 continue
 
             if getattr(schema, prop_name) is None:
@@ -112,6 +115,13 @@ class ConstraintValidatorDeterminer:
             )
             constraint_name = f"node.{prop_name}.update"
 
+            do_constraint_validation = prop_field_update == UpdateSupport.VALIDATE_CONSTRAINT.value or (
+                prop_field_update == UpdateSupport.MIGRATION_REQUIRED.value
+                and CONSTRAINT_VALIDATOR_MAP.get(constraint_name)
+            )
+            if not do_constraint_validation:
+                continue
+
             constraints.append(SchemaUpdateConstraintInfo(constraint_name=constraint_name, path=schema_path))
         return constraints
 
@@ -154,7 +164,10 @@ class ConstraintValidatorDeterminer:
                 continue
 
             prop_field_update = prop_field_info.json_schema_extra.get("update")
-            if prop_field_update != UpdateSupport.VALIDATE_CONSTRAINT.value:
+            if prop_field_update not in (
+                UpdateSupport.VALIDATE_CONSTRAINT.value,
+                UpdateSupport.MIGRATION_REQUIRED.value,
+            ):
                 continue
 
             if prop_value is None:
@@ -168,6 +181,13 @@ class ConstraintValidatorDeterminer:
                 path_type = SchemaPathType.RELATIONSHIP
                 constraint_name = f"relationship.{prop_name}.update"
 
+            do_constraint_validation = prop_field_update == UpdateSupport.VALIDATE_CONSTRAINT.value or (
+                prop_field_update == UpdateSupport.MIGRATION_REQUIRED.value
+                and CONSTRAINT_VALIDATOR_MAP.get(constraint_name)
+            )
+            if not do_constraint_validation:
+                continue
+
             schema_path = SchemaPath(
                 schema_kind=schema.kind,
                 path_type=path_type,

infrahub/core/validators/tasks.py

@@ -13,19 +13,18 @@ from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
 from infrahub.core.validators.model import SchemaConstraintValidatorRequest, SchemaViolation
 from infrahub.dependencies.registry import get_component_registry
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workers.dependencies import get_database
 from infrahub.workflows.utils import add_tags
 
 from .models.validate_migration import SchemaValidateMigrationData, SchemaValidatorPathResponseData
 
 if TYPE_CHECKING:
     from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.database import InfrahubDatabase
 
 
 @flow(name="schema_validate_migrations", flow_run_name="Validate schema migrations", persist_result=True)
-async def schema_validate_migrations(
-    message: SchemaValidateMigrationData, service: InfrahubServices
-) -> list[SchemaValidatorPathResponseData]:
+async def schema_validate_migrations(message: SchemaValidateMigrationData) -> list[SchemaValidatorPathResponseData]:
     batch = InfrahubBatch(return_exceptions=True)
     log = get_run_logger()
     await add_tags(branches=[message.branch.name])
@@ -47,7 +46,7 @@ async def schema_validate_migrations(
             node_schema=schema,
             schema_path=constraint.path,
             schema_branch=message.schema_branch,
-            service=service,
+            database=await get_database(),
         )
 
     results = [result async for _, result in batch.execute()]
@@ -67,9 +66,9 @@ async def schema_path_validate(
     node_schema: NodeSchema | GenericSchema,
     schema_path: SchemaPath,
     schema_branch: SchemaBranch,
-    service: InfrahubServices,
+    database: InfrahubDatabase,
 ) -> SchemaValidatorPathResponseData:
-    async with service.database.start_session(read_only=True) as db:
+    async with database.start_session(read_only=True) as db:
         constraint_request = SchemaConstraintValidatorRequest(
             branch=branch,
             constraint_name=constraint_name,

infrahub/core/validators/uniqueness/checker.py

@@ -75,7 +75,7 @@ class UniquenessChecker(ConstraintCheckerInterface):
 
     async def build_query_request(self, schema: MainSchemaTypes) -> NodeUniquenessQueryRequest:
         unique_attr_paths = {
-            QueryAttributePath(attribute_name=attr_schema.name, property_name="value")
+            QueryAttributePath(attribute_name=attr_schema.name, attribute_kind=attr_schema.kind, property_name="value")
             for attr_schema in schema.unique_attributes
         }
         relationship_attr_paths = set()
@@ -92,7 +92,9 @@ class UniquenessChecker(ConstraintCheckerInterface):
                 sub_schema, property_name = get_attribute_path_from_string(path, schema)
                 if isinstance(sub_schema, AttributeSchema):
                     unique_attr_paths.add(
-                        QueryAttributePath(attribute_name=sub_schema.name, property_name=property_name)
+                        QueryAttributePath(
+                            attribute_name=sub_schema.name, attribute_kind=sub_schema.kind, property_name=property_name
+                        )
                     )
                 elif isinstance(sub_schema, RelationshipSchema):
                     relationship_attr_paths.add(

infrahub/core/validators/uniqueness/model.py

@@ -22,6 +22,7 @@ class QueryRelationshipAttributePath(BaseModel):
 
 class QueryAttributePath(BaseModel):
     attribute_name: str
+    attribute_kind: str
     property_name: str | None = Field(default=None)
     value: Any | None = Field(default=None)