infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.2__py3-none-any.whl

infrahub/core/attribute.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import ipaddress
 import re
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 import netaddr
 import ujson
-from infrahub_sdk.timestamp import TimestampFormatError
+from infrahub_sdk.exceptions import TimestampFormatError
 from infrahub_sdk.utils import is_valid_url
 from infrahub_sdk.uuidt import UUIDT
 from pydantic import BaseModel, Field
@@ -43,7 +43,7 @@ if TYPE_CHECKING:
 MAX_STRING_LENGTH = 4096
 
 
-def validate_string_length(value: Optional[str]) -> None:
+def validate_string_length(value: str | None) -> None:
     """
     Validates input string length does not exceed a given threshold, as Neo4J cannot index string values larger than 8167 bytes,
     see https://neo4j.com/developer/kb/index-limitations-and-workaround/.
@@ -75,7 +75,7 @@ class AttributeCreateData(BaseModel):
 
 
 class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
-    type: Optional[Union[type, tuple[type]]] = None
+    type: type | tuple[type] | None = None
 
     _rel_to_node_label: str = RELATIONSHIP_TO_NODE_LABEL
     _rel_to_value_label: str = RELATIONSHIP_TO_VALUE_LABEL
@@ -87,10 +87,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         branch: Branch,
         at: Timestamp,
         node: Node,
-        id: Optional[str] = None,
-        db_id: Optional[str] = None,
-        data: Optional[Union[dict, str, AttributeFromDB]] = None,
-        updated_at: Optional[Union[Timestamp, str]] = None,
+        id: str | None = None,
+        db_id: str | None = None,
+        data: dict | str | AttributeFromDB | None = None,
+        updated_at: Timestamp | str | None = None,
         is_default: bool = False,
         is_from_profile: bool = False,
         **kwargs,
@@ -106,7 +106,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         self.at = at
         self.is_default = is_default
         self.is_from_profile = is_from_profile
-        self.from_pool: Optional[dict] = None
+        self.from_pool: dict | None = None
 
         self._init_node_property_mixin(kwargs)
         self._init_flag_property_mixin(kwargs)
@@ -317,7 +317,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         """Deserialize the value coming from the database."""
         return data.value
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
+    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
         """Create or Update the Attribute in the database."""
 
         save_at = Timestamp(at)
@@ -327,7 +327,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         return await self._update(at=save_at, db=db)
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
+    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
         if not self.db_id:
             return None
 
@@ -388,7 +388,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         return changelog
 
-    async def _update(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
+    async def _update(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
         """Update the attribute in the database.
 
         Get the current value
@@ -497,10 +497,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
     async def to_graphql(
         self,
         db: InfrahubDatabase,
-        fields: Optional[dict] = None,
-        related_node_ids: Optional[set] = None,
+        fields: dict | None = None,
+        related_node_ids: set | None = None,
         filter_sensitive: bool = False,
-        permissions: Optional[dict] = None,
+        permissions: dict | None = None,
         include_properties: bool = True,
     ) -> dict:
         """Generate GraphQL Payload for this attribute."""
@@ -677,7 +677,7 @@ class String(BaseAttribute):
 
 
 class StringOptional(String):
-    value: Optional[str]
+    value: str | None
 
 
 class HashedPassword(BaseAttribute):
@@ -690,13 +690,13 @@ class HashedPassword(BaseAttribute):
 
 
 class HashedPasswordOptional(HashedPassword):
-    value: Optional[str]
+    value: str | None
 
 
 class Integer(BaseAttribute):
     type = int
     value: int
-    from_pool: Optional[str] = None
+    from_pool: str | None = None
 
     @classmethod
     def validate_format(cls, value: Any, name: str, schema: AttributeSchema) -> None:
@@ -715,7 +715,7 @@ class Integer(BaseAttribute):
 
 
 class IntegerOptional(Integer):
-    value: Optional[int]
+    value: int | None
 
 
 class Boolean(BaseAttribute):
@@ -724,7 +724,7 @@ class Boolean(BaseAttribute):
 
 
 class BooleanOptional(Boolean):
-    value: Optional[bool]
+    value: bool | None
 
 
 class DateTime(BaseAttribute):
@@ -745,7 +745,7 @@ class DateTime(BaseAttribute):
 
 
 class DateTimeOptional(DateTime):
-    value: Optional[str]
+    value: str | None
 
 
 class Dropdown(BaseAttribute):
@@ -792,7 +792,7 @@ class Dropdown(BaseAttribute):
 
 
 class DropdownOptional(Dropdown):
-    value: Optional[str]
+    value: str | None
 
 
 class URL(BaseAttribute):
@@ -808,7 +808,7 @@ class URL(BaseAttribute):
 
 
 class URLOptional(URL):
-    value: Optional[str]
+    value: str | None
 
 
 class IPNetwork(BaseAttribute):
@@ -820,35 +820,35 @@ class IPNetwork(BaseAttribute):
         return ["value", "version", "binary_address", "prefixlen"]
 
     @property
-    def obj(self) -> Union[ipaddress.IPv4Network, ipaddress.IPv6Network]:
+    def obj(self) -> ipaddress.IPv4Network | ipaddress.IPv6Network:
         """Return an ipaddress interface object."""
         if not self.value:
             raise ValueError("value for IPNetwork must be defined")
         return ipaddress.ip_network(str(self.value))
 
     @property
-    def broadcast_address(self) -> Optional[str]:
+    def broadcast_address(self) -> str | None:
         """Return the broadcast address of the ip network."""
         if not self.value:
             return None
         return str(self.obj.broadcast_address)
 
     @property
-    def hostmask(self) -> Optional[str]:
+    def hostmask(self) -> str | None:
         """Return the hostmask of the ip network."""
         if not self.value:
             return None
         return str(self.obj.hostmask)
 
     @property
-    def netmask(self) -> Optional[str]:
+    def netmask(self) -> str | None:
         """Return the netmask of the ip network."""
         if not self.value:
             return None
         return str(self.obj.netmask)
 
     @property
-    def network_address(self) -> Optional[str]:
+    def network_address(self) -> str | None:
         """Return the netmask of the ip network."""
         if not self.value:
             return None
@@ -865,35 +865,35 @@ class IPNetwork(BaseAttribute):
         return convert_ip_to_binary_str(obj=self.obj)
 
     @property
-    def prefixlen(self) -> Optional[int]:
+    def prefixlen(self) -> int | None:
         """Return the prefix length the ip network."""
         if not self.value:
             return None
         return ipaddress.ip_network(str(self.value)).prefixlen
 
     @property
-    def num_addresses(self) -> Optional[int]:
+    def num_addresses(self) -> int | None:
         """Return the number of possible addresses in the ip network."""
         if not self.value:
             return None
         return ipaddress.ip_network(str(self.value)).num_addresses
 
     @property
-    def version(self) -> Optional[int]:
+    def version(self) -> int | None:
         """Return the IP version of the ip network."""
         if not self.value:
             return None
         return ipaddress.ip_network(str(self.value)).version
 
     @property
-    def with_hostmask(self) -> Optional[str]:
+    def with_hostmask(self) -> str | None:
         """Return the network ip and the associated hostmask of the ip network."""
         if not self.value:
             return None
         return ipaddress.ip_network(str(self.value)).with_hostmask
 
     @property
-    def with_netmask(self) -> Optional[str]:
+    def with_netmask(self) -> str | None:
         """Return the network ip and the associated netmask of the ip network."""
         if not self.value:
             return None
@@ -941,7 +941,7 @@ class IPNetwork(BaseAttribute):
 
 
 class IPNetworkOptional(IPNetwork):
-    value: Optional[str]
+    value: str | None
 
 
 class IPHost(BaseAttribute):
@@ -953,63 +953,63 @@ class IPHost(BaseAttribute):
         return ["value", "version", "binary_address"]
 
     @property
-    def obj(self) -> Union[ipaddress.IPv4Interface, ipaddress.IPv6Interface]:
+    def obj(self) -> ipaddress.IPv4Interface | ipaddress.IPv6Interface:
         """Return the ip adress without a prefix or subnet mask."""
         if not self.value:
             raise ValueError("value for IPHost must be defined")
         return ipaddress.ip_interface(str(self.value))
 
     @property
-    def ip(self) -> Optional[str]:
+    def ip(self) -> str | None:
         """Return the ip adress without a prefix or subnet mask."""
         if not self.value:
             return None
         return str(self.obj.ip)
 
     @property
-    def hostmask(self) -> Optional[str]:
+    def hostmask(self) -> str | None:
         """Return the hostmask of the ip address."""
         if not self.value:
             return None
         return str(self.obj.hostmask)
 
     @property
-    def netmask(self) -> Optional[str]:
+    def netmask(self) -> str | None:
         """Return the netmask of the ip address."""
         if not self.value:
             return None
         return str(self.obj.netmask)
 
     @property
-    def network(self) -> Optional[str]:
+    def network(self) -> str | None:
         """Return the network encapsuling the ip address."""
         if not self.value:
             return None
         return str(self.obj.network)
 
     @property
-    def prefixlen(self) -> Optional[int]:
+    def prefixlen(self) -> int | None:
         """Return the prefix length of the ip address."""
         if not self.value:
             return None
         return self.obj.network.prefixlen
 
     @property
-    def version(self) -> Optional[int]:
+    def version(self) -> int | None:
         """Return the IP version of the ip address."""
         if not self.value:
             return None
         return self.obj.version
 
     @property
-    def with_hostmask(self) -> Optional[str]:
+    def with_hostmask(self) -> str | None:
         """Return the ip address and the associated hostmask of the ip address."""
         if not self.value:
             return None
         return self.obj.with_hostmask
 
     @property
-    def with_netmask(self) -> Optional[str]:
+    def with_netmask(self) -> str | None:
         """Return the ip address and the associated netmask of the ip address."""
         if not self.value:
             return None
@@ -1066,7 +1066,7 @@ class IPHost(BaseAttribute):
 
 
 class IPHostOptional(IPHost):
-    value: Optional[str]
+    value: str | None
 
 
 class MacAddress(BaseAttribute):
@@ -1081,7 +1081,7 @@ class MacAddress(BaseAttribute):
         return netaddr.EUI(addr=self.value)
 
     @property
-    def oui(self) -> Optional[str]:
+    def oui(self) -> str | None:
         """Return the OUI (Organisationally Unique Identifier) for the MAC address."""
         if not self.value:
             return None
@@ -1093,58 +1093,58 @@ class MacAddress(BaseAttribute):
             return str(self.obj).removesuffix(f"-{self.ei}")
 
     @property
-    def ei(self) -> Optional[str]:
+    def ei(self) -> str | None:
         """Return the EI (Extension Identifier) for the MAC address."""
         if not self.value:
             return None
         return self.obj.ei
 
     @property
-    def version(self) -> Optional[int]:
+    def version(self) -> int | None:
         """Return the version of the MAC address."""
         if not self.value:
             return None
         return self.obj.version
 
     @property
-    def binary(self) -> Optional[str]:
+    def binary(self) -> str | None:
         """Return the MAC address in binary format."""
         if not self.value:
             return None
         return self.obj.bin
 
     @property
-    def eui48(self) -> Optional[str]:
+    def eui48(self) -> str | None:
         if not self.value:
             return None
         return self.obj.format(dialect=netaddr.mac_eui48)
 
     @property
-    def eui64(self) -> Optional[str]:
+    def eui64(self) -> str | None:
         if not self.value:
             return None
         return str(self.obj.eui64())
 
     @property
-    def bare(self) -> Optional[str]:
+    def bare(self) -> str | None:
         if not self.value:
             return None
         return self.obj.format(dialect=netaddr.mac_bare)
 
     @property
-    def dot_notation(self) -> Optional[str]:
+    def dot_notation(self) -> str | None:
         if not self.value:
             return None
         return self.obj.format(dialect=netaddr.mac_cisco)
 
     @property
-    def semicolon_notation(self) -> Optional[str]:
+    def semicolon_notation(self) -> str | None:
         if not self.value:
             return None
         return self.obj.format(dialect=netaddr.mac_unix)
 
     @property
-    def split_notation(self) -> Optional[str]:
+    def split_notation(self) -> str | None:
         if not self.value:
             return None
         return self.obj.format(dialect=netaddr.mac_pgsql)
@@ -1172,7 +1172,7 @@ class MacAddress(BaseAttribute):
 
 
 class MacAddressOptional(MacAddress):
-    value: Optional[str]
+    value: str | None
 
 
 class ListAttribute(BaseAttribute):
@@ -1208,12 +1208,12 @@ class ListAttribute(BaseAttribute):
 
 
 class ListAttributeOptional(ListAttribute):
-    value: Optional[list[Any]]
+    value: list[Any] | None
 
 
 class JSONAttribute(BaseAttribute):
     type = (dict, list)
-    value: Union[dict, list]
+    value: dict | list
 
     @classmethod
     def deserialize_from_string(cls, value_as_string: str) -> Any:
@@ -1244,4 +1244,4 @@ class JSONAttribute(BaseAttribute):
 
 
 class JSONAttributeOptional(JSONAttribute):
-    value: Optional[Union[dict, list]]
+    value: dict | list | None

infrahub/core/branch/tasks.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Any
+from uuid import uuid4
 
 import pydantic
 from prefect import flow, get_run_logger
@@ -11,23 +12,24 @@ from infrahub import lock
 from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
 from infrahub.core import registry
 from infrahub.core.branch import Branch
-from infrahub.core.changelog.diff import DiffChangelogCollector
+from infrahub.core.changelog.diff import DiffChangelogCollector, MigrationTracker
 from infrahub.core.constants import MutationAction
 from infrahub.core.diff.coordinator import DiffCoordinator
 from infrahub.core.diff.ipam_diff_parser import IpamDiffParser
 from infrahub.core.diff.merger.merger import DiffMerger
-from infrahub.core.diff.model.path import BranchTrackingId
+from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRoot, EnrichedDiffRootMetadata
 from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.core.merge import BranchMerger
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.validators.determiner import ConstraintValidatorDeterminer
 from infrahub.core.validators.models.validate_migration import SchemaValidateMigrationData
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
 from infrahub.events.models import EventMeta, InfrahubEvent
-from infrahub.events.node_action import NodeMutatedEvent
+from infrahub.events.node_action import get_node_event
 from infrahub.exceptions import BranchNotFoundError, MergeFailedError, ValidationError
 from infrahub.graphql.mutations.models import BranchCreateModel  # noqa: TC001
 from infrahub.log import get_log_data
@@ -44,7 +46,7 @@ from infrahub.workflows.utils import add_tags
 
 
 @flow(name="branch-rebase", flow_run_name="Rebase branch {branch}")
-async def rebase_branch(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+async def rebase_branch(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:  # noqa: PLR0915
     async with service.database.start_session() as db:
         log = get_run_logger()
         await add_tags(branches=[branch])
@@ -54,6 +56,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, service: Infrahub
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
         diff_coordinator = await component_registry.get_component(DiffCoordinator, db=db, branch=obj)
         diff_merger = await component_registry.get_component(DiffMerger, db=db, branch=obj)
+        initial_from_time = Timestamp(obj.get_branched_from())
         merger = BranchMerger(
             db=db,
             diff_coordinator=diff_coordinator,
@@ -62,7 +65,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, service: Infrahub
             source_branch=obj,
             service=service,
         )
-        diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
+
         enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
         async for _ in diff_repository.get_all_conflicts_for_diff(
             diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
@@ -97,7 +100,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, service: Infrahub
                 raise ValidationError(",\n".join(error_messages))
 
         schema_in_main_before = merger.destination_schema.duplicate()
-
+        migrations = []
         async with lock.registry.global_graph_lock():
             async with db.start_transaction() as dbt:
                 await obj.rebase(db=dbt)
@@ -134,6 +137,14 @@ async def rebase_branch(branch: str, context: InfrahubContext, service: Infrahub
                 for error in errors:
                     log.error(error)
 
+        default_branch_diff = await _get_diff_root(
+            diff_coordinator=diff_coordinator,
+            enriched_diff_metadata=enriched_diff_metadata,
+            diff_repository=diff_repository,
+            base_branch=base_branch,
+            target_from=initial_from_time,
+        )
+
         # -------------------------------------------------------------
         # Trigger the reconciliation of IPAM data after the rebase
         # -------------------------------------------------------------
@@ -156,16 +167,32 @@ async def rebase_branch(branch: str, context: InfrahubContext, service: Infrahub
     # -------------------------------------------------------------
     # Generate an event to indicate that a branch has been rebased
     # -------------------------------------------------------------
-    # TODO Add account information
-    await service.event.send(
-        event=BranchRebasedEvent(
-            branch_name=obj.name, branch_id=str(obj.uuid), meta=EventMeta(branch=obj, context=context)
-        )
+    rebase_event = BranchRebasedEvent(
+        branch_name=obj.name, branch_id=str(obj.uuid), meta=EventMeta(branch=obj, context=context)
+    )
+    events: list[InfrahubEvent] = [rebase_event]
+    changelog_collector = DiffChangelogCollector(
+        diff=default_branch_diff, branch=obj, db=db, migration_tracker=MigrationTracker(migrations=migrations)
     )
+    for action, node_changelog in changelog_collector.collect_changelogs():
+        node_event_class = get_node_event(MutationAction.from_diff_action(diff_action=action))
+        mutate_event = node_event_class(
+            kind=node_changelog.node_kind,
+            node_id=node_changelog.node_id,
+            changelog=node_changelog,
+            fields=node_changelog.updated_fields,
+            meta=EventMeta.from_parent(parent=rebase_event, branch=obj),
+        )
+        events.append(mutate_event)
+
+    for event in events:
+        await service.event.send(event)
 
 
 @flow(name="branch-merge", flow_run_name="Merge branch {branch} into main")
-async def merge_branch(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+async def merge_branch(
+    branch: str, context: InfrahubContext, service: InfrahubServices, proposed_change_id: str | None = None
+) -> None:
     async with service.database.start_session() as db:
         log = get_run_logger()
 
@@ -174,7 +201,12 @@ async def merge_branch(branch: str, context: InfrahubContext, service: InfrahubS
         obj = await Branch.get_by_name(db=db, name=branch)
         default_branch = await registry.get_branch(db=db, branch=registry.default_branch)
         component_registry = get_component_registry()
-        merge_event = BranchMergedEvent(meta=EventMeta.from_context(context=context, branch=obj))
+        merge_event = BranchMergedEvent(
+            branch_name=obj.name,
+            branch_id=str(obj.get_uuid()),
+            proposed_change_id=proposed_change_id,
+            meta=EventMeta.from_context(context=context, branch=registry.get_global_branch()),
+        )
 
         merger: BranchMerger | None = None
         async with lock.registry.global_graph_lock():
@@ -252,16 +284,15 @@ async def merge_branch(branch: str, context: InfrahubContext, service: InfrahubS
         events: list[InfrahubEvent] = [merge_event]
 
         for action, node_changelog in node_events:
-            meta = EventMeta.from_parent(parent=merge_event)
-            mutate_event = NodeMutatedEvent(
+            meta = EventMeta.from_parent(parent=merge_event, branch=default_branch)
+            node_event_class = get_node_event(MutationAction.from_diff_action(diff_action=action))
+            mutate_event = node_event_class(
                 kind=node_changelog.node_kind,
                 node_id=node_changelog.node_id,
-                data=node_changelog,
-                action=MutationAction.from_diff_action(diff_action=action),
+                changelog=node_changelog,
                 fields=node_changelog.updated_fields,
                 meta=meta,
             )
-            mutate_event.set_context_branch(branch=default_branch)
             events.append(mutate_event)
 
         for event in events:
@@ -280,7 +311,7 @@ async def delete_branch(branch: str, context: InfrahubContext, service: Infrahub
             branch_name=branch,
             branch_id=str(obj.uuid),
             sync_with_git=obj.sync_with_git,
-            meta=EventMeta(branch=obj, context=context),
+            meta=EventMeta.from_context(context=context, branch=registry.get_global_branch()),
         )
 
         await service.workflow.submit_workflow(
@@ -348,9 +379,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext, serv
             branch_name=obj.name,
             branch_id=str(obj.uuid),
             sync_with_git=obj.sync_with_git,
-            meta=EventMeta(
-                branch=obj, account_id=context.account.account_id, initiator_id=WORKER_IDENTITY, context=context
-            ),
+            meta=EventMeta.from_context(context=context, branch=registry.get_global_branch()),
         )
         await service.event.send(event=event)
 
@@ -360,3 +389,26 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext, serv
                 context=context,
                 parameters={"branch": obj.name, "branch_id": str(obj.uuid)},
             )
+
+
+async def _get_diff_root(
+    diff_coordinator: DiffCoordinator,
+    enriched_diff_metadata: EnrichedDiffRootMetadata,
+    diff_repository: DiffRepository,
+    base_branch: Branch,
+    target_from: Timestamp,
+) -> EnrichedDiffRoot:
+    default_branch_diff = await diff_coordinator.create_or_update_arbitrary_timeframe_diff(
+        base_branch=base_branch,
+        diff_branch=base_branch,
+        from_time=target_from,
+        to_time=enriched_diff_metadata.to_time,
+        name=str(uuid4()),
+    )
+    # make sure we have the actual diff with data and not just the metadata
+    if not isinstance(default_branch_diff, EnrichedDiffRoot):
+        default_branch_diff = await diff_repository.get_one(
+            diff_branch_name=base_branch.name, diff_id=default_branch_diff.uuid
+        )
+
+    return default_branch_diff