omnibase_infra 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

omnibase_infra/runtime/service_kernel.py

@@ -55,6 +55,7 @@ import signal
 import sys
 import time
 from collections.abc import Awaitable, Callable
+from functools import partial
 from importlib.metadata import version as get_package_version
 from pathlib import Path
 from typing import cast
@@ -75,7 +76,15 @@ from omnibase_infra.errors import (
 from omnibase_infra.event_bus.event_bus_inmemory import EventBusInmemory
 from omnibase_infra.event_bus.event_bus_kafka import EventBusKafka
 from omnibase_infra.event_bus.models.config import ModelKafkaEventBusConfig
+from omnibase_infra.event_bus.models.model_event_message import ModelEventMessage
 from omnibase_infra.models import ModelNodeIdentity
+from omnibase_infra.nodes.contract_registry_reducer.contract_registration_event_router import (
+    ContractRegistrationEventRouter,
+    ProtocolIntentEffect,
+)
+from omnibase_infra.nodes.contract_registry_reducer.reducer import (
+    ContractRegistryReducer,
+)
 from omnibase_infra.nodes.node_registration_orchestrator.dispatchers import (
     DispatcherNodeIntrospected,
 )
@@ -423,6 +432,11 @@ async def bootstrap() -> int:
     health_server: ServiceHealth | None = None
     postgres_pool: asyncpg.Pool | None = None
     introspection_unsubscribe: Callable[[], Awaitable[None]] | None = None
+    # Contract registry unsubscribe functions and router
+    contract_router: ContractRegistrationEventRouter | None = None
+    contract_unsub_registered: Callable[[], Awaitable[None]] | None = None
+    contract_unsub_deregistered: Callable[[], Awaitable[None]] | None = None
+    contract_unsub_heartbeat: Callable[[], Awaitable[None]] | None = None
     correlation_id = generate_correlation_id()
     bootstrap_start_time = time.time()
 
@@ -458,6 +472,7 @@ async def bootstrap() -> int:
 
         # 3. Create event bus
         # Dispatch based on configuration or environment variable:
+        # - ONEX_EVENT_BUS_TYPE env var overrides config.event_bus.type
         # - If KAFKA_BOOTSTRAP_SERVERS env var is set, use EventBusKafka
         # - If config.event_bus.type == "kafka", use EventBusKafka
         # - Otherwise, use EventBusInmemory for local development/testing
@@ -465,12 +480,54 @@ async def bootstrap() -> int:
         environment = os.getenv("ONEX_ENVIRONMENT") or config.event_bus.environment
         kafka_bootstrap_servers = os.getenv("KAFKA_BOOTSTRAP_SERVERS")
 
-        # Explicit bool evaluation (not truthy string) for kafka usage.
-        # KAFKA_BOOTSTRAP_SERVERS env var takes precedence over config.event_bus.type.
-        # This prevents implicit "kafka but localhost" fallback scenarios.
-        use_kafka: bool = (
-            bool(kafka_bootstrap_servers) or config.event_bus.type == "kafka"
-        )
+        # Check for ONEX_EVENT_BUS_TYPE environment variable override
+        # This allows CI/testing environments to force inmemory event bus
+        # even when the config file defaults to kafka.
+        event_bus_type_override = os.getenv("ONEX_EVENT_BUS_TYPE", "").lower()
+        if event_bus_type_override:
+            logger.debug(
+                "Event bus type override from ONEX_EVENT_BUS_TYPE=%s (correlation_id=%s)",
+                event_bus_type_override,
+                correlation_id,
+            )
+
+        # Determine effective event bus type with override precedence:
+        # 1. ONEX_EVENT_BUS_TYPE env var (highest priority)
+        # 2. KAFKA_BOOTSTRAP_SERVERS env var (if set, implies kafka)
+        # 3. config.event_bus.type (from runtime_config.yaml)
+        if event_bus_type_override == "inmemory":
+            # Explicit inmemory override - use inmemory regardless of other config
+            use_kafka = False
+            logger.info(
+                "Using inmemory event bus (ONEX_EVENT_BUS_TYPE override) (correlation_id=%s)",
+                correlation_id,
+            )
+        elif event_bus_type_override == "kafka":
+            # Explicit kafka override - validate that bootstrap_servers is available
+            use_kafka = True
+        elif event_bus_type_override and event_bus_type_override not in (
+            "inmemory",
+            "kafka",
+        ):
+            # Invalid override value - warn and fall back to config
+            logger.warning(
+                "Invalid ONEX_EVENT_BUS_TYPE value '%s', expected 'inmemory' or 'kafka'. "
+                "Falling back to config.event_bus.type='%s' (correlation_id=%s)",
+                event_bus_type_override,
+                config.event_bus.type,
+                correlation_id,
+            )
+            use_kafka = (
+                bool(kafka_bootstrap_servers) or config.event_bus.type == "kafka"
+            )
+        else:
+            # No override - use original logic
+            # Explicit bool evaluation (not truthy string) for kafka usage.
+            # KAFKA_BOOTSTRAP_SERVERS env var takes precedence over config.event_bus.type.
+            # This prevents implicit "kafka but localhost" fallback scenarios.
+            use_kafka = (
+                bool(kafka_bootstrap_servers) or config.event_bus.type == "kafka"
+            )
 
         # Validate bootstrap_servers is provided when kafka is requested via config
         # This prevents confusing implicit localhost:9092 fallback
@@ -931,6 +988,81 @@ async def bootstrap() -> int:
                         },
                     )
 
+                # 4.9. Wire ContractRegistrationEventRouter if contract_registry.enabled
+                # This router subscribes to contract lifecycle events (registration,
+                # deregistration, heartbeat) and routes them to the ContractRegistryReducer.
+                # The router also runs an internal tick timer for staleness computation.
+                if config.contract_registry.enabled and postgres_pool is not None:
+                    # Import postgres handlers for contract persistence
+                    # Deferred import to avoid loading heavy dependencies when not needed
+                    from omnibase_infra.nodes.node_contract_persistence_effect.handlers import (
+                        HandlerPostgresCleanupTopics,
+                        HandlerPostgresContractUpsert,
+                        HandlerPostgresDeactivate,
+                        HandlerPostgresHeartbeat,
+                        HandlerPostgresMarkStale,
+                        HandlerPostgresTopicUpdate,
+                    )
+
+                    # Create effect handlers keyed by intent_type
+                    # These handlers execute PostgreSQL operations for intents from the reducer
+                    # Note: Handlers implement ProtocolIntentEffect duck-typing style with
+                    # more specific payload types. Cast tells mypy they satisfy the protocol.
+                    contract_effect_handlers: dict[str, ProtocolIntentEffect] = {
+                        "postgres.upsert_contract": cast(
+                            "ProtocolIntentEffect",
+                            HandlerPostgresContractUpsert(postgres_pool),
+                        ),
+                        "postgres.update_topic": cast(
+                            "ProtocolIntentEffect",
+                            HandlerPostgresTopicUpdate(postgres_pool),
+                        ),
+                        "postgres.mark_stale": cast(
+                            "ProtocolIntentEffect",
+                            HandlerPostgresMarkStale(postgres_pool),
+                        ),
+                        "postgres.update_heartbeat": cast(
+                            "ProtocolIntentEffect",
+                            HandlerPostgresHeartbeat(postgres_pool),
+                        ),
+                        "postgres.deactivate_contract": cast(
+                            "ProtocolIntentEffect",
+                            HandlerPostgresDeactivate(postgres_pool),
+                        ),
+                        "postgres.cleanup_topic_references": cast(
+                            "ProtocolIntentEffect",
+                            HandlerPostgresCleanupTopics(postgres_pool),
+                        ),
+                    }
+
+                    # Create reducer and router
+                    contract_reducer = ContractRegistryReducer()
+                    contract_router = ContractRegistrationEventRouter(
+                        container=container,
+                        reducer=contract_reducer,
+                        effect_handlers=contract_effect_handlers,
+                        event_bus=event_bus,
+                        tick_interval_seconds=config.contract_registry.tick_interval_seconds,
+                    )
+
+                    logger.info(
+                        "ContractRegistrationEventRouter created (correlation_id=%s)",
+                        correlation_id,
+                        extra={
+                            "tick_interval_seconds": config.contract_registry.tick_interval_seconds,
+                            "handler_count": len(contract_effect_handlers),
+                        },
+                    )
+                else:
+                    logger.debug(
+                        "Contract registry disabled or no postgres_pool (correlation_id=%s)",
+                        correlation_id,
+                        extra={
+                            "contract_registry_enabled": config.contract_registry.enabled,
+                            "postgres_pool_available": postgres_pool is not None,
+                        },
+                    )
+
             except Exception as pool_error:
                 # Log warning but continue without registration support
                 # Use sanitize_error_message to prevent credential leakage in logs
@@ -1298,6 +1430,84 @@ async def bootstrap() -> int:
                 },
             )
 
+        # 9.6. Start contract registry event consumer if router is available
+        # This consumer subscribes to 3 Kafka topics for contract lifecycle events
+        # and routes them to the ContractRegistryReducer for projection.
+        if contract_router is not None and has_subscribe:
+            # Create typed node identity for contract registry subscriptions
+            contract_node_identity = ModelNodeIdentity(
+                env=environment,
+                service=config.name or "onex-kernel",
+                node_name="contract-registry",
+                version=config.contract_version or "v1",
+            )
+
+            # Subscribe to 3 contract lifecycle topics with same identity
+            contract_subscribe_start_time = time.time()
+
+            # Derive environment-aware topic names (avoid hardcoded "dev." prefix)
+            contract_registered_topic = (
+                f"{environment}.onex.evt.platform.contract-registered.v1"
+            )
+            contract_deregistered_topic = (
+                f"{environment}.onex.evt.platform.contract-deregistered.v1"
+            )
+            node_heartbeat_topic = f"{environment}.onex.evt.platform.node-heartbeat.v1"
+
+            logger.info(
+                "Subscribing to contract registry events on event bus (correlation_id=%s)",
+                correlation_id,
+                extra={
+                    "topics": [
+                        contract_registered_topic,
+                        contract_deregistered_topic,
+                        node_heartbeat_topic,
+                    ],
+                    "node_identity": {
+                        "env": contract_node_identity.env,
+                        "service": contract_node_identity.service,
+                        "node_name": contract_node_identity.node_name,
+                        "version": contract_node_identity.version,
+                    },
+                    "purpose": EnumConsumerGroupPurpose.CONTRACT_REGISTRY.value,
+                },
+            )
+
+            contract_unsub_registered = await event_bus.subscribe(
+                topic=contract_registered_topic,
+                node_identity=contract_node_identity,
+                on_message=contract_router.handle_message,
+                purpose=EnumConsumerGroupPurpose.CONTRACT_REGISTRY,
+            )
+            contract_unsub_deregistered = await event_bus.subscribe(
+                topic=contract_deregistered_topic,
+                node_identity=contract_node_identity,
+                on_message=contract_router.handle_message,
+                purpose=EnumConsumerGroupPurpose.CONTRACT_REGISTRY,
+            )
+            contract_unsub_heartbeat = await event_bus.subscribe(
+                topic=node_heartbeat_topic,
+                node_identity=contract_node_identity,
+                on_message=contract_router.handle_message,
+                purpose=EnumConsumerGroupPurpose.CONTRACT_REGISTRY,
+            )
+
+            # Start the router's tick timer
+            await contract_router.start()
+
+            contract_subscribe_duration = time.time() - contract_subscribe_start_time
+            logger.info(
+                "Contract registry event consumers started successfully in %.3fs (correlation_id=%s)",
+                contract_subscribe_duration,
+                correlation_id,
+                extra={
+                    "topics_count": 3,
+                    "tick_interval_seconds": contract_router.tick_interval_seconds,
+                    "subscribe_duration_seconds": contract_subscribe_duration,
+                    "event_bus_type": event_bus_type,
+                },
+            )
+
         # Calculate total bootstrap time
         bootstrap_duration = time.time() - bootstrap_start_time
 
@@ -1309,14 +1519,24 @@ async def bootstrap() -> int:
                 registration_status = "enabled (PostgreSQL only)"
         else:
             registration_status = "disabled"
+
+        # Contract registry status for banner
+        if contract_router is not None:
+            contract_registry_status = (
+                f"enabled (tick: {config.contract_registry.tick_interval_seconds}s)"
+            )
+        else:
+            contract_registry_status = "disabled"
+
         banner_lines = [
             "=" * 60,
             f"ONEX Runtime Kernel v{KERNEL_VERSION}",
             f"Environment: {environment}",
             f"Contracts: {contracts_dir}",
             f"Event Bus: {event_bus_type} (group: {config.consumer_group})",
-            f"Topics: {config.input_topic} → {config.output_topic}",
+            f"Topics: {config.input_topic} -> {config.output_topic}",
             f"Registration: {registration_status}",
+            f"Contract Registry: {contract_registry_status}",
             f"Health endpoint: http://0.0.0.0:{http_port}/health",
             f"Bootstrap time: {bootstrap_duration:.3f}s",
             f"Correlation ID: {correlation_id}",
@@ -1367,6 +1587,47 @@ async def bootstrap() -> int:
                 )
             introspection_unsubscribe = None
 
+        # Stop contract registry router and consumers
+        if contract_router is not None:
+            try:
+                await contract_router.stop()
+                logger.debug(
+                    "Contract registry router stopped (correlation_id=%s)",
+                    correlation_id,
+                )
+            except Exception as router_stop_error:
+                logger.warning(
+                    "Failed to stop contract registry router: %s (correlation_id=%s)",
+                    sanitize_error_message(router_stop_error),
+                    correlation_id,
+                )
+            contract_router = None
+
+        # Unsubscribe from contract registry topics
+        for unsub_name, unsub_func in [
+            ("contract-registered", contract_unsub_registered),
+            ("contract-deregistered", contract_unsub_deregistered),
+            ("node-heartbeat", contract_unsub_heartbeat),
+        ]:
+            if unsub_func is not None:
+                try:
+                    await unsub_func()
+                    logger.debug(
+                        "Contract registry consumer %s stopped (correlation_id=%s)",
+                        unsub_name,
+                        correlation_id,
+                    )
+                except Exception as unsub_error:
+                    logger.warning(
+                        "Failed to stop contract registry consumer %s: %s (correlation_id=%s)",
+                        unsub_name,
+                        sanitize_error_message(unsub_error),
+                        correlation_id,
+                    )
+        contract_unsub_registered = None
+        contract_unsub_deregistered = None
+        contract_unsub_heartbeat = None
+
         # Stop health server (fast, non-blocking)
         if health_server is not None:
             try:
@@ -1492,7 +1753,7 @@ async def bootstrap() -> int:
 
     finally:
         # Guard cleanup - stop all resources if not already stopped
-        # Order: introspection consumer -> health server -> runtime -> pool
+        # Order: introspection consumer -> contract registry -> health server -> runtime -> pool
 
         if introspection_unsubscribe is not None:
             try:
@@ -1504,6 +1765,32 @@ async def bootstrap() -> int:
                     correlation_id,
                 )
 
+        # Cleanup contract registry router and consumers
+        if contract_router is not None:
+            try:
+                await contract_router.stop()
+            except Exception as cleanup_error:
+                logger.warning(
+                    "Failed to stop contract registry router during cleanup: %s (correlation_id=%s)",
+                    sanitize_error_message(cleanup_error),
+                    correlation_id,
+                )
+
+        for unsub_func in [
+            contract_unsub_registered,
+            contract_unsub_deregistered,
+            contract_unsub_heartbeat,
+        ]:
+            if unsub_func is not None:
+                try:
+                    await unsub_func()
+                except Exception as cleanup_error:
+                    logger.warning(
+                        "Failed to stop contract registry consumer during cleanup: %s (correlation_id=%s)",
+                        sanitize_error_message(cleanup_error),
+                        correlation_id,
+                    )
+
         if health_server is not None:
             try:
                 await health_server.stop()

omnibase_infra/runtime/service_runtime_host_process.py

@@ -73,6 +73,12 @@ from omnibase_infra.errors import (
 from omnibase_infra.event_bus.event_bus_inmemory import EventBusInmemory
 from omnibase_infra.event_bus.event_bus_kafka import EventBusKafka
 from omnibase_infra.models import ModelNodeIdentity
+from omnibase_infra.models.runtime.model_resolved_dependencies import (
+    ModelResolvedDependencies,
+)
+from omnibase_infra.runtime.contract_dependency_resolver import (
+    ContractDependencyResolver,
+)
 from omnibase_infra.runtime.envelope_validator import (
     normalize_correlation_id,
     validate_envelope,
@@ -764,6 +770,10 @@ class RuntimeHostProcess:
         # Enables contract config to be passed to handlers via initialize()
         self._handler_descriptors: dict[str, ModelHandlerDescriptor] = {}
 
+        # Contract dependency resolver for protocol auto-injection (OMN-1903)
+        # Lazy-created when first needed during handler population
+        self._dependency_resolver: ContractDependencyResolver | None = None
+
         # Pending message tracking for graceful shutdown (OMN-756)
         # Tracks count of in-flight messages currently being processed
         self._pending_message_count: int = 0
@@ -1798,11 +1808,44 @@ class RuntimeHostProcess:
                     handler_type
                 )
 
-                # Instantiate the handler with container for dependency injection
+                # Get descriptor early for dependency resolution (OMN-1903)
+                descriptor = self._handler_descriptors.get(handler_type)
+
+                # R1/R3: Resolve dependencies if contract has them (OMN-1903)
+                # Returns None if descriptor has no contract_path or no dependencies
+                resolved_dependencies: ModelResolvedDependencies | None = None
+                if descriptor:
+                    # This may raise ProtocolDependencyResolutionError (R2: fail-fast)
+                    resolved_dependencies = await self._resolve_handler_dependencies(
+                        descriptor
+                    )
+
+                # Instantiate the handler with container (and dependencies if supported)
                 # ProtocolContainerAware defines __init__(container: ModelONEXContainer)
-                handler_instance: ProtocolContainerAware = handler_cls(
-                    container=container
-                )
+                # Handlers that support OMN-1732 can accept optional dependencies parameter
+                handler_instance: ProtocolContainerAware
+                if resolved_dependencies and self._accepts_dependencies_param(
+                    handler_cls
+                ):
+                    # New-style handler with dependency injection
+                    # Type ignore: handler_cls is typed as ProtocolContainerAware which doesn't
+                    # have dependencies param, but runtime introspection confirmed it exists
+                    handler_instance = handler_cls(  # type: ignore[call-arg]
+                        container=container,
+                        dependencies=resolved_dependencies,
+                    )
+                    logger.debug(
+                        "Instantiated handler with resolved dependencies",
+                        extra={
+                            "handler_type": handler_type,
+                            "resolved_protocols": list(
+                                resolved_dependencies.protocols.keys()
+                            ),
+                        },
+                    )
+                else:
+                    # Legacy handler without dependency parameter
+                    handler_instance = handler_cls(container=container)
 
                 # Call initialize() if the handler has this method
                 # Handlers may require async initialization with config
@@ -1814,7 +1857,6 @@ class RuntimeHostProcess:
                     config_source = "runtime_only"
 
                     # Layer 1: Contract config as baseline (if descriptor exists with config)
-                    descriptor = self._handler_descriptors.get(handler_type)
                     if descriptor and descriptor.contract_config:
                         effective_config.update(descriptor.contract_config)
                         config_source = "contract_only"
@@ -1890,6 +1932,106 @@ class RuntimeHostProcess:
             },
         )
 
+    async def _resolve_handler_dependencies(
+        self,
+        descriptor: ModelHandlerDescriptor,
+    ) -> ModelResolvedDependencies | None:
+        """Resolve protocol dependencies for a handler from its contract.
+
+        Part of OMN-1903: Runtime dependency injection integration.
+
+        If the handler's contract declares protocol dependencies, this method
+        resolves them from the container's service_registry. Returns None if:
+        - No contract_path in descriptor (opt-in behavior, R3)
+        - Contract has no dependencies section
+
+        Args:
+            descriptor: Handler descriptor containing contract_path.
+
+        Returns:
+            ModelResolvedDependencies with resolved protocols, or None if no
+            dependencies to resolve.
+
+        Raises:
+            ProtocolDependencyResolutionError: If any required protocol cannot
+                be resolved (fail-fast behavior, R2).
+            ProtocolConfigurationError: If contract file cannot be loaded.
+        """
+        # R3: Opt-in behavior - skip if no contract_path
+        if not descriptor.contract_path:
+            logger.debug(
+                "Handler has no contract_path, skipping dependency resolution",
+                extra={"handler_id": descriptor.handler_id},
+            )
+            return None
+
+        # Lazy-create resolver on first use
+        if self._dependency_resolver is None:
+            container = self._get_or_create_container()
+            self._dependency_resolver = ContractDependencyResolver(container)
+
+        # R1: Call resolver with contract path
+        contract_path = Path(descriptor.contract_path)
+        logger.debug(
+            "Resolving dependencies for handler",
+            extra={
+                "handler_id": descriptor.handler_id,
+                "contract_path": str(contract_path),
+            },
+        )
+
+        # R2: Fail-fast on missing protocols (allow_missing=False)
+        resolved = await self._dependency_resolver.resolve_from_path(
+            contract_path,
+            allow_missing=False,
+        )
+
+        if resolved:
+            logger.debug(
+                "Resolved dependencies for handler",
+                extra={
+                    "handler_id": descriptor.handler_id,
+                    "resolved_protocols": list(resolved.protocols.keys()),
+                },
+            )
+        else:
+            logger.debug(
+                "No protocol dependencies in contract",
+                extra={
+                    "handler_id": descriptor.handler_id,
+                    "contract_path": str(contract_path),
+                },
+            )
+
+        return resolved if resolved else None
+
+    def _accepts_dependencies_param(self, handler_cls: type) -> bool:
+        """Check if a handler class accepts 'dependencies' in its constructor.
+
+        Part of OMN-1903: Runtime dependency injection integration.
+
+        Uses introspection to check if the handler's __init__ accepts a
+        'dependencies' keyword argument. This enables gradual migration:
+        - Legacy handlers: __init__(container) - no dependencies param
+        - New handlers: __init__(container, dependencies=...) - receives deps
+
+        Args:
+            handler_cls: The handler class to check.
+
+        Returns:
+            True if the handler accepts 'dependencies' parameter, False otherwise.
+        """
+        import inspect
+
+        try:
+            # Use inspect.signature on the class itself, not __init__
+            # This avoids the "unsound instance access" mypy warning
+            sig = inspect.signature(handler_cls)
+            return "dependencies" in sig.parameters
+        except (ValueError, TypeError):
+            # Cannot inspect signature (e.g., builtin class)
+            return False
+
     async def _load_contract_configs(self, correlation_id: UUID) -> None:
         """Load contract configurations from all discovered contracts.
 
@@ -2919,6 +3061,8 @@ class RuntimeHostProcess:
             dispatch_engine=self._dispatch_engine,
             environment=environment,
             node_name="runtime-host",
+            service=self._node_identity.service,
+            version=self._node_identity.version,
         )
 
         # Wire subscriptions for each handler with a contract

omnibase_infra/runtime/util_version.py

@@ -14,6 +14,7 @@ ModelPolicyKey, and ModelPolicyRegistration.
 
 from __future__ import annotations
 
+from omnibase_core.models.errors import ModelOnexError
 from omnibase_core.models.primitives import ModelSemVer
 
 
@@ -81,9 +82,12 @@ def normalize_version(version: str) -> str:
     expanded_version = ".".join(version_nums)
 
     # Parse with ModelSemVer for validation
+    # Note: ModelSemVer.parse() raises ModelOnexError for invalid versions,
+    # but we also catch ValueError for defensive programming against
+    # potential upstream changes.
     try:
         semver = ModelSemVer.parse(expanded_version)
-    except Exception as e:
+    except (ModelOnexError, ValueError) as e:
         raise ValueError(f"Invalid version format: {e}") from e
 
     result: str = semver.to_string()