port-ocean 0.28.19__py3-none-any.whl → 0.29.1__py3-none-any.whl

port_ocean/core/handlers/webhook/processor_manager.py

@@ -11,11 +11,17 @@ from port_ocean.core.handlers.queue.abstract_queue import AbstractQueue
 from port_ocean.core.integrations.mixins.events import EventsMixin
 from port_ocean.core.integrations.mixins.live_events import LiveEventsMixin
 from port_ocean.exceptions.webhook_processor import WebhookEventNotSupportedError
-from .webhook_event import WebhookEvent, WebhookEventRawResults, LiveEventTimestamp
+from port_ocean.core.handlers.webhook.webhook_event import (
+    WebhookEvent,
+    WebhookEventRawResults,
+    LiveEventTimestamp,
+)
 from port_ocean.context.event import event
 
-
-from .abstract_webhook_processor import AbstractWebhookProcessor
+from port_ocean.core.handlers.webhook.abstract_webhook_processor import (
+    AbstractWebhookProcessor,
+    WebhookProcessorType,
+)
 from port_ocean.utils.signal import SignalHandler
 from port_ocean.core.handlers.queue import LocalQueue
 
@@ -56,7 +62,7 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
         while True:
             event = None
             matching_processors: List[
-                Tuple[ResourceConfig, AbstractWebhookProcessor]
+                Tuple[ResourceConfig | None, AbstractWebhookProcessor]
             ] = []
             try:
                 event = await queue.get()
@@ -133,16 +139,22 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
 
     async def _extract_matching_processors(
         self, webhook_event: WebhookEvent, path: str
-    ) -> list[tuple[ResourceConfig, AbstractWebhookProcessor]]:
+    ) -> list[tuple[ResourceConfig | None, AbstractWebhookProcessor]]:
         """Find and extract the matching processor for an event"""
 
-        created_processors: list[tuple[ResourceConfig, AbstractWebhookProcessor]] = []
+        created_processors: list[
+            tuple[ResourceConfig | None, AbstractWebhookProcessor]
+        ] = []
         event_processor_names = []
 
         for processor_class in self._processors_classes[path]:
             processor = processor_class(webhook_event.clone())
             if await processor.should_process_event(webhook_event):
                 event_processor_names.append(processor.__class__.__name__)
+                if processor.get_processor_type() == WebhookProcessorType.ACTION:
+                    created_processors.append((None, processor))
+                    continue
+
                 kinds = await processor.get_matching_kinds(webhook_event)
                 for kind in kinds:
                     for resource in event.port_app_config.resources:
@@ -179,7 +191,10 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
         event.set_timestamp(LiveEventTimestamp.FinishedProcessingWithError)
 
     async def _process_single_event(
-        self, processor: AbstractWebhookProcessor, path: str, resource: ResourceConfig
+        self,
+        processor: AbstractWebhookProcessor,
+        path: str,
+        resource: ResourceConfig | None,
     ) -> WebhookEventRawResults:
         """Process a single event with a specific processor"""
         try:
@@ -199,7 +214,7 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
             raise
 
     async def _execute_processor(
-        self, processor: AbstractWebhookProcessor, resource: ResourceConfig
+        self, processor: AbstractWebhookProcessor, resource: ResourceConfig | None
     ) -> WebhookEventRawResults:
         """Execute a single processor within a max processing time"""
         try:
@@ -213,7 +228,7 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
             )
 
     async def _process_webhook_request(
-        self, processor: AbstractWebhookProcessor, resource: ResourceConfig
+        self, processor: AbstractWebhookProcessor, resource: ResourceConfig | None
     ) -> WebhookEventRawResults:
         """Process a webhook request with retry logic
 
@@ -235,9 +250,10 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
         while True:
             try:
                 webhook_event_raw_results = await processor.handle_event(
-                    payload, resource
+                    payload, resource  # type: ignore[arg-type]
                 )
-                webhook_event_raw_results.resource = resource
+                if resource is not None:
+                    webhook_event_raw_results.resource = resource
                 break
 
             except Exception as e:
@@ -258,7 +274,9 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
         return webhook_event_raw_results
 
     def register_processor(
-        self, path: str, processor: Type[AbstractWebhookProcessor]
+        self,
+        path: str,
+        processor: Type[AbstractWebhookProcessor],
     ) -> None:
         """Register a webhook processor for a specific path with optional filter
 

port_ocean/core/integrations/mixins/sync_raw.py

@@ -24,7 +24,7 @@ from port_ocean.core.integrations.mixins.utils import (
     resync_generator_wrapper,
     resync_function_wrapper,
 )
-from port_ocean.core.models import Entity, ProcessExecutionMode
+from port_ocean.core.models import Entity, IntegrationFeatureFlag, ProcessExecutionMode
 from port_ocean.core.ocean_types import (
     RAW_RESULT,
     RESYNC_RESULT,
@@ -478,7 +478,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             bool: True if lakehouse data is enabled, False otherwise
         """
         flags = await ocean.port_client.get_organization_feature_flags()
-        if "LAKEHOUSE_ELIGIBLE" in flags and ocean.config.lakehouse_enabled:
+        if IntegrationFeatureFlag.LAKEHOUSE_ELIGIBLE in flags and ocean.config.lakehouse_enabled:
             return True
         return False
 

port_ocean/core/models.py

@@ -1,11 +1,19 @@
 from dataclasses import dataclass, field
 from enum import Enum, StrEnum
-from typing import Any, TypedDict
-
+from typing import Any, Literal, TypedDict
 from pydantic import BaseModel
 from pydantic.fields import Field
 
 
+class EventListenerType(StrEnum):
+    WEBHOOK = "WEBHOOK"
+    KAFKA = "KAFKA"
+    POLLING = "POLLING"
+    ONCE = "ONCE"
+    WEBHOOKS_ONLY = "WEBHOOKS_ONLY"
+    ACTIONS_ONLY = "ACTIONS_ONLY"
+
+
 class CreatePortResourcesOrigin(StrEnum):
     Ocean = "Ocean"
     Port = "Port"
@@ -121,3 +129,28 @@ class EntityPortDiff:
     deleted: list[Entity] = field(default_factory=list)
     modified: list[Entity] = field(default_factory=list)
     created: list[Entity] = field(default_factory=list)
+
+
+class IntegrationFeatureFlag(StrEnum):
+    USE_PROVISIONED_DEFAULTS = "USE_PROVISIONED_DEFAULTS"
+    LAKEHOUSE_ELIGIBLE = "LAKEHOUSE_ELIGIBLE"
+    OCEAN_ACTIONS_PROCESSING_ENABLED = "OCEAN_ACTIONS_PROCESSING_ENABLED"
+
+
+class RunStatus(StrEnum):
+    IN_PROGRESS = "IN_PROGRESS"
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"
+
+
+class IntegrationActionInvocationPayload(BaseModel):
+    type: Literal["INTEGRATION_ACTION"]
+    installationId: str
+    integrationActionType: str
+    integrationActionExecutionProperties: dict[str, Any] = Field(default_factory=dict)
+
+
+class ActionRun(BaseModel):
+    id: str
+    status: RunStatus
+    payload: IntegrationActionInvocationPayload

port_ocean/exceptions/execution_manager.py

@@ -0,0 +1,22 @@
+class DuplicateActionExecutorError(Exception):
+    """
+    Raised when attempting to register an executor for an action that already has an existing executor.
+    """
+
+    pass
+
+
+class RunAlreadyAcknowledgedError(Exception):
+    """
+    Raised when attempting to acknowledge a run that has already been acknowledged.
+    """
+
+    pass
+
+
+class PartitionKeyNotFoundError(Exception):
+    """
+    Raised when attempting to extract a partition key that is not found in the invocation payload.
+    """
+
+    pass

port_ocean/ocean.py

@@ -26,6 +26,7 @@ from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
 from port_ocean.core.handlers.webhook.processor_manager import (
     LiveEventsProcessorManager,
 )
+from port_ocean.core.handlers.actions.execution_manager import ExecutionManager
 from port_ocean.core.integrations.base import BaseIntegration
 from port_ocean.core.models import ProcessExecutionMode
 from port_ocean.log.sensetive import sensitive_log_filter
@@ -88,6 +89,16 @@ class Ocean:
             max_wait_seconds_before_shutdown=self.config.max_wait_seconds_before_shutdown,
         )
 
+        self.execution_manager = ExecutionManager(
+            webhook_manager=self.webhook_manager,
+            signal_handler=signal_handler,
+            workers_count=self.config.actions_processor.workers_count,
+            runs_buffer_high_watermark=self.config.actions_processor.runs_buffer_high_watermark,
+            poll_check_interval_seconds=self.config.actions_processor.poll_check_interval_seconds,
+            visibility_timeout_ms=self.config.actions_processor.visibility_timeout_ms,
+            max_wait_seconds_before_shutdown=self.config.max_wait_seconds_before_shutdown,
+        )
+
         self.integration = (
             integration_class(ocean) if integration_class else BaseIntegration(ocean)
         )
@@ -200,6 +211,24 @@ class Ocean:
                 )
         return None
 
+    async def _register_addons(self) -> None:
+        if self.base_url and self.config.event_listener.should_process_webhooks:
+            await self.webhook_manager.start_processing_event_messages()
+        else:
+            logger.warning(
+                "No base URL provided, or webhook processing is disabled is this event listener, skipping webhook processing"
+            )
+
+        if (
+            self.config.actions_processor.enabled
+            and self.config.event_listener.should_run_actions
+        ):
+            await self.execution_manager.start_processing_action_runs()
+        else:
+            logger.warning(
+                "Execution agent is not enabled, or actions processing is disabled in this event listener, skipping execution agent setup"
+            )
+
     def initialize_app(self) -> None:
         self.fast_api_app.include_router(self.integration_router, prefix="/integration")
         self.fast_api_app.include_router(
@@ -210,10 +239,7 @@ class Ocean:
         async def lifecycle(_: FastAPI) -> AsyncIterator[None]:
             try:
                 await self.integration.start()
-                if self.base_url:
-                    await self.webhook_manager.start_processing_event_messages()
-                else:
-                    logger.warning("No base URL provided, skipping webhook processing")
+                await self._register_addons()
                 await self._setup_scheduled_resync()
                 yield None
             except Exception:

port_ocean/tests/core/event_listener/test_kafka.py

@@ -1,11 +1,12 @@
 from port_ocean.core.event_listener.kafka import KafkaEventListenerSettings
+from port_ocean.core.models import EventListenerType
 import pytest
 from pydantic import ValidationError
 
 
 def test_default_kafka_settings() -> None:
     """Test default values are properly set"""
-    config = KafkaEventListenerSettings(type="KAFKA")
+    config = KafkaEventListenerSettings(type=EventListenerType.KAFKA)
     assert config.type == "KAFKA"
     assert config.security_protocol == "SASL_SSL"
     assert config.authentication_mechanism == "SCRAM-SHA-512"
@@ -17,28 +18,32 @@ def test_default_kafka_settings() -> None:
 def test_brokers_json_array_parsing() -> None:
     """Test that JSON array strings get converted to comma-separated"""
     json_brokers = '["broker1:9092", "broker2:9092", "broker3:9092"]'
-    config = KafkaEventListenerSettings(type="KAFKA", brokers=json_brokers)
+    config = KafkaEventListenerSettings(
+        type=EventListenerType.KAFKA, brokers=json_brokers
+    )
     assert config.brokers == "broker1:9092,broker2:9092,broker3:9092"
 
 
 def test_brokers_regular_string_unchanged() -> None:
     """Test that regular comma-separated strings pass through unchanged"""
     regular_brokers = "broker1:9092,broker2:9092"
-    config = KafkaEventListenerSettings(type="KAFKA", brokers=regular_brokers)
+    config = KafkaEventListenerSettings(
+        type=EventListenerType.KAFKA, brokers=regular_brokers
+    )
     assert config.brokers == regular_brokers
 
 
 def test_brokers_malformed_json_unchanged() -> None:
     """Test that malformed JSON strings don't break validation"""
     bad_json = "[broker1:9092, broker2:9092"
-    config = KafkaEventListenerSettings(type="KAFKA", brokers=bad_json)
+    config = KafkaEventListenerSettings(type=EventListenerType.KAFKA, brokers=bad_json)
     assert config.brokers == bad_json
 
 
 def test_custom_values() -> None:
     """Test overriding default values"""
     config = KafkaEventListenerSettings(
-        type="KAFKA",
+        type=EventListenerType.KAFKA,
         brokers="custom:9092",
         security_protocol="PLAINTEXT",
         authentication_mechanism="PLAIN",
@@ -60,11 +65,13 @@ def test_type_literal_validation() -> None:
 
 def test_empty_brokers_array() -> None:
     """Test empty JSON array becomes empty string"""
-    config = KafkaEventListenerSettings(type="KAFKA", brokers="[]")
+    config = KafkaEventListenerSettings(type=EventListenerType.KAFKA, brokers="[]")
     assert config.brokers == ""
 
 
 def test_single_broker_array() -> None:
     """Test single broker in JSON array"""
-    config = KafkaEventListenerSettings(type="KAFKA", brokers='["single:9092"]')
+    config = KafkaEventListenerSettings(
+        type=EventListenerType.KAFKA, brokers='["single:9092"]'
+    )
     assert config.brokers == "single:9092"