Refactored webserver client

Created a thin wrapper for sessions with webserver
Simplifies and unifies route handlers logic

Author: pcrespov

services/api-server/src/simcore_service_api_server/api/dependencies/webserver.py

@@ -3,16 +3,20 @@
 from typing import Dict, Optional
 
 from cryptography.fernet import Fernet
-from fastapi import Depends, HTTPException, status
+from fastapi import Depends, FastAPI, HTTPException, status
 from fastapi.requests import Request
-from httpx import AsyncClient
 
 from ...core.settings import AppSettings, WebServerSettings
+from ...services.webserver import AuthSession
 from .authentication import get_active_user_email
 
 UNAVAILBLE_MSG = "backend service is disabled or unreachable"
 
 
+def _get_app(request: Request) -> FastAPI:
+    return request.app
+
+
 def _get_settings(request: Request) -> WebServerSettings:
     app_settings: AppSettings = request.app.state.settings
     return app_settings.webserver
@@ -22,13 +26,6 @@ def _get_encrypt(request: Request) -> Optional[Fernet]:
     return getattr(request.app.state, "webserver_fernet", None)
 
 
-def get_webserver_client(request: Request) -> AsyncClient:
-    client = getattr(request.app.state, "webserver_client", None)
-    if not client:
-        raise HTTPException(status.HTTP_503_SERVICE_UNAVAILABLE, detail=UNAVAILBLE_MSG)
-    return client
-
-
 def get_session_cookie(
     identity: str = Depends(get_active_user_email),
     settings: WebServerSettings = Depends(_get_settings),
@@ -53,3 +50,14 @@ def get_session_cookie(
     encrypted_cookie_data = fernet.encrypt(cookie_data).decode("utf-8")
 
     return {cookie_name: encrypted_cookie_data}
+
+
+def get_webserver_session(
+    app: FastAPI = Depends(_get_app),
+    session_cookies: Dict = Depends(get_session_cookie),
+) -> AuthSession:
+    """
+        Lifetime of AuthSession wrapper is one request because it needs different session cookies
+        Lifetime of embedded client is attached to the app lifetime
+    """
+    return AuthSession.create(app, session_cookies)

services/api-server/src/simcore_service_api_server/api/routes/users.py

@@ -1,67 +1,48 @@
 import logging
-from typing import Dict
 
 from fastapi import APIRouter, Depends, HTTPException, Security
-from httpx import AsyncClient, Response, StatusCode
-
-# SEE: https://www.python-httpx.org/async/
-# TODO: path mapping and operation
-# TODO: if fails, raise for status and translates to service unavailable if fails
-#
 from pydantic import ValidationError
 from starlette import status
 
 from ...models.schemas.profiles import Profile, ProfileUpdate
-from ..dependencies.webserver import get_session_cookie, get_webserver_client
+from ..dependencies.webserver import AuthSession, get_webserver_session
 
 logger = logging.getLogger(__name__)
 
 
 router = APIRouter()
+# SEE: https://www.python-httpx.org/async/
+# TODO: path mapping and operation
 
 
 @router.get("", response_model=Profile)
 async def get_my_profile(
-    client: AsyncClient = Depends(get_webserver_client),
-    session_cookies: Dict = Depends(get_session_cookie),
+    client: AuthSession = Depends(get_webserver_session),
 ) -> Profile:
-    resp = await client.get("/v0/me", cookies=session_cookies)
-
-    if resp.status_code == status.HTTP_200_OK:
-        data = resp.json()["data"]
-        try:
-            # FIXME: temporary patch until web-API is reviewed
-            data["role"] = data["role"].upper()
-            profile = Profile.parse_obj(data)
-            return profile
-        except ValidationError:
-            logger.exception("webserver response invalid")
-            raise
-
-    elif StatusCode.is_server_error(resp.status_code):
-        logger.error("webserver failed :%s", resp.reason_phrase)
+    data = await client.get("/me")
+
+    # FIXME: temporary patch until web-API is reviewed
+    data["role"] = data["role"].upper()
+    try:
+        profile = Profile.parse_obj(data)
+    except ValidationError:
+        logger.exception("webserver invalid response")
         raise HTTPException(status.HTTP_503_SERVICE_UNAVAILABLE)
 
-    raise HTTPException(resp.status_code, resp.reason_phrase)
+    return profile
 
 
 @router.put("", response_model=Profile)
 async def update_my_profile(
     profile_update: ProfileUpdate,
-    client: AsyncClient = Depends(get_webserver_client),
-    session_cookies: Dict = Security(get_session_cookie, scopes=["write"]),
+    client: AuthSession = Security(get_webserver_session, scopes=["write"]),
 ) -> Profile:
     # FIXME: replace by patch
     # TODO: improve. from patch -> put, we need to ensure it has a default in place
     profile_update.first_name = profile_update.first_name or ""
     profile_update.last_name = profile_update.last_name or ""
-    resp: Response = await client.put(
-        "/v0/me", json=profile_update.dict(), cookies=session_cookies
-    )
 
-    if StatusCode.is_error(resp.status_code):
-        logger.error("webserver failed: %s", resp.reason_phrase)
-        raise HTTPException(status.HTTP_503_SERVICE_UNAVAILABLE)
+    await client.put("/me", body=profile_update.dict())
 
-    profile = await get_my_profile(client, session_cookies)
+    profile = await get_my_profile(client)
     return profile

services/api-server/src/simcore_service_api_server/services/remote_debug.py

@@ -33,7 +33,9 @@ def setup_remote_debugging(force_enabled=False, *, boot_mode=None):
 
         logger.info("Remote debugging enabled: listening port %s", REMOTE_DEBUG_PORT)
     else:
-        logger.debug("Booting without remote debugging since SC_BOOT_MODE=%s", boot_mode)
+        logger.debug(
+            "Booting without remote debugging since SC_BOOT_MODE=%s", boot_mode
+        )
 
 
 __all__ = ["setup_remote_debugging"]

services/api-server/src/simcore_service_api_server/services/webserver.py

@@ -1,18 +1,19 @@
 import base64
+import json
 import logging
+from typing import Dict, Optional
 
+import attr
 from cryptography import fernet
-from fastapi import FastAPI
-from httpx import AsyncClient
+from fastapi import FastAPI, HTTPException
+from httpx import AsyncClient, Response, StatusCode
+from starlette import status
 
 from ..core.settings import WebServerSettings
 
 logger = logging.getLogger(__name__)
 
 
-# TODO: create client setup with all info inside
-
-
 def _get_secret_key(settings: WebServerSettings):
     secret_key_bytes = settings.session_secret_key.get_secret_value().encode("utf-8")
     while len(secret_key_bytes) < 32:
@@ -53,5 +54,67 @@ async def close_webserver(app: FastAPI) -> None:
     logger.debug("Webserver closed successfully")
 
 
-def get_webserver_client(app: FastAPI) -> AsyncClient:
-    return app.state.webserver_client
+@attr.s(auto_attribs=True)
+class AuthSession:
+    """
+    - wrapper around thin-client to simplify webserver's API
+    - sets endspoint upon construction
+    - MIME type: application/json
+    - processes responses, returning data or raising formatted HTTP exception
+    - The lifetime of an AuthSession is ONE request.
+
+    SEE services/api-server/src/simcore_service_api_server/api/dependencies/webserver.py
+    """
+
+    client: AsyncClient  # Its lifetime is attached to app
+    vtag: str
+    session_cookies: Dict = None
+
+    @classmethod
+    def create(cls, app: FastAPI, session_cookies: Dict):
+        return cls(
+            client=app.state.webserver_client,
+            vtag=app.state.settings.webserver.vtag,
+            session_cookies=session_cookies,
+        )
+
+    def _url(self, path: str) -> str:
+        return f"/{self.vtag}/{path.ltrip('/')}"
+
+    @classmethod
+    def _process(cls, resp: Response) -> Optional[Dict]:
+        # enveloped answer
+        data, error = None, None
+        try:
+            body = resp.json()
+            data, error = body["data"], body["error"]
+        except (json.JSONDecodeError, KeyError):
+            logger.warning("Failed to unenvelop webserver response", exc_info=True)
+
+        if StatusCode.is_server_error(resp.status_code):
+            logger.error(
+                "webserver error %d [%s]: %s",
+                resp.status_code,
+                resp.reason_phrase,
+                error,
+            )
+            raise HTTPException(status.HTTP_503_SERVICE_UNAVAILABLE)
+
+        elif StatusCode.is_client_error(resp.status_code):
+            msg = error or resp.reason_phrase
+            raise HTTPException(resp.status_code, detail=msg)
+
+        return data
+
+    # OPERATIONS
+    # TODO: automate conversion
+
+    async def get(self, path: str) -> Optional[Dict]:
+        url = self._url(path)
+        resp = await self.client.get(url, cookies=self.session_cookies)
+        return self._process(resp)
+
+    async def put(self, path: str, body: Dict) -> Optional[Dict]:
+        url = self._url(path)
+        resp = await self.client.put(url, json=body, cookies=self.session_cookies)
+        return self._process(resp)