port-ocean 0.12.2.dev6__tar.gz → 0.12.2.dev8__tar.gz

{port_ocean-0.12.2.dev6 → port_ocean-0.12.2.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.12.2.dev6
+Version: 0.12.2.dev8
 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.12.2.dev6 → port_ocean-0.12.2.dev8}/port_ocean/core/event_listener/base.py

@@ -1,14 +1,12 @@
-import asyncio
 from abc import abstractmethod
-from concurrent.futures import ProcessPoolExecutor
 from typing import TypedDict, Callable, Any, Awaitable
 
 from pydantic import Extra
 
 from port_ocean.config.base import BaseOceanModel
+from port_ocean.utils.signal import signal_handler
 from port_ocean.context.ocean import ocean
 from port_ocean.utils.misc import IntegrationStateStatus
-from port_ocean.utils.signal import signal_handler
 
 
 class EventListenerEvents(TypedDict):
@@ -69,14 +67,7 @@ class BaseEventListener:
         """
         await self._before_resync()
         try:
-            loop = asyncio.get_event_loop()
-            with ProcessPoolExecutor() as executor:
-                e = executor.submit(
-                    lambda: asyncio.run_coroutine_threadsafe(
-                        self.events["on_resync"](resync_args), loop
-                    )
-                )
-                signal_handler.register(e.cancel)
+            await self.events["on_resync"](resync_args)
             await self._after_resync()
         except Exception as e:
             await self._on_resync_failure(e)

{port_ocean-0.12.2.dev6 → port_ocean-0.12.2.dev8}/port_ocean/core/integrations/mixins/sync_raw.py

@@ -3,7 +3,6 @@ import inspect
 import typing
 from typing import Callable, Awaitable, Any
 
-import httpx
 from loguru import logger
 
 from port_ocean.clients.port.types import UserAgentType
@@ -140,9 +139,9 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         objects_diff = await self._calculate_raw(
             [(resource, results)], parse_all, send_raw_data_examples_amount
         )
-        await self.entities_state_applier.upsert(
-            objects_diff[0].entity_selector_diff.passed, user_agent_type
-        )
+        # modified_objects = await self.entities_state_applier.upsert(
+        #     objects_diff[0].entity_selector_diff.passed, user_agent_type
+        # )
         return CalculationResult(
             objects_diff[0].entity_selector_diff._replace(passed=objects_diff[0].entity_selector_diff.passed),
             errors=objects_diff[0].errors,
@@ -426,20 +425,20 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 use_cache=False
             )
             logger.info(f"Resync will use the following mappings: {app_config.dict()}")
-            try:
-                did_fetched_current_state = True
-                entities_at_port = await ocean.port_client.search_entities(
-                    user_agent_type
-                )
-            except httpx.HTTPError as e:
-                logger.warning(
-                    "Failed to fetch the current state of entities at Port. "
-                    "Skipping delete phase due to unknown initial state. "
-                    f"Error: {e}\n"
-                    f"Response status code: {e.response.status_code if isinstance(e, httpx.HTTPStatusError) else None}\n"
-                    f"Response content: {e.response.text if isinstance(e, httpx.HTTPStatusError) else None}\n"
-                )
-                did_fetched_current_state = False
+            # try:
+            #     did_fetched_current_state = True
+            #     entities_at_port = await ocean.port_client.search_entities(
+            #         user_agent_type
+            #     )
+            # except httpx.HTTPError as e:
+            #     logger.warning(
+            #         "Failed to fetch the current state of entities at Port. "
+            #         "Skipping delete phase due to unknown initial state. "
+            #         f"Error: {e}\n"
+            #         f"Response status code: {e.response.status_code if isinstance(e, httpx.HTTPStatusError) else None}\n"
+            #         f"Response content: {e.response.text if isinstance(e, httpx.HTTPStatusError) else None}\n"
+            #     )
+            #     did_fetched_current_state = False
 
             creation_results: list[tuple[list[Entity], list[Exception]]] = []
 
@@ -458,36 +457,36 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             except asyncio.CancelledError as e:
                 logger.warning("Resync aborted successfully, skipping delete phase. This leads to an incomplete state")
                 raise
-            else:
-                if not did_fetched_current_state:
-                    logger.warning(
-                        "Due to an error before the resync, the previous state of entities at Port is unknown."
-                        " Skipping delete phase due to unknown initial state."
-                    )
-                    return
-
-                logger.info("Starting resync diff calculation")
-                flat_created_entities, errors = zip_and_sum(creation_results) or [
-                    [],
-                    [],
-                ]
-
-                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",
-                        errors,
-                    )
-                    if not silent:
-                        raise error_group
-
-                    logger.error(message, exc_info=error_group)
-                else:
-                    logger.info(
-                        f"Running resync diff calculation, number of entities at Port before resync: {len(entities_at_port)}, number of entities created during sync: {len(flat_created_entities)}"
-                    )
-                    await self.entities_state_applier.delete_diff(
-                        {"before": entities_at_port, "after": flat_created_entities},
-                        user_agent_type,
-                    )
-                    logger.info("Resync finished successfully")
+            # else:
+            #     if not did_fetched_current_state:
+            #         logger.warning(
+            #             "Due to an error before the resync, the previous state of entities at Port is unknown."
+            #             " Skipping delete phase due to unknown initial state."
+            #         )
+            #         return
+            #
+            #     logger.info("Starting resync diff calculation")
+            #     flat_created_entities, errors = zip_and_sum(creation_results) or [
+            #         [],
+            #         [],
+            #     ]
+            #
+            #     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",
+            #             errors,
+            #         )
+            #         if not silent:
+            #             raise error_group
+            #
+            #         logger.error(message, exc_info=error_group)
+            #     else:
+            #         logger.info(
+            #             f"Running resync diff calculation, number of entities at Port before resync: {len(entities_at_port)}, number of entities created during sync: {len(flat_created_entities)}"
+            #         )
+            #         await self.entities_state_applier.delete_diff(
+            #             {"before": entities_at_port, "after": flat_created_entities},
+            #             user_agent_type,
+            #         )
+            #         logger.info("Resync finished successfully")

{port_ocean-0.12.2.dev6 → port_ocean-0.12.2.dev8}/port_ocean/log/handlers.py

@@ -1,8 +1,8 @@
 import asyncio
 import logging
 import sys
+import threading
 import time
-from concurrent.futures import ProcessPoolExecutor
 from datetime import datetime
 from logging.handlers import MemoryHandler
 from typing import Any
@@ -65,19 +65,18 @@ class HTTPMemoryHandler(MemoryHandler):
         if self.ocean is None or not self.buffer:
             return
 
+        def _wrap_event_loop(_ocean: Ocean, logs_to_send: list[dict[str, Any]]) -> None:
+            loop = asyncio.new_event_loop()
+            loop.run_until_complete(self.send_logs(_ocean, logs_to_send))
+            loop.close()
+
         self.acquire()
         logs = list(self._serialized_buffer)
         if logs:
             self.buffer.clear()
             self._serialized_buffer.clear()
             self.last_flush_time = time.time()
-            loop = asyncio.new_event_loop()
-            with ProcessPoolExecutor() as executor:
-                executor.submit(
-                    lambda: asyncio.run_coroutine_threadsafe(
-                        self.send_logs(self.ocean, logs), loop
-                    )
-                )
+            threading.Thread(target=_wrap_event_loop, args=(self.ocean, logs)).start()
         self.release()
 
     async def send_logs(

{port_ocean-0.12.2.dev6 → port_ocean-0.12.2.dev8}/port_ocean/ocean.py

@@ -1,6 +1,6 @@
 import asyncio
 import sys
-from concurrent.futures import ProcessPoolExecutor
+import threading
 from contextlib import asynccontextmanager
 from typing import Callable, Any, Dict, AsyncIterator, Type
 
@@ -9,6 +9,8 @@ from loguru import logger
 from pydantic import BaseModel
 from starlette.types import Scope, Receive, Send
 
+from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
+from port_ocean.core.models import Runtime
 from port_ocean.clients.port.client import PortClient
 from port_ocean.config.settings import (
     IntegrationConfiguration,
@@ -18,15 +20,13 @@ from port_ocean.context.ocean import (
     ocean,
     initialize_port_ocean_context,
 )
-from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
 from port_ocean.core.integrations.base import BaseIntegration
-from port_ocean.core.models import Runtime
 from port_ocean.log.sensetive import sensitive_log_filter
 from port_ocean.middlewares import request_handler
-from port_ocean.utils.misc import IntegrationStateStatus
 from port_ocean.utils.repeat import repeat_every
 from port_ocean.utils.signal import signal_handler
 from port_ocean.version import __integration_version__
+from port_ocean.utils.misc import IntegrationStateStatus
 
 
 class Ocean:
@@ -92,13 +92,6 @@ class Ocean:
                 )
                 raise e
 
-        def pool_executor_wrapper(event_loop) -> None:
-            with ProcessPoolExecutor() as executor:
-                e = executor.submit(lambda: asyncio.run_coroutine_threadsafe(
-                    execute_resync_all(), event_loop
-                ))
-                signal_handler.register(e.cancel)
-
         interval = self.config.scheduled_resync_interval
         loop = asyncio.get_event_loop()
         if interval is not None:
@@ -110,7 +103,13 @@ class Ocean:
                 seconds=interval * 60,
                 # Not running the resync immediately because the event listener should run resync on startup
                 wait_first=True,
-            )(lambda _: pool_executor_wrapper(loop))
+            )(
+                lambda: threading.Thread(
+                    target=lambda: asyncio.run_coroutine_threadsafe(
+                        execute_resync_all(), loop
+                    )
+                ).start()
+            )
             await repeated_function()
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:

{port_ocean-0.12.2.dev6 → port_ocean-0.12.2.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.12.2-dev06"
+version = "0.12.2-dev08"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"