port-ocean 0.20.3__tar.gz → 0.21.0__tar.gz

{port_ocean-0.20.3 → port_ocean-0.21.0}/PKG-INFO

@@ -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 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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-0.21.0/port_ocean/core/integrations/mixins/events.py

@@ -0,0 +1,71 @@
+from collections import defaultdict
+from typing import Any
+
+from loguru import logger
+
+from port_ocean.core.ocean_types import (
+    IntegrationEventsCallbacks,
+    START_EVENT_LISTENER,
+    RESYNC_EVENT_LISTENER,
+    BEFORE_RESYNC_EVENT_LISTENER,
+    AFTER_RESYNC_EVENT_LISTENER,
+)
+
+
+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 various lifecycle events.
+
+    Attributes:
+        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, 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, 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
+
+    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
+
+    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-0.20.3 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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-0.20.3 → port_ocean-0.21.0}/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"]