port-ocean 0.5.5__py3-none-any.whl → 0.17.8__py3-none-any.whl

port_ocean/core/utils/utils.py

@@ -0,0 +1,109 @@
+import asyncio
+from typing import Iterable, Any, TypeVar, Callable, Awaitable
+
+from loguru import logger
+from pydantic import parse_obj_as, ValidationError
+
+from port_ocean.clients.port.client import PortClient
+from port_ocean.core.models import Entity, Runtime
+from port_ocean.core.models import EntityPortDiff
+from port_ocean.core.ocean_types import RAW_RESULT
+from port_ocean.exceptions.core import (
+    RawObjectValidationException,
+    IntegrationRuntimeException,
+)
+
+T = TypeVar("T", bound=tuple[list[Any], ...])
+
+
+def zip_and_sum(collection: Iterable[T]) -> T:
+    return tuple(sum(items, []) for items in zip(*collection))  # type: ignore
+
+
+def validate_result(result: Any) -> RAW_RESULT:
+    try:
+        return parse_obj_as(list[dict[str, Any]], result)
+    except ValidationError as e:
+        raise RawObjectValidationException(f"Expected list[dict[str, Any]], Error: {e}")
+
+
+def is_same_entity(first_entity: Entity, second_entity: Entity) -> bool:
+    return (
+        first_entity.identifier == second_entity.identifier
+        and first_entity.blueprint == second_entity.blueprint
+    )
+
+
+async def validate_integration_runtime(
+    port_client: PortClient,
+    requested_runtime: Runtime,
+) -> None:
+    logger.debug("Validating integration runtime")
+    current_integration = await port_client.get_current_integration(
+        should_raise=False, should_log=False
+    )
+    current_installation_type = current_integration.get("installationType", "OnPrem")
+    if current_integration and not requested_runtime.is_installation_type_compatible(
+        current_installation_type
+    ):
+        raise IntegrationRuntimeException(
+            f"Invalid Runtime! Requested to run existing {current_installation_type} integration in {requested_runtime} runtime."
+        )
+
+
+Q = TypeVar("Q")
+
+
+async def gather_and_split_errors_from_results(
+    task: Iterable[Awaitable[Q]],
+    result_threshold_validation: Callable[[Q | Exception], bool] | None = None,
+) -> tuple[list[Q], list[Exception]]:
+    valid_items: list[Q] = []
+    errors: list[Exception] = []
+    results = await asyncio.gather(*task, return_exceptions=True)
+    for item in results:
+        # return_exceptions will also catch Python BaseException which also includes KeyboardInterrupt, SystemExit, GeneratorExit
+        # https://docs.python.org/3/library/asyncio-task.html#asyncio.gather
+        # These exceptions should be raised and not caught for the application to exit properly.
+        # https://stackoverflow.com/a/17802352
+        if isinstance(item, BaseException) and not isinstance(item, Exception):
+            raise item
+        elif isinstance(item, Exception):
+            errors.append(item)
+        elif not result_threshold_validation or result_threshold_validation(item):
+            valid_items.append(item)
+
+    return valid_items, errors
+
+
+def get_port_diff(
+    before: Iterable[Entity],
+    after: Iterable[Entity],
+) -> EntityPortDiff:
+    before_dict = {}
+    after_dict = {}
+    created = []
+    modified = []
+    deleted = []
+
+    # Create dictionaries for before and after lists
+    for entity in before:
+        key = (entity.identifier, entity.blueprint)
+        before_dict[key] = entity
+
+    for entity in after:
+        key = (entity.identifier, entity.blueprint)
+        after_dict[key] = entity
+
+    # Find created, modified, and deleted objects
+    for key, obj in after_dict.items():
+        if key not in before_dict:
+            created.append(obj)
+        else:
+            modified.append(obj)
+
+    for key, obj in before_dict.items():
+        if key not in after_dict:
+            deleted.append(obj)
+
+    return EntityPortDiff(created=created, modified=modified, deleted=deleted)

port_ocean/debug_cli.py

@@ -0,0 +1,5 @@
+from port_ocean.cli.commands.main import cli_start
+
+
+if __name__ == "__main__":
+    cli_start()

port_ocean/exceptions/core.py

@@ -33,3 +33,7 @@ class IntegrationAlreadyStartedException(BaseOceanException):
 
 class IntegrationNotStartedException(BaseOceanException):
     pass
+
+
+class IntegrationRuntimeException(BaseOceanException):
+    pass

port_ocean/exceptions/port_defaults.py

@@ -6,10 +6,8 @@ class AbortDefaultCreationError(BaseOceanException):
         self,
         blueprints_to_rollback: list[str],
         errors: list[Exception],
-        pages_to_rollback: list[str] | None = None,
     ):
         self.blueprints_to_rollback = blueprints_to_rollback
-        self.pages_to_rollback = pages_to_rollback
         self.errors = errors
         super().__init__("Aborting defaults creation")
 

port_ocean/helpers/retry.py

@@ -55,14 +55,14 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             HTTPStatus.GATEWAY_TIMEOUT,
         ]
     )
-    MAX_BACKOFF_WAIT = 60
+    MAX_BACKOFF_WAIT_IN_SECONDS = 60
 
     def __init__(
         self,
         wrapped_transport: Union[httpx.BaseTransport, httpx.AsyncBaseTransport],
         max_attempts: int = 10,
-        max_backoff_wait: float = MAX_BACKOFF_WAIT,
-        backoff_factor: float = 0.1,
+        max_backoff_wait: float = MAX_BACKOFF_WAIT_IN_SECONDS,
+        base_delay: float = 0.1,
         jitter_ratio: float = 0.1,
         respect_retry_after_header: bool = True,
         retryable_methods: Iterable[str] | None = None,
@@ -81,7 +81,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             max_backoff_wait (float, optional):
                 The maximum amount of time (in seconds) to wait before retrying a request.
                 Defaults to 60.
-            backoff_factor (float, optional):
+            base_delay (float, optional):
                 The factor by which the waiting time will be multiplied in each retry attempt.
                 Defaults to 0.1.
             jitter_ratio (float, optional):
@@ -105,7 +105,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             )
 
         self._max_attempts = max_attempts
-        self._backoff_factor = backoff_factor
+        self._base_delay = base_delay
         self._respect_retry_after_header = respect_retry_after_header
         self._retryable_methods = (
             frozenset(retryable_methods)
@@ -132,13 +132,18 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             httpx.Response: The response received.
 
         """
-        transport: httpx.BaseTransport = self._wrapped_transport  # type: ignore
-        if request.method in self._retryable_methods:
-            send_method = partial(transport.handle_request)
-            response = self._retry_operation(request, send_method)
-        else:
-            response = transport.handle_request(request)
-        return response
+        try:
+            transport: httpx.BaseTransport = self._wrapped_transport  # type: ignore
+            if self._is_retryable_method(request):
+                send_method = partial(transport.handle_request)
+                response = self._retry_operation(request, send_method)
+            else:
+                response = transport.handle_request(request)
+            return response
+        except Exception as e:
+            if not self._is_retryable_method(request) and self._logger is not None:
+                self._logger.exception(f"{repr(e)} - {request.url}", exc_info=e)
+            raise e
 
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
         """Sends an HTTP request, possibly with retries.
@@ -150,13 +155,19 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             The response.
 
         """
-        transport: httpx.AsyncBaseTransport = self._wrapped_transport  # type: ignore
-        if self._is_retryable_method(request):
-            send_method = partial(transport.handle_async_request)
-            response = await self._retry_operation_async(request, send_method)
-        else:
-            response = await transport.handle_async_request(request)
-        return response
+        try:
+            transport: httpx.AsyncBaseTransport = self._wrapped_transport  # type: ignore
+            if self._is_retryable_method(request):
+                send_method = partial(transport.handle_async_request)
+                response = await self._retry_operation_async(request, send_method)
+            else:
+                response = await transport.handle_async_request(request)
+            return response
+        except Exception as e:
+            # Retyable methods are logged via _log_error
+            if not self._is_retryable_method(request) and self._logger is not None:
+                self._logger.exception(f"{repr(e)} - {request.url}", exc_info=e)
+            raise e
 
     async def aclose(self) -> None:
         """
@@ -179,12 +190,35 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         transport.close()
 
     def _is_retryable_method(self, request: httpx.Request) -> bool:
-        return request.method in self._retryable_methods
+        return request.method in self._retryable_methods or request.extensions.get(
+            "retryable", False
+        )
 
     def _should_retry(self, response: httpx.Response) -> bool:
         return response.status_code in self._retry_status_codes
 
-    def _log_failure(
+    def _log_error(
+        self,
+        request: httpx.Request,
+        error: Exception | None,
+    ) -> None:
+        if not self._logger:
+            return
+
+        if isinstance(error, httpx.ConnectTimeout):
+            self._logger.error(
+                f"Request {request.method} {request.url} failed to connect: {str(error)}"
+            )
+        elif isinstance(error, httpx.TimeoutException):
+            self._logger.error(
+                f"Request {request.method} {request.url} failed with a timeout exception: {str(error)}"
+            )
+        elif isinstance(error, httpx.HTTPError):
+            self._logger.error(
+                f"Request {request.method} {request.url} failed with an HTTP error: {str(error)}"
+            )
+
+    def _log_before_retry(
         self,
         request: httpx.Request,
         sleep_time: float,
@@ -232,7 +266,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             except ValueError:
                 pass
 
-        backoff = self._backoff_factor * (2 ** (attempts_made - 1))
+        backoff = self._base_delay * (2 ** (attempts_made - 1))
         jitter = (backoff * self._jitter_ratio) * random.choice([1, -1])
         total_backoff = backoff + jitter
         return min(total_backoff, self._max_backoff_wait)
@@ -249,7 +283,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         while True:
             if attempts_made > 0:
                 sleep_time = self._calculate_sleep(attempts_made, {})
-                self._log_failure(request, sleep_time, response, error)
+                self._log_before_retry(request, sleep_time, response, error)
                 await asyncio.sleep(sleep_time)
 
             error = None
@@ -262,9 +296,25 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                 ):
                     return response
                 await response.aclose()
+            except httpx.ConnectTimeout as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
+            except httpx.ReadTimeout as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
+            except httpx.TimeoutException as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
             except httpx.HTTPError as e:
                 error = e
                 if remaining_attempts < 1:
+                    self._log_error(request, error)
                     raise
             attempts_made += 1
             remaining_attempts -= 1
@@ -281,7 +331,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         while True:
             if attempts_made > 0:
                 sleep_time = self._calculate_sleep(attempts_made, {})
-                self._log_failure(request, sleep_time, response, error)
+                self._log_before_retry(request, sleep_time, response, error)
                 time.sleep(sleep_time)
 
             error = None
@@ -292,9 +342,20 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                 if remaining_attempts < 1 or not self._should_retry(response):
                     return response
                 response.close()
+            except httpx.ConnectTimeout as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
+            except httpx.TimeoutException as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
             except httpx.HTTPError as e:
                 error = e
                 if remaining_attempts < 1:
+                    self._log_error(request, error)
                     raise
             attempts_made += 1
             remaining_attempts -= 1

port_ocean/log/handlers.py

@@ -11,16 +11,22 @@ from loguru import logger
 
 from port_ocean import Ocean
 from port_ocean.context.ocean import ocean
+from copy import deepcopy
+from traceback import format_exception
 
 
 def _serialize_record(record: logging.LogRecord) -> dict[str, Any]:
+    extra = {**deepcopy(record.__dict__["extra"])}
+    if isinstance(extra.get("exc_info"), Exception):
+        serialized_exception = "".join(format_exception(extra.get("exc_info")))
+        extra["exc_info"] = serialized_exception
     return {
         "message": record.msg,
         "level": record.levelname,
         "timestamp": datetime.utcfromtimestamp(record.created).strftime(
             "%Y-%m-%dT%H:%M:%S.%fZ"
         ),
-        "extra": record.__dict__["extra"],
+        "extra": extra,
     }
 
 
@@ -37,6 +43,7 @@ class HTTPMemoryHandler(MemoryHandler):
         self.flush_size = flush_size
         self.last_flush_time = time.time()
         self._serialized_buffer: list[dict[str, Any]] = []
+        self._thread_pool: list[threading.Thread] = []
 
     @property
     def ocean(self) -> Ocean | None:
@@ -46,6 +53,7 @@ class HTTPMemoryHandler(MemoryHandler):
         return None
 
     def emit(self, record: logging.LogRecord) -> None:
+
         self._serialized_buffer.append(_serialize_record(record))
         super().emit(record)
 
@@ -61,6 +69,11 @@ class HTTPMemoryHandler(MemoryHandler):
             return True
         return False
 
+    def wait_for_lingering_threads(self) -> None:
+        for thread in self._thread_pool:
+            if thread.is_alive():
+                thread.join()
+
     def flush(self) -> None:
         if self.ocean is None or not self.buffer:
             return
@@ -70,13 +83,21 @@ class HTTPMemoryHandler(MemoryHandler):
             loop.run_until_complete(self.send_logs(_ocean, logs_to_send))
             loop.close()
 
+        def clear_thread_pool() -> None:
+            for thread in self._thread_pool:
+                if not thread.is_alive():
+                    self._thread_pool.remove(thread)
+
         self.acquire()
         logs = list(self._serialized_buffer)
         if logs:
             self.buffer.clear()
             self._serialized_buffer.clear()
             self.last_flush_time = time.time()
-            threading.Thread(target=_wrap_event_loop, args=(self.ocean, logs)).start()
+            clear_thread_pool()
+            thread = threading.Thread(target=_wrap_event_loop, args=(self.ocean, logs))
+            thread.start()
+            self._thread_pool.append(thread)
         self.release()
 
     async def send_logs(

port_ocean/log/logger_setup.py

@@ -9,6 +9,7 @@ from loguru import logger
 from port_ocean.config.settings import LogLevelType
 from port_ocean.log.handlers import HTTPMemoryHandler
 from port_ocean.log.sensetive import sensitive_log_filter
+from port_ocean.utils.signal import signal_handler
 
 
 def setup_logger(level: LogLevelType, enable_http_handler: bool) -> None:
@@ -35,6 +36,7 @@ def _stdout_loguru_handler(level: LogLevelType) -> None:
         diagnose=False,  # hide variable values in log backtrace
         filter=sensitive_log_filter.create_filter(),
     )
+    logger.configure(patcher=exception_deserializer)
 
 
 def _http_loguru_handler(level: LogLevelType) -> None:
@@ -50,8 +52,13 @@ def _http_loguru_handler(level: LogLevelType) -> None:
         enqueue=True,  # process logs in background
         filter=sensitive_log_filter.create_filter(full_hide=True),
     )
+    logger.configure(patcher=exception_deserializer)
 
-    queue_listener = QueueListener(queue, HTTPMemoryHandler())
+    http_memory_handler = HTTPMemoryHandler()
+    signal_handler.register(http_memory_handler.wait_for_lingering_threads)
+    signal_handler.register(http_memory_handler.flush)
+
+    queue_listener = QueueListener(queue, http_memory_handler)
     queue_listener.start()
 
 

port_ocean/log/sensetive.py

@@ -1,5 +1,5 @@
 import re
-from typing import Callable, TYPE_CHECKING
+from typing import Any, Callable, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from loguru import Record
@@ -21,7 +21,7 @@ secret_patterns = {
     "GitHub": r"[g|G][i|I][t|T][h|H][u|U][b|B].*['|\"][0-9a-zA-Z]{35,40}['|\"]",
     "Google Cloud Platform API Key": r"AIza[0-9A-Za-z\\-_]{35}",
     "Google Cloud Platform OAuth": r"[0-9]+-[0-9A-Za-z_]{32}\\.apps\\.googleusercontent\\.com",
-    "Google (GCP) Service-account": r'"type": "service_account"',
+    "Google (GCP) Service-account": f'"type":{" "}"service_account"',
     "Google OAuth Access Token": r"ya29\\.[0-9A-Za-z\\-_]+",
     "Connection String": r"[a-zA-Z]+:\/\/[^/\s]+:[^/\s]+@[^/\s]+\/[^/\s]+",
 }
@@ -35,16 +35,31 @@ class SensitiveLogFilter:
             [re.compile(re.escape(token.strip())) for token in tokens if token.strip()]
         )
 
+    def mask_string(self, string: str, full_hide: bool = False) -> str:
+        masked_string = string
+        for pattern in self.compiled_patterns:
+            replace: Callable[[re.Match[str]], str] | str = (
+                "[REDACTED]"
+                if full_hide
+                else lambda match: match.group()[:6] + "[REDACTED]"
+            )
+            masked_string = pattern.sub(replace, masked_string)
+        return masked_string
+
+    def mask_object(self, obj: Any, full_hide: bool = False) -> Any:
+        if isinstance(obj, str):
+            return self.mask_string(obj, full_hide)
+        if isinstance(obj, list):
+            return [self.mask_object(o, full_hide) for o in obj]
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                obj[k] = self.mask_object(v, full_hide)
+
+        return obj
+
     def create_filter(self, full_hide: bool = False) -> Callable[["Record"], bool]:
         def _filter(record: "Record") -> bool:
-            for pattern in self.compiled_patterns:
-                replace: Callable[[re.Match[str]], str] | str = (
-                    "[REDACTED]"
-                    if full_hide
-                    else lambda match: match.group()[:6] + "[REDACTED]"
-                )
-                record["message"] = pattern.sub(replace, record["message"])
-
+            record["message"] = self.mask_string(record["message"], full_hide)
             return True
 
         return _filter

port_ocean/middlewares.py

@@ -52,7 +52,14 @@ async def request_handler(
     request_id = generate_uuid()
 
     with logger.contextualize(request_id=request_id):
-        logger.bind(url=str(request.url), method=request.method).info("Request started")
+        log_level = (
+            "DEBUG"
+            if request.url.path == "/docs" or request.url.path == "/openapi.json"
+            else "INFO"
+        )
+        logger.bind(url=str(request.url), method=request.method).log(
+            log_level, f"Request to {request.url.path} started"
+        )
         response = await _handle_silently(call_next, request)
 
         end_time = get_time(seconds_precision=False)
@@ -61,5 +68,6 @@ async def request_handler(
         response.headers["X-Process-Time"] = str(time_elapsed)
         logger.bind(
             time_elapsed=time_elapsed, response_status=response.status_code
-        ).info("Request ended")
+        ).log(log_level, f"Request to {request.url.path} ended")
+
         return response

port_ocean/ocean.py

@@ -1,13 +1,15 @@
 import asyncio
 import sys
 import threading
-from typing import Callable, Any, Dict
+from contextlib import asynccontextmanager
+from typing import Callable, Any, Dict, AsyncIterator, Type
 
 from fastapi import FastAPI, APIRouter
 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.clients.port.client import PortClient
 from port_ocean.config.settings import (
     IntegrationConfiguration,
@@ -21,8 +23,9 @@ from port_ocean.core.integrations.base import BaseIntegration
 from port_ocean.log.sensetive import sensitive_log_filter
 from port_ocean.middlewares import request_handler
 from port_ocean.utils.repeat import repeat_every
-from port_ocean.utils.signal import init_signal_handler
+from port_ocean.utils.signal import signal_handler
 from port_ocean.version import __integration_version__
+from port_ocean.utils.misc import IntegrationStateStatus
 
 
 class Ocean:
@@ -31,7 +34,7 @@ class Ocean:
         app: FastAPI | None = None,
         integration_class: Callable[[PortOceanContext], BaseIntegration] | None = None,
         integration_router: APIRouter | None = None,
-        config_factory: Callable[..., BaseModel] | None = None,
+        config_factory: Type[BaseModel] | None = None,
         config_override: Dict[str, Any] | None = None,
     ):
         initialize_port_ocean_context(self)
@@ -39,16 +42,11 @@ class Ocean:
         self.fast_api_app.middleware("http")(request_handler)
 
         self.config = IntegrationConfiguration(
-            base_path="./", **(config_override or {})
+            # type: ignore
+            _integration_config_model=config_factory,
+            **(config_override or {}),
         )
 
-        if config_factory:
-            raw_config = (
-                self.config.integration.config
-                if isinstance(self.config.integration.config, dict)
-                else self.config.integration.config.dict()
-            )
-            self.config.integration.config = config_factory(**raw_config)
         # add the integration sensitive configuration to the sensitive patterns to mask out
         sensitive_log_filter.hide_sensitive_strings(
             *self.config.get_sensitive_fields_data()
@@ -67,40 +65,75 @@ class Ocean:
             integration_class(ocean) if integration_class else BaseIntegration(ocean)
         )
 
+        self.resync_state_updater = ResyncStateUpdater(
+            self.port_client, self.config.scheduled_resync_interval
+        )
+
+        self.app_initialized = False
+
+    def is_saas(self) -> bool:
+        return self.config.runtime.is_saas_runtime
+
     async def _setup_scheduled_resync(
         self,
     ) -> None:
-        def execute_resync_all() -> None:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
+        async def execute_resync_all() -> None:
+            await self.resync_state_updater.update_before_resync()
             logger.info("Starting a new scheduled resync")
-            loop.run_until_complete(self.integration.sync_raw_all())
-            loop.close()
+            try:
+                await self.integration.sync_raw_all()
+                await self.resync_state_updater.update_after_resync()
+            except asyncio.CancelledError:
+                logger.warning(
+                    "resync was cancelled by the scheduled resync, skipping state update"
+                )
+            except Exception as e:
+                await self.resync_state_updater.update_after_resync(
+                    IntegrationStateStatus.Failed
+                )
+                raise e
 
         interval = self.config.scheduled_resync_interval
+        loop = asyncio.get_event_loop()
         if interval is not None:
             logger.info(
-                f"Setting up scheduled resync, the integration will automatically perform a full resync every {interval} minutes)"
+                f"Setting up scheduled resync, the integration will automatically perform a full resync every {interval} minutes)",
+                scheduled_interval=interval,
             )
             repeated_function = repeat_every(
                 seconds=interval * 60,
                 # Not running the resync immediately because the event listener should run resync on startup
                 wait_first=True,
-            )(lambda: threading.Thread(target=execute_resync_all).start())
+            )(
+                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:
+    def initialize_app(self) -> None:
         self.fast_api_app.include_router(self.integration_router, prefix="/integration")
 
-        @self.fast_api_app.on_event("startup")
-        async def startup() -> None:
-            init_signal_handler()
+        @asynccontextmanager
+        async def lifecycle(_: FastAPI) -> AsyncIterator[None]:
             try:
                 await self.integration.start()
                 await self._setup_scheduled_resync()
+                yield None
             except Exception:
-                logger.exception("Failed to start integration")
+                logger.exception("Integration had a fatal error. Shutting down.")
+                logger.complete()
                 sys.exit("Server stopped")
+            finally:
+                signal_handler.exit()
+
+        self.fast_api_app.router.lifespan_context = lifecycle
+        self.app_initialized = True
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if not self.app_initialized:
+            self.initialize_app()
 
         await self.fast_api_app(scope, receive, send)