port-ocean 0.20.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

port_ocean/cli/cookiecutter/hooks/post_gen_project.py

@@ -8,7 +8,7 @@ def handle_private_integration_flags():
     )
     root_dir = os.path.join("{{ cookiecutter._repo_dir }}", "../../../")
     infra_make_file = os.path.join(root_dir, "integrations/_infra/Makefile")
-    infra_dockerfile = os.path.join(root_dir, "integrations/_infra/Dockerfile.deb")
+    infra_dockerfile = os.path.join(root_dir, "integrations/_infra/Dockerfile.Deb")
     infra_dockerignore = os.path.join(
         root_dir, "integrations/_infra/Dockerfile.dockerignore"
     )

port_ocean/context/event.py

@@ -182,9 +182,14 @@ async def event_context(
                 f"Skipping resync due to empty mapping: {str(e)}", exc_info=True
             )
             raise
-        except Exception as e:
+        except BaseException as e:
             success = False
-            logger.error(f"Event failed with error: {str(e)}", exc_info=True)
+            if isinstance(e, KeyboardInterrupt):
+                logger.warning("Operation interrupted by user", exc_info=True)
+            elif isinstance(e, asyncio.CancelledError):
+                logger.warning("Operation was cancelled", exc_info=True)
+            else:
+                logger.error(f"Event failed with error: {repr(e)}", exc_info=True)
             raise
         else:
             success = True

port_ocean/context/ocean.py

@@ -12,6 +12,8 @@ from port_ocean.core.ocean_types import (
     START_EVENT_LISTENER,
     RawEntityDiff,
     EntityDiff,
+    BEFORE_RESYNC_EVENT_LISTENER,
+    AFTER_RESYNC_EVENT_LISTENER,
 )
 from port_ocean.exceptions.context import (
     PortOceanContextNotFoundError,
@@ -80,7 +82,7 @@ class PortOceanContext:
         ) -> RESYNC_EVENT_LISTENER | None:
             if not self.app.config.event_listener.should_resync:
                 logger.debug(
-                    "Webhook only event listener is used, resync events are ignored"
+                    f"Using event listener {self.app.config.event_listener.type}, which shouldn't perform any resyncs. Skipping resyncs setup..."
                 )
                 return None
             return self.integration.on_resync(function, kind)
@@ -93,6 +95,40 @@ class PortOceanContext:
 
         return wrapper
 
+    def on_resync_start(
+        self,
+    ) -> Callable[
+        [BEFORE_RESYNC_EVENT_LISTENER | None], BEFORE_RESYNC_EVENT_LISTENER | None
+    ]:
+        def wrapper(
+            function: BEFORE_RESYNC_EVENT_LISTENER | None,
+        ) -> BEFORE_RESYNC_EVENT_LISTENER | None:
+            if not self.app.config.event_listener.should_resync:
+                logger.debug(
+                    f"Using event listener {self.app.config.event_listener.type}, which shouldn't perform any resyncs. Skipping resyncs setup..."
+                )
+                return None
+            return self.integration.on_resync_start(function)
+
+        return wrapper
+
+    def on_resync_complete(
+        self,
+    ) -> Callable[
+        [AFTER_RESYNC_EVENT_LISTENER | None], AFTER_RESYNC_EVENT_LISTENER | None
+    ]:
+        def wrapper(
+            function: AFTER_RESYNC_EVENT_LISTENER | None,
+        ) -> AFTER_RESYNC_EVENT_LISTENER | None:
+            if not self.app.config.event_listener.should_resync:
+                logger.debug(
+                    f"Using event listener {self.app.config.event_listener.type}, which shouldn't perform any resyncs. Skipping resyncs setup..."
+                )
+                return None
+            return self.integration.on_resync_complete(function)
+
+        return wrapper
+
     async def update_raw_diff(
         self,
         kind: str,

port_ocean/core/handlers/webhook/abstract_webhook_processor.py

@@ -109,9 +109,9 @@ class AbstractWebhookProcessor(ABC):
         pass
 
     @abstractmethod
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         pass
 
     @abstractmethod
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         pass

port_ocean/core/handlers/webhook/processor_manager.py

@@ -47,7 +47,7 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
             except Exception as e:
                 logger.exception(f"Error starting queue processor for {path}: {str(e)}")
 
-    def _extract_matching_processors(
+    async def _extract_matching_processors(
         self, webhook_event: WebhookEvent, path: str
     ) -> list[tuple[ResourceConfig, AbstractWebhookProcessor]]:
         """Find and extract the matching processor for an event"""
@@ -56,8 +56,8 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
 
         for processor_class in self._processors_classes[path]:
             processor = processor_class(webhook_event.clone())
-            if processor.should_process_event(webhook_event):
-                kinds = processor.get_matching_kinds(webhook_event)
+            if await processor.should_process_event(webhook_event):
+                kinds = await processor.get_matching_kinds(webhook_event)
                 for kind in kinds:
                     for resource in event.port_app_config.resources:
                         if resource.kind == kind:
@@ -92,26 +92,30 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
                         parent_override=webhook_event.event_context,
                     ):
                         matching_processors_with_resource = (
-                            self._extract_matching_processors(webhook_event, path)
+                            await self._extract_matching_processors(webhook_event, path)
                         )
                         webhook_event_raw_results_for_all_resources = await asyncio.gather(
                             *(
                                 self._process_single_event(processor, path, resource)
                                 for resource, processor in matching_processors_with_resource
-                            )
+                            ),
+                            return_exceptions=True,
                         )
-                        if webhook_event_raw_results_for_all_resources and all(
-                            webhook_event_raw_results_for_all_resources
-                        ):
+
+                        successful_raw_results: list[WebhookEventRawResults] = [
+                            result
+                            for result in webhook_event_raw_results_for_all_resources
+                            if isinstance(result, WebhookEventRawResults)
+                        ]
+
+                        if successful_raw_results:
                             logger.info(
                                 "Exporting raw event results to entities",
                                 webhook_event_raw_results_for_all_resources_length=len(
-                                    webhook_event_raw_results_for_all_resources
+                                    successful_raw_results
                                 ),
                             )
-                            await self.sync_raw_results(
-                                webhook_event_raw_results_for_all_resources
-                            )
+                            await self.sync_raw_results(successful_raw_results)
             except asyncio.CancelledError:
                 logger.info(f"Queue processor for {path} is shutting down")
                 for _, processor in matching_processors_with_resource:

port_ocean/core/integrations/mixins/events.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from typing import Any
 
 from loguru import logger
 
@@ -6,6 +7,8 @@ from port_ocean.core.ocean_types import (
     IntegrationEventsCallbacks,
     START_EVENT_LISTENER,
     RESYNC_EVENT_LISTENER,
+    BEFORE_RESYNC_EVENT_LISTENER,
+    AFTER_RESYNC_EVENT_LISTENER,
 )
 
 
@@ -13,55 +16,56 @@ class EventsMixin:
     """A mixin class that provides event handling capabilities for the integration class.
 
     This mixin allows classes to register event listeners and manage event callbacks.
-    It provides methods for attaching listeners to "start" and "resync" events.
+    It provides methods for attaching listeners to various lifecycle events.
 
     Attributes:
-        event_strategy (IntegrationEventsCallbacks): A dictionary storing event callbacks.
-            - "start": List of functions to be called on "start" event.
-            - "resync": Default dictionary mapping event kinds to lists of functions
-                        to be called on "resync" events of the specified kind.
+        event_strategy: A dictionary storing event callbacks for different event types.
     """
 
     def __init__(self) -> None:
         self.event_strategy: IntegrationEventsCallbacks = {
             "start": [],
             "resync": defaultdict(list),
+            "resync_start": [],
+            "resync_complete": [],
         }
 
     @property
     def available_resync_kinds(self) -> list[str]:
         return list(self.event_strategy["resync"].keys())
 
-    def on_start(self, func: START_EVENT_LISTENER) -> START_EVENT_LISTENER:
-        """Register a function as a listener for the "start" event.
-
-        Args:
-            func (START_EVENT_LISTENER): The function to be called on the "start" event.
-
-        Returns:
-            START_EVENT_LISTENER: The input function, unchanged.
-        """
-        logger.debug(f"Registering {func} as a start event listener")
-        self.event_strategy["start"].append(func)
-        return func
+    def on_start(self, function: START_EVENT_LISTENER) -> START_EVENT_LISTENER:
+        """Register a function as a listener for the "start" event."""
+        logger.debug(f"Registering {function} as a start event listener")
+        self.event_strategy["start"].append(function)
+        return function
 
     def on_resync(
-        self, func: RESYNC_EVENT_LISTENER| None, kind: str | None = None
-    ) -> RESYNC_EVENT_LISTENER:
-        """Register a function as a listener for a "resync" event.
+        self, function: RESYNC_EVENT_LISTENER | None, kind: str | None = None
+    ) -> RESYNC_EVENT_LISTENER | None:
+        """Register a function as a listener for a "resync" event."""
+        if function is not None:
+            if kind is None:
+                logger.debug("Registering resync event listener any kind")
+            else:
+                logger.info(f"Registering resync event listener for kind {kind}")
+            self.event_strategy["resync"][kind].append(function)
+        return function
 
-        Args:
-            func (RESYNC_EVENT_LISTENER): The function to be called on the "resync" event.
-            kind (str | None, optional): The kind of "resync" event. Defaults to None.
+    def on_resync_start(
+        self, function: BEFORE_RESYNC_EVENT_LISTENER | None
+    ) -> BEFORE_RESYNC_EVENT_LISTENER | None:
+        """Register a function to be called when a resync operation starts."""
+        if function is not None:
+            logger.debug(f"Registering {function} as a resync_start event listener")
+            self.event_strategy["resync_start"].append(function)
+        return function
 
-        Returns:
-            RESYNC_EVENT_LISTENER: The input function, unchanged.
-        """
-        if func is None:
-            return None
-        if kind is None:
-            logger.debug(f"Registering resync event listener any kind")
-        else:
-            logger.info(f"Registering resync event listener for kind {kind}")
-        self.event_strategy["resync"][kind].append(func)
-        return func
+    def on_resync_complete(
+        self, function: AFTER_RESYNC_EVENT_LISTENER | None
+    ) -> AFTER_RESYNC_EVENT_LISTENER | None:
+        """Register a function to be called when a resync operation completes."""
+        if function is not None:
+            logger.debug(f"Registering {function} as a resync_complete event listener")
+            self.event_strategy["resync_complete"].append(function)
+        return function

port_ocean/core/integrations/mixins/sync_raw.py

@@ -550,6 +550,10 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             )
             logger.info(f"Resync will use the following mappings: {app_config.dict()}")
 
+            # Execute resync_start hooks
+            for resync_start_fn in self.event_strategy["resync_start"]:
+                await resync_start_fn()
+
             try:
                 did_fetched_current_state = True
             except httpx.HTTPError as e:
@@ -598,7 +602,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 if errors:
                     message = f"Resync failed with {len(errors)}. Skipping delete phase due to incomplete state"
                     error_group = ExceptionGroup(
-                        f"Resync failed with {len(errors)}. Skipping delete phase due to incomplete state",
+                        message,
                         errors,
                     )
                     if not silent:
@@ -618,3 +622,12 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     )
 
                     logger.info("Resync finished successfully")
+
+                    # Execute resync_complete hooks
+                    if "resync_complete" in self.event_strategy:
+                        logger.info("Executing resync_complete hooks")
+
+                        for resync_complete_fn in self.event_strategy["resync_complete"]:
+                            await resync_complete_fn()
+
+                        logger.info("Finished executing resync_complete hooks")

port_ocean/core/ocean_types.py

@@ -19,6 +19,9 @@ LISTENER_RESULT = Awaitable[RAW_RESULT] | ASYNC_GENERATOR_RESYNC_TYPE
 RESYNC_EVENT_LISTENER = Callable[[str], LISTENER_RESULT]
 START_EVENT_LISTENER = Callable[[], Awaitable[None]]
 
+BEFORE_RESYNC_EVENT_LISTENER = Callable[[], Awaitable[None]]
+AFTER_RESYNC_EVENT_LISTENER = Callable[[], Awaitable[None]]
+
 
 class RawEntityDiff(TypedDict):
     before: list[RAW_ITEM]
@@ -44,3 +47,5 @@ class CalculationResult(NamedTuple):
 class IntegrationEventsCallbacks(TypedDict):
     start: list[START_EVENT_LISTENER]
     resync: dict[str | None, list[RESYNC_EVENT_LISTENER]]
+    resync_start: list[BEFORE_RESYNC_EVENT_LISTENER]
+    resync_complete: list[AFTER_RESYNC_EVENT_LISTENER]

port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -799,3 +799,177 @@ async def test_register_resource_raw_skip_event_type_http_request_upsert_called_
         mock_sync_raw_mixin._calculate_raw.assert_called_once()
         mock_sync_raw_mixin._map_entities_compared_with_port.assert_not_called()
         mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_on_resync_start_hooks_are_called(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Setup
+    resync_start_called = False
+
+    async def on_resync_start() -> None:
+        nonlocal resync_start_called
+        resync_start_called = True
+
+    mock_sync_raw_mixin.on_resync_start(on_resync_start)
+
+    # Execute
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+        await mock_sync_raw_mixin.sync_raw_all(
+            trigger_type="machine",
+            user_agent_type=UserAgentType.exporter,
+        )
+
+    # Verify
+    assert resync_start_called, "on_resync_start hook was not called"
+
+
+@pytest.mark.asyncio
+async def test_on_resync_complete_hooks_are_called_on_success(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_port_app_config: PortAppConfig,
+    mock_ocean: Ocean,
+) -> None:
+    # Setup
+    resync_complete_called = False
+
+    async def on_resync_complete() -> None:
+        nonlocal resync_complete_called
+        resync_complete_called = True
+
+    mock_sync_raw_mixin.on_resync_complete(on_resync_complete)
+    mock_ocean.port_client.search_entities.return_value = []  # type: ignore
+
+    # Execute
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+        await mock_sync_raw_mixin.sync_raw_all(
+            trigger_type="machine",
+            user_agent_type=UserAgentType.exporter,
+        )
+
+    # Verify
+    assert resync_complete_called, "on_resync_complete hook was not called"
+
+
+@pytest.mark.asyncio
+async def test_on_resync_complete_hooks_not_called_on_error(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Setup
+    resync_complete_called = False
+
+    async def on_resync_complete() -> None:
+        nonlocal resync_complete_called
+        resync_complete_called = True
+
+    mock_sync_raw_mixin.on_resync_complete(on_resync_complete)
+    mock_sync_raw_mixin._get_resource_raw_results.side_effect = Exception("Test error")  # type: ignore
+
+    # Execute
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+        with pytest.raises(Exception):
+            await mock_sync_raw_mixin.sync_raw_all(
+                trigger_type="machine",
+                user_agent_type=UserAgentType.exporter,
+            )
+
+    # Verify
+    assert (
+        not resync_complete_called
+    ), "on_resync_complete hook should not have been called on error"
+
+
+@pytest.mark.asyncio
+async def test_multiple_on_resync_start_on_resync_complete_hooks_called_in_order(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_port_app_config: PortAppConfig,
+    mock_ocean: Ocean,
+) -> None:
+    # Setup
+    call_order: list[str] = []
+
+    async def on_resync_start1() -> None:
+        call_order.append("on_resync_start1")
+
+    async def on_resync_start2() -> None:
+        call_order.append("on_resync_start2")
+
+    async def on_resync_complete1() -> None:
+        call_order.append("on_resync_complete1")
+
+    async def on_resync_complete2() -> None:
+        call_order.append("on_resync_complete2")
+
+    mock_sync_raw_mixin.on_resync_start(on_resync_start1)
+    mock_sync_raw_mixin.on_resync_start(on_resync_start2)
+    mock_sync_raw_mixin.on_resync_complete(on_resync_complete1)
+    mock_sync_raw_mixin.on_resync_complete(on_resync_complete2)
+    mock_ocean.port_client.search_entities.return_value = []  # type: ignore
+
+    # Execute
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+        await mock_sync_raw_mixin.sync_raw_all(
+            trigger_type="machine",
+            user_agent_type=UserAgentType.exporter,
+        )
+
+    # Verify
+    assert call_order == [
+        "on_resync_start1",
+        "on_resync_start2",
+        "on_resync_complete1",
+        "on_resync_complete2",
+    ], "Hooks were not called in the correct order"
+
+
+@pytest.mark.asyncio
+async def test_on_resync_start_hook_error_prevents_resync(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Setup
+    resync_complete_called = False
+    resync_proceeded = False
+
+    async def on_resync_start() -> None:
+        raise Exception("Before resync error")
+
+    async def on_resync_complete() -> None:
+        nonlocal resync_complete_called
+        resync_complete_called = True
+
+    mock_sync_raw_mixin.on_resync_start(on_resync_start)
+    mock_sync_raw_mixin.on_resync_complete(on_resync_complete)
+
+    original_get_resource_raw_results = mock_sync_raw_mixin._get_resource_raw_results
+
+    async def track_resync(*args: Any, **kwargs: Any) -> Any:
+        nonlocal resync_proceeded
+        resync_proceeded = True
+        return await original_get_resource_raw_results(*args, **kwargs)
+
+    mock_sync_raw_mixin._get_resource_raw_results = track_resync  # type: ignore
+
+    # Execute
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+        with pytest.raises(Exception, match="Before resync error"):
+            await mock_sync_raw_mixin.sync_raw_all(
+                trigger_type="machine",
+                user_agent_type=UserAgentType.exporter,
+            )
+
+    # Verify
+    assert (
+        not resync_proceeded
+    ), "Resync should not have proceeded after before_resync hook error"
+    assert (
+        not resync_complete_called
+    ), "on_resync_complete hook should not have been called after error"

port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py

@@ -32,7 +32,7 @@ class ConcreteWebhookProcessor(AbstractWebhookProcessor):
     ) -> WebhookEventRawResults:
         return WebhookEventRawResults(updated_raw_results=[{}], deleted_raw_results=[])
 
-    def should_process_event(self, webhook_event: WebhookEvent) -> bool:
+    async def should_process_event(self, webhook_event: WebhookEvent) -> bool:
         return True
 
     async def before_processing(self) -> None:
@@ -47,7 +47,7 @@ class ConcreteWebhookProcessor(AbstractWebhookProcessor):
         await super().cancel()
         self.cancel_called = True
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["test"]
 
 

port_ocean/tests/core/handlers/webhook/test_processor_manager.py

@@ -54,10 +54,10 @@ class MockProcessor(AbstractWebhookProcessor):
     ) -> WebhookEventRawResults:
         return WebhookEventRawResults(updated_raw_results=[], deleted_raw_results=[])
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         return True
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["repository"]
 
 
@@ -75,10 +75,10 @@ class MockProcessorFalse(AbstractWebhookProcessor):
     ) -> WebhookEventRawResults:
         return WebhookEventRawResults(updated_raw_results=[], deleted_raw_results=[])
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         return False
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["repository"]
 
 
@@ -110,10 +110,10 @@ class MockWebhookProcessor(AbstractWebhookProcessor):
     async def cancel(self) -> None:
         self.cancel_called = True
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         return True
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["test"]
 
 
@@ -155,10 +155,10 @@ class MockWebhookHandlerForProcessWebhookRequest(AbstractWebhookProcessor):
         self.handled = True
         return WebhookEventRawResults(updated_raw_results=[], deleted_raw_results=[])
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["repository"]
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         """Filter the event data before processing."""
         return True
 
@@ -329,16 +329,16 @@ async def test_extractMatchingProcessors_processorMatch(
 
     async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
         event.port_app_config = mock_port_app_config
-        processors = processor_manager._extract_matching_processors(
+        processors = await processor_manager._extract_matching_processors(
             webhook_event, test_path
         )
 
-    assert len(processors) == 1
-    config, processor = processors[0]
-    assert isinstance(processor, MockProcessor)
-    assert config.kind == "repository"
-    assert processor.event != webhook_event
-    assert processor.event.payload == webhook_event.payload
+        assert len(processors) == 1
+        config, processor = processors[0]
+        assert isinstance(processor, MockProcessor)
+        assert config.kind == "repository"
+        assert processor.event != webhook_event
+        assert processor.event.payload == webhook_event.payload
 
 
 @pytest.mark.asyncio
@@ -355,7 +355,9 @@ async def test_extractMatchingProcessors_noMatch(
             EventType.HTTP_REQUEST, trigger_type="request"
         ) as event:
             event.port_app_config = mock_port_app_config
-            processor_manager._extract_matching_processors(webhook_event, test_path)
+            await processor_manager._extract_matching_processors(
+                webhook_event, test_path
+            )
 
 
 @pytest.mark.asyncio
@@ -370,7 +372,7 @@ async def test_extractMatchingProcessors_multipleMatches(
 
     async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
         event.port_app_config = mock_port_app_config
-        processors = processor_manager._extract_matching_processors(
+        processors = await processor_manager._extract_matching_processors(
             webhook_event, test_path
         )
 
@@ -391,7 +393,7 @@ async def test_extractMatchingProcessors_onlyOneMatches(
 
     async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
         event.port_app_config = mock_port_app_config
-        processors = processor_manager._extract_matching_processors(
+        processors = await processor_manager._extract_matching_processors(
             webhook_event, test_path
         )
 
@@ -542,10 +544,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessed_en
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -649,10 +651,10 @@ async def test_integrationTest_postRequestSent_reachedTimeout_entityNotUpserted(
                 updated_raw_results=[], deleted_raw_results=[]
             )
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -766,20 +768,20 @@ async def test_integrationTest_postRequestSent_noMatchingHandlers_entityNotUpser
             )
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return False
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
     original_process_data = LiveEventsProcessorManager._extract_matching_processors
 
-    def patched_extract_matching_processors(
+    async def patched_extract_matching_processors(
         self: LiveEventsProcessorManager, event: WebhookEvent, path: str
     ) -> list[tuple[ResourceConfig, AbstractWebhookProcessor]]:
         try:
-            return original_process_data(self, event, path)
+            return await original_process_data(self, event, path)
         except Exception as e:
             test_state["exception_thrown"] = e  # type: ignore
             return []
@@ -882,10 +884,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     class TestProcessorB(AbstractWebhookProcessor):
@@ -913,10 +915,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     class TestProcessorFiltersOut(AbstractWebhookProcessor):
@@ -944,10 +946,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return False
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -1071,10 +1073,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -1195,10 +1197,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -1262,3 +1264,139 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
     mock_delete.assert_not_called()
 
     await mock_context.app.webhook_manager.shutdown()
+
+
+@pytest.mark.asyncio
+@patch(
+    "port_ocean.core.handlers.entities_state_applier.port.applier.HttpEntitiesStateApplier.upsert"
+)
+@patch(
+    "port_ocean.core.handlers.entities_state_applier.port.applier.HttpEntitiesStateApplier.delete"
+)
+async def test_integrationTest_postRequestSent_oneProcessorThrowsException_onlySuccessfulResultsProcessed(
+    mock_delete: AsyncMock,
+    mock_upsert: AsyncMock,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Integration test for webhook processing where one processor throws an exception"""
+
+    monkeypatch.setattr(
+        "port_ocean.core.integrations.mixins.handler.ocean", mock_context
+    )
+    monkeypatch.setattr(
+        "port_ocean.core.integrations.mixins.live_events.ocean", mock_context
+    )
+    processed_events: list[WebhookEventRawResults] = []
+    mock_upsert.return_value = [entity]
+
+    class SuccessfulProcessor(AbstractWebhookProcessor):
+        async def authenticate(
+            self, payload: Dict[str, Any], headers: Dict[str, str]
+        ) -> bool:
+            return True
+
+        async def validate_payload(self, payload: Dict[str, Any]) -> bool:
+            return True
+
+        async def handle_event(
+            self, payload: EventPayload, resource: ResourceConfig
+        ) -> WebhookEventRawResults:
+            event_data = WebhookEventRawResults(
+                updated_raw_results=[
+                    {
+                        "name": "repo-one",
+                        "links": {"html": {"href": "https://example.com/repo-one"}},
+                        "main_branch": "main",
+                    }
+                ],
+                deleted_raw_results=[],
+            )
+            processed_events.append(event_data)
+            return event_data
+
+        async def should_process_event(self, event: WebhookEvent) -> bool:
+            return True
+
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+            return ["repository"]
+
+    class FailingProcessor(AbstractWebhookProcessor):
+        async def authenticate(
+            self, payload: Dict[str, Any], headers: Dict[str, str]
+        ) -> bool:
+            return True
+
+        async def validate_payload(self, payload: Dict[str, Any]) -> bool:
+            return True
+
+        async def handle_event(
+            self, payload: EventPayload, resource: ResourceConfig
+        ) -> WebhookEventRawResults:
+            raise ValueError("Simulated failure in processor")
+
+        async def should_process_event(self, event: WebhookEvent) -> bool:
+            return True
+
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+            return ["repository"]
+
+    processing_complete = asyncio.Event()
+    original_process_data = LiveEventsMixin.sync_raw_results
+
+    async def patched_export_single_resource(
+        self: LiveEventsMixin, webhookEventRawResults: list[WebhookEventRawResults]
+    ) -> None:
+        try:
+            await original_process_data(self, webhookEventRawResults)
+        except Exception as e:
+            raise e
+        finally:
+            processing_complete.set()
+
+    monkeypatch.setattr(
+        LiveEventsMixin,
+        "sync_raw_results",
+        patched_export_single_resource,
+    )
+    test_path = "/webhook-test"
+    mock_context.app.integration = BaseIntegration(ocean)
+    mock_context.app.webhook_manager = LiveEventsProcessorManager(
+        mock_context.app.integration_router, SignalHandler()
+    )
+
+    # Register both processors
+    mock_context.app.webhook_manager.register_processor(test_path, SuccessfulProcessor)
+    mock_context.app.webhook_manager.register_processor(test_path, FailingProcessor)
+    await mock_context.app.webhook_manager.start_processing_event_messages()
+    mock_context.app.fast_api_app.include_router(
+        mock_context.app.webhook_manager._router
+    )
+    client = TestClient(mock_context.app.fast_api_app)
+
+    test_payload = {"test": "data"}
+
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
+        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
+        event.port_app_config = (
+            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
+        )
+
+        response = client.post(
+            test_path, json=test_payload, headers={"Content-Type": "application/json"}
+        )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+    try:
+        await asyncio.wait_for(processing_complete.wait(), timeout=10.0)
+    except asyncio.TimeoutError:
+        pytest.fail("Event processing timed out")
+
+    assert len(processed_events) == 1
+    assert mock_upsert.call_count == 1
+    mock_delete.assert_not_called()
+
+    await mock_context.app.webhook_manager.shutdown()

{port_ocean-0.20.3.dist-info → port_ocean-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.20.3
+Version: 0.21.0
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.20.3.dist-info → port_ocean-0.21.0.dist-info}/RECORD

@@ -24,7 +24,7 @@ port_ocean/cli/commands/version.py,sha256=hEuIEIcm6Zkamz41Z9nxeSM_4g3oNlAgWwQyDG
 port_ocean/cli/cookiecutter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/cli/cookiecutter/cookiecutter.json,sha256=ie-LJjg-ek3lP2RRosY2u_q2W4y2TykXm_Gynjjt6Es,814
 port_ocean/cli/cookiecutter/extensions.py,sha256=eQNjZvy2enDkJpvMbBGil77Xk9-38f862wfnmCjdoBc,446
-port_ocean/cli/cookiecutter/hooks/post_gen_project.py,sha256=tFqtsjSbu7HMN32WIiFO37S1a_dfHezvdPwmM6MmNJk,1182
+port_ocean/cli/cookiecutter/hooks/post_gen_project.py,sha256=7DBdSv_vDI1YKW-y7y4wHenu4iF4zV1MukoUT1EgzXI,1182
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.env.example,sha256=ywAmZto6YBGXyhEmpG1uYsgaHr2N1ZBRjdtRNt6Vkpw,388
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.gitignore,sha256=32p1lDW_g5hyBz486GWfDeR9m7ikFlASVri5a8vmNoo,2698
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/resources/.gitignore,sha256=kCpRPdl3S_jqYYZaOrc0-xa6-l3KqVjNRXc6jCkd_-Q,12
@@ -66,8 +66,8 @@ port_ocean/config/settings.py,sha256=PfMwhFQOI0zfK0bD32EunXqicVrlPYBkYC2A99nmZlg
 port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/consumers/kafka_consumer.py,sha256=N8KocjBi9aR0BOPG8hgKovg-ns_ggpEjrSxqSqF_BSo,4710
 port_ocean/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/context/event.py,sha256=QK2ben4fJtxdorq_yRroATttP0DRc4wLtlUJ1as5D58,6208
-port_ocean/context/ocean.py,sha256=Yt3G9CbcmFhxFTdxUhjkiZSfm92VKmzs7m-BMSGaU54,6316
+port_ocean/context/event.py,sha256=pdLBnHl9Ue5Qyyxk_NLVnIizsj9rjFgAt5qzpXq-2yw,6492
+port_ocean/context/ocean.py,sha256=Yt0KP3Rgc4MrLSo3dF0a40ww6ny0r2hDADZ42vTj22M,7750
 port_ocean/context/resource.py,sha256=yDj63URzQelj8zJPh4BAzTtPhpKr9Gw9DRn7I_0mJ1s,1692
 port_ocean/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/defaults/__init__.py,sha256=8qCZg8n06WAdMu9s_FiRtDYLGPGHbOuS60vapeUoAks,142
@@ -103,20 +103,20 @@ port_ocean/core/handlers/queue/local_queue.py,sha256=EzqsGIX43xbVAcePwTcCg5QDrXA
 port_ocean/core/handlers/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
 port_ocean/core/handlers/resync_state_updater/updater.py,sha256=Yg9ET6ZV5B9GW7u6zZA6GlB_71kmvxvYX2FWgQNzMvo,3182
 port_ocean/core/handlers/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=YRMr4M1m0XNZbxNGU0bzB3hEkPat1HCom66EU9NRffU,3879
-port_ocean/core/handlers/webhook/processor_manager.py,sha256=RoPV3cHjAv7jJ_vpC9y2fF2v9eb41h0VM6bNAPuzKdg,11779
+port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=5KwZkdkDd5HdVkXPzKiqabodZKl-hOtMypkTKd8Hq3M,3891
+port_ocean/core/handlers/webhook/processor_manager.py,sha256=Pmg81IT0i3MCFWC6648Ln4NfpAWvpyrPZwOFfdTPkDE,11928
 port_ocean/core/handlers/webhook/webhook_event.py,sha256=Iuw6IX3PPjwHECUeFgrJl6K249mJ-DPAGhP8OMxbc1c,4096
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/integrations/base.py,sha256=eS0WDOfCTim1UOQQrNuP14I6hvT_fr8dof_cr1ls01s,3107
 port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4_RgZnwSRmTCreKcBVM,220
-port_ocean/core/integrations/mixins/events.py,sha256=0jKRsBw6lU8Mqs7MaQK4n-t_H6Z4NEkXZ5VWzqTrKEc,2396
+port_ocean/core/integrations/mixins/events.py,sha256=2L7P3Jhp8XBqddh2_o9Cn4N261nN1SySfrEdJoqLrIw,2714
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/live_events.py,sha256=8HklZmlyffYY_LeDe8xbt3Tb08rlLkqVhFF-2NQeJP4,4126
 port_ocean/core/integrations/mixins/sync.py,sha256=GHiFbnw0XrBfl7aCTH_w67f_N7EZbcUgssc-0fPujNU,4047
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=7kk2p5lLKq9oivqqintZumuaIHSbcSmoUfWrE346l7g,24821
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=RzIQ7fawAeRR8g-ocZ_ChAE6PhZjcTHCq4iMd0T0y3Q,25316
 port_ocean/core/integrations/mixins/utils.py,sha256=oN4Okz6xlaefpid1_Pud8HPSw9BwwjRohyNsknq-Myg,2309
 port_ocean/core/models.py,sha256=FvTp-BlpbvLbMbngE0wsiimsCfmIhUR1PvsE__Z--1I,2206
-port_ocean/core/ocean_types.py,sha256=j_-or1VxDy22whLLxwxgzIsE4wAhFLH19Xff9l4oJA8,1124
+port_ocean/core/ocean_types.py,sha256=onwYMsvdd2_9QmZ7qU6h-t2uF_PTIivpEro0ahevhdw,1354
 port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
 port_ocean/core/utils/utils.py,sha256=HmumOeH27N0NX1_OP3t4oGKt074ht9XyXhvfZ5I05s4,6474
 port_ocean/debug_cli.py,sha256=gHrv-Ey3cImKOcGZpjoHlo4pa_zfmyOl6TUM4o9VtcA,96
@@ -152,12 +152,12 @@ port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcG
 port_ocean/tests/core/handlers/entities_state_applier/test_applier.py,sha256=R9bqyJocUWTh0NW0s-5ttD_SYYeM5EbYILgVmgWa7qA,2776
 port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=FnEnaDjuoAbKvKyv6xJ46n3j0ZcaT70Sg2zc7oy7HAA,13596
 port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=iAwVpr3n3PIkXQLw7hxd-iB_SR_vyfletVXJLOmyz28,12480
-port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=gxQ4e9hQuMS8-o5UbiUSt1I1uaK0DCO3yCFDVigpZvo,31740
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=S1m6SQtlQVr3qD_otHEojj4pR87vICyO9ELNyAEwZRs,37428
 port_ocean/tests/core/handlers/port_app_config/test_api.py,sha256=eJZ6SuFBLz71y4ca3DNqKag6d6HUjNJS0aqQPwiLMTI,1999
 port_ocean/tests/core/handlers/port_app_config/test_base.py,sha256=tdjpFUnUZ6TNMxc3trKkzmMTGTb7oKIeu3rRXv_fV3g,6872
 port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
-port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=lLOVjjUCI973d9Ps_hugWOjyxNgEiPjqZVqN3qC2Rhs,3328
-port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=jwoimtQqrzro2Q2wBUmtKWN2bg9013GRpm7LEPCix80,44109
+port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=zKwHhPAYEZoZ5Z2UETp1t--mbkS8uyvlXThB0obZTTc,3340
+port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=Nb-3VXVRol9fM5pLZQ1iGyPsZcHkWSNGG3bDHWjuR3Y,49285
 port_ocean/tests/core/handlers/webhook/test_webhook_event.py,sha256=oR4dEHLO65mp6rkfNfszZcfFoRZlB8ZWee4XetmsuIk,3181
 port_ocean/tests/core/test_utils.py,sha256=Z3kdhb5V7Svhcyy3EansdTpgHL36TL6erNtU-OPwAcI,2647
 port_ocean/tests/core/utils/test_entity_topological_sorter.py,sha256=zuq5WSPy_88PemG3mOUIHTxWMR_js1R7tOzUYlgBd68,3447
@@ -184,8 +184,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=mMVq-1Ab5YpNiqN4PkiyTGlV_G0wkUDMMjTZp5z3pb0,1514
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.20.3.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.20.3.dist-info/METADATA,sha256=etjLtg8n350AlzlWET_M8HSbFlYiDwx2mb9vYIbihJk,6669
-port_ocean-0.20.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.20.3.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.20.3.dist-info/RECORD,,
+port_ocean-0.21.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.21.0.dist-info/METADATA,sha256=Dq7R51uDPsYbhOUC1gopJD0AY3X_F8kDn-vwrwuOCKY,6669
+port_ocean-0.21.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.21.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.21.0.dist-info/RECORD,,