port-ocean 0.12.2.dev17__tar.gz → 0.12.2.dev20__tar.gz

{port_ocean-0.12.2.dev17 → port_ocean-0.12.2.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.12.2.dev17
+Version: 0.12.2.dev20
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port
@@ -26,7 +26,7 @@ Requires-Dist: aiostream (>=0.5.2,<0.7.0)
 Requires-Dist: click (>=8.1.3,<9.0.0) ; extra == "cli"
 Requires-Dist: confluent-kafka (>=2.1.1,<3.0.0)
 Requires-Dist: cookiecutter (>=2.1.1,<3.0.0) ; extra == "cli"
-Requires-Dist: fastapi (>=0.100,<0.112)
+Requires-Dist: fastapi (>=0.100,<0.116)
 Requires-Dist: httpx (>=0.24.1,<0.28.0)
 Requires-Dist: jinja2-time (>=0.2.0,<0.3.0) ; extra == "cli"
 Requires-Dist: jq (>=1.8.0,<2.0.0)
@@ -40,7 +40,7 @@ Requires-Dist: rich (>=13.4.1,<14.0.0) ; extra == "cli"
 Requires-Dist: six (>=1.16.0,<2.0.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
 Requires-Dist: urllib3 (>=1.26.16,<3.0.0)
-Requires-Dist: uvicorn (>=0.22,<0.31)
+Requires-Dist: uvicorn (>=0.22,<0.33)
 Requires-Dist: werkzeug (>=2.3.4,<4.0.0)
 Project-URL: Repository, https://github.com/port-labs/Port-Ocean
 Description-Content-Type: text/markdown

{port_ocean-0.12.2.dev17 → port_ocean-0.12.2.dev20}/port_ocean/context/ocean.py

@@ -1,6 +1,5 @@
 from typing import Callable, TYPE_CHECKING, Any, Literal, Union
 
-from fastapi import APIRouter
 from pydantic.main import BaseModel
 from werkzeug.local import LocalProxy
 
@@ -44,10 +43,6 @@ class PortOceanContext:
     def config(self) -> "IntegrationConfiguration":
         return self.app.config
 
-    @property
-    def router(self) -> APIRouter:
-        return self.app.integration_router
-
     @property
     def integration(self) -> "BaseIntegration":
         return self.app.integration

{port_ocean-0.12.2.dev17 → port_ocean-0.12.2.dev20}/port_ocean/exceptions/api.py

@@ -1,7 +1,7 @@
 import abc
 
-from fastapi.responses import Response, PlainTextResponse
 from port_ocean.exceptions.base import BaseOceanException
+from starlette.responses import Response, PlainTextResponse
 
 
 class BaseAPIException(BaseOceanException, abc.ABC):

port_ocean-0.12.2.dev20/port_ocean/middlewares.py

@@ -0,0 +1,70 @@
+from loguru import logger
+from starlette.requests import Request
+from starlette.responses import Response
+
+from port_ocean.exceptions.api import BaseAPIException, InternalServerException
+from .context.event import event_context, EventType
+from .context.ocean import ocean
+from .utils.misc import get_time, generate_uuid
+from starlette.middleware.base import (
+    BaseHTTPMiddleware,
+    RequestResponseEndpoint,
+)
+
+
+class RequestHandlerMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
+        start_time = get_time(seconds_precision=False)
+        request_id = generate_uuid()
+
+        with logger.contextualize(request_id=request_id):
+            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 self._handle_silently(request, call_next)
+
+            end_time = get_time(seconds_precision=False)
+            time_elapsed = round(end_time - start_time, 5)
+            response.headers["X-Request-ID"] = request_id
+            response.headers["X-Process-Time"] = str(time_elapsed)
+            logger.bind(
+                time_elapsed=time_elapsed, response_status=response.status_code
+            ).log(log_level, f"Request to {request.url.path} ended")
+
+            return response
+
+    async def _handle_silently(
+        self, request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        response: Response
+        try:
+            if request.url.path.startswith("/integration"):
+                async with event_context(
+                    EventType.HTTP_REQUEST, trigger_type="request"
+                ):
+                    await ocean.integration.port_app_config_handler.get_port_app_config()
+                    response = await call_next(request)
+            else:
+                response = await call_next(request)
+
+        except BaseAPIException as ex:
+            response = ex.response()
+            if response.status_code < 500:
+                logger.bind(exception=str(ex)).info(
+                    "Request did not succeed due to client-side error"
+                )
+            else:
+                logger.opt(exception=True).warning(
+                    "Request did not succeed due to server-side error"
+                )
+
+        except Exception:
+            logger.opt(exception=True).error("Request failed due to unexpected error")
+            response = InternalServerException().response()
+
+        return response

{port_ocean-0.12.2.dev17 → port_ocean-0.12.2.dev20}/port_ocean/ocean.py

@@ -1,12 +1,13 @@
 import asyncio
 import sys
 import threading
-from contextlib import asynccontextmanager
-from typing import Callable, Any, Dict, AsyncIterator, Type
+from typing import Callable, Any, Dict, Type
 
-from fastapi import FastAPI, APIRouter
 from loguru import logger
 from pydantic import BaseModel
+from starlette.middleware import Middleware
+from starlette.responses import JSONResponse
+from starlette.routing import Route
 from starlette.types import Scope, Receive, Send
 
 from port_ocean.clients.port.client import PortClient
@@ -18,25 +19,50 @@ 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 RequestHandlerMiddleware
 from port_ocean.utils.repeat import repeat_every
 from port_ocean.utils.signal import signal_handler
 from port_ocean.version import __integration_version__
+import contextlib
+
+from starlette.applications import Starlette
 
 
 class Ocean:
     def __init__(
         self,
-        app: FastAPI | None = None,
+        app: Starlette | None = None,
         integration_class: Callable[[PortOceanContext], BaseIntegration] | None = None,
-        integration_router: APIRouter | None = None,
+        integration_router: None = None,
         config_factory: Type[BaseModel] | None = None,
         config_override: Dict[str, Any] | None = None,
     ):
         initialize_port_ocean_context(self)
-        self.fast_api_app = app or FastAPI()
-        # self.fast_api_app.middleware("http")(request_handler)
+
+        @contextlib.asynccontextmanager
+        async def lifespan(app):
+            try:
+                await self.integration.start()
+                await self._setup_scheduled_resync()
+                yield None
+            except Exception:
+                logger.exception("Integration had a fatal error. Shutting down.")
+                sys.exit("Server stopped")
+            finally:
+                signal_handler.exit()
+
+        async def handle_webhook_request(data: dict[str, Any]) -> dict[str, Any]:
+            return JSONResponse({"ok": True})
+
+        self.starlette_app = Starlette(
+            routes=[Route("/integration/webhook", endpoint=handle_webhook_request)],
+            middleware=[Middleware(RequestHandlerMiddleware)],
+            lifespan=lifespan,
+        )
 
         self.config = IntegrationConfiguration(
             # type: ignore
@@ -45,10 +71,9 @@ class Ocean:
         )
 
         # add the integration sensitive configuration to the sensitive patterns to mask out
-        # sensitive_log_filter.hide_sensitive_strings(
-        #     *self.config.get_sensitive_fields_data()
-        # )
-        # self.integration_router = integration_router or APIRouter()
+        sensitive_log_filter.hide_sensitive_strings(
+            *self.config.get_sensitive_fields_data()
+        )
 
         self.port_client = PortClient(
             base_url=self.config.port.base_url,
@@ -62,9 +87,9 @@ 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.resync_state_updater = ResyncStateUpdater(
+            self.port_client, self.config.scheduled_resync_interval
+        )
 
     def is_saas(self) -> bool:
         return self.config.runtime == Runtime.Saas
@@ -109,19 +134,4 @@ class Ocean:
             await repeated_function()
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        # self.fast_api_app.include_router(self.integration_router, prefix="/integration")
-
-        @asynccontextmanager
-        async def lifecycle(_: FastAPI) -> AsyncIterator[None]:
-            try:
-                await self.integration.start()
-                await self._setup_scheduled_resync()
-                yield None
-            except Exception:
-                logger.exception("Integration had a fatal error. Shutting down.")
-                sys.exit("Server stopped")
-            finally:
-                signal_handler.exit()
-
-        self.fast_api_app.router.lifespan_context = lifecycle
-        await self.fast_api_app(scope, receive, send)
+        await self.starlette_app(scope, receive, send)

{port_ocean-0.12.2.dev17 → port_ocean-0.12.2.dev20}/port_ocean/run.py

@@ -7,8 +7,8 @@ from pydantic import BaseModel
 
 from port_ocean.bootstrap import create_default_app
 from port_ocean.config.dynamic import default_config_factory
-from port_ocean.config.settings import LogLevelType, ApplicationSettings
-from port_ocean.core.defaults import initialize_defaults
+from port_ocean.config.settings import ApplicationSettings, LogLevelType
+from port_ocean.core.defaults.initialize import initialize_defaults
 from port_ocean.core.utils import validate_integration_runtime
 from port_ocean.log.logger_setup import setup_logger
 from port_ocean.ocean import Ocean
@@ -60,4 +60,4 @@ def run(
 
     initialize_defaults(app.integration.AppConfigHandlerClass.CONFIG_CLASS, app.config)
 
-    uvicorn.run(app, host="0.0.0.0", port=8000, loop="none")
+    uvicorn.run(app, host="0.0.0.0", port=application_settings.port)

{port_ocean-0.12.2.dev17 → port_ocean-0.12.2.dev20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.12.2-dev17"
+version = "0.12.2-dev20"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"
@@ -40,8 +40,8 @@ pydantic = { version = "^1.10.8", extras = ["dotenv"] }
 loguru = "^0.7.0"
 pyyaml = "^6.0"
 werkzeug = ">=2.3.4,<4.0.0"
-fastapi = ">=0.100,<0.112"
-uvicorn = ">=0.22,<0.31"
+fastapi = ">=0.100,<0.116"
+uvicorn = ">=0.22,<0.33"
 confluent-kafka = "^2.1.1"
 httpx = ">=0.24.1,<0.28.0"
 jq = "^1.8.0"

port_ocean-0.12.2.dev17/port_ocean/middlewares.py

@@ -1,73 +0,0 @@
-from typing import Callable, Awaitable
-
-from fastapi import Request, Response
-from loguru import logger
-
-from port_ocean.exceptions.api import BaseAPIException, InternalServerException
-from .context.event import event_context, EventType
-from .context.ocean import ocean
-from .utils.misc import get_time, generate_uuid
-
-
-async def _handle_silently(
-    call_next: Callable[[Request], Awaitable[Response]], request: Request
-) -> Response:
-    response: Response
-    try:
-        if request.url.path.startswith("/integration"):
-            async with event_context(EventType.HTTP_REQUEST, trigger_type="request"):
-                await ocean.integration.port_app_config_handler.get_port_app_config()
-                response = await call_next(request)
-        else:
-            response = await call_next(request)
-
-    except BaseAPIException as ex:
-        response = ex.response()
-        if response.status_code < 500:
-            logger.bind(exception=str(ex)).info(
-                "Request did not succeed due to client-side error"
-            )
-        else:
-            logger.opt(exception=True).warning(
-                "Request did not succeed due to server-side error"
-            )
-
-    except Exception:
-        logger.opt(exception=True).error("Request failed due to unexpected error")
-        response = InternalServerException().response()
-
-    return response
-
-
-async def request_handler(
-    request: Request, call_next: Callable[[Request], Awaitable[Response]]
-) -> Response:
-    """Middleware used by FastAPI to process each request, featuring:
-
-    - Contextualize request logs with a unique Request ID (UUID4) for each unique request.
-    - Catch exceptions during the request handling. Translate custom API exceptions into responses,
-      or treat (and log) unexpected exceptions.
-    """
-    start_time = get_time(seconds_precision=False)
-    request_id = generate_uuid()
-
-    with logger.contextualize(request_id=request_id):
-        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)
-        time_elapsed = round(end_time - start_time, 5)
-        response.headers["X-Request-ID"] = request_id
-        response.headers["X-Process-Time"] = str(time_elapsed)
-        logger.bind(
-            time_elapsed=time_elapsed, response_status=response.status_code
-        ).log(log_level, f"Request to {request.url.path} ended")
-
-        return response