Enh/add auth

app/main.py

@@ -1,10 +1,13 @@
 """OTE-API FastAPI application."""
+import logging
+from importlib import import_module
 from typing import TYPE_CHECKING
 
-from fastapi import FastAPI, status
+from fastapi import Depends, FastAPI, status
 from fastapi.openapi.utils import get_openapi
 from fastapi_plugins import RedisSettings, redis_plugin
 from oteapi.plugins import load_strategies
+from oteapi.settings import OteApiCoreSettings
 from pydantic import Field
 
 from app import __version__
@@ -21,12 +24,30 @@
 )
 
 if TYPE_CHECKING:  # pragma: no cover
-    from typing import Any, Dict
+    from typing import Any, Dict, List
 
 
-class AppSettings(RedisSettings):
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class AppSettings(RedisSettings, OteApiCoreSettings):
     """Redis settings."""
 
+    include_redisadmin: bool = Field(
+        False,
+        description="""If set to `True`,
+        the router for the low-level cache interface will be included into the api.
+        WARNING: This might NOT be recommended for specific production cases,
+        since sensible data (such as secrets) in the cache might be revealed by
+        inspecting other user's session objects. If set to false, the cache can
+        only be read from an admin accessing the redis backend.""",
+    )
+
+    authentication_dependencies: str = Field(
+        "", description="List of FastAPI dependencies for authentication features."
+    )
+
     api_name: str = Field(
         "oteapi_services", description="Application-specific name for Redis cache."
     )
@@ -44,6 +65,7 @@ class Config:
 def create_app() -> FastAPI:
     """Create the FastAPI app."""
     app = FastAPI(
+        dependencies=get_auth_deps(),
         title="Open Translation Environment API",
         version=__version__,
         description="""OntoTrans Interfaces OpenAPI schema.
@@ -61,16 +83,18 @@ def create_app() -> FastAPI:
 This service is based on [**oteapi-core**](https://github.com/EMMC-ASBL/oteapi-core).
 """,
     )
-    for router_module in (
+    available_routers = [
         session,
         dataresource,
         datafilter,
         function,
         mapping,
         transformation,
-        redisadmin,
         triplestore,
-    ):
+    ]
+    if CONFIG.include_redisadmin:
+        available_routers.append(redisadmin)
+    for router_module in available_routers:
         app.include_router(
             router_module.ROUTER,
             prefix=CONFIG.prefix,
@@ -85,6 +109,34 @@ def create_app() -> FastAPI:
     return app
 
 
+def get_auth_deps() -> "List[Depends]":
+    """Get authentication dependencies
+
+    Fetch dependencies for authentication through the
+    `OTEAPI_AUTH_DEPS` environment variable.
+
+    Returns:
+        List of FastAPI dependencies with authentication functions.
+
+    """
+    if CONFIG.authentication_dependencies:
+        modules = [
+            module.strip().split(":")
+            for module in CONFIG.authentication_dependencies.split("|")
+        ]
+        imports = [
+            getattr(import_module(module), classname) for (module, classname) in modules
+        ]
+        logger.info(
+            "Imported the following dependencies for authentication: %s", imports
+        )
+        dependencies = [Depends(dependency) for dependency in imports]
+    else:
+        dependencies = []
+        logger.info("No dependencies for authentication assigned.")
+    return dependencies
+
+
 def custom_openapi() -> "Dict[str, Any]":
     """Improve the default look & feel when rendering using ReDocs."""
     if APP.openapi_schema:

app/routers/dataresource.py

@@ -3,7 +3,7 @@
 from typing import TYPE_CHECKING, Optional
 
 from aioredis import Redis
-from fastapi import APIRouter, Depends, status
+from fastapi import APIRouter, Depends, Request, status
 from fastapi_plugins import depends_redis
 from oteapi.models import ResourceConfig
 from oteapi.plugins import create_strategy
@@ -37,6 +37,7 @@
 )
 async def create_dataresource(
     config: ResourceConfig,
+    request: Request,
     session_id: Optional[str] = None,
     cache: Redis = Depends(depends_redis),
 ) -> CreateResourceResponse:
@@ -55,7 +56,11 @@ async def create_dataresource(
     """
     new_resource = CreateResourceResponse()
 
-    await cache.set(new_resource.resource_id, config.json())
+    config.token = request.headers.get("Authorization") or config.token
+
+    resource_config = config.json()
+
+    await cache.set(new_resource.resource_id, resource_config)
 
     if session_id:
         if not await cache.exists(session_id):

app/routers/function.py

@@ -3,7 +3,7 @@
 from typing import TYPE_CHECKING, Optional
 
 from aioredis import Redis
-from fastapi import APIRouter, Depends, status
+from fastapi import APIRouter, Depends, Request, status
 from fastapi_plugins import depends_redis
 from oteapi.models import FunctionConfig
 from oteapi.plugins import create_strategy
@@ -30,13 +30,18 @@
 )
 async def create_function(
     config: FunctionConfig,
+    request: Request,
     session_id: Optional[str] = None,
     cache: Redis = Depends(depends_redis),
 ) -> CreateFunctionResponse:
     """Create a new function configuration."""
     new_function = CreateFunctionResponse()
 
-    await cache.set(new_function.function_id, config.json())
+    config.token = request.headers.get("Authorization") or config.token
+
+    function_config = config.json()
+
+    await cache.set(new_function.function_id, function_config)
 
     if session_id:
         if not await cache.exists(session_id):

app/routers/redisadmin.py

@@ -1,20 +1,24 @@
 """Helper service for viewing redis objects."""
 import json
-from typing import Dict, List
+from typing import Any, Dict
 
 from aioredis import Redis
 from fastapi import APIRouter, Depends
 from fastapi_plugins import depends_redis
 
+from app.models.error import httpexception_404_item_id_does_not_exist
+
 ROUTER = APIRouter(prefix="/redis")
 
 
 @ROUTER.get("/{key}", include_in_schema=False)
-async def get_gey(
+async def get_key(
     key: str,
     cache: Redis = Depends(depends_redis),
-) -> Dict[str, List[str]]:
+) -> Dict[str, Any]:
     """Low-level cache interface to retrieve the object-value
     stored with key 'key'
     """
+    if not await cache.exists(key):
+        raise httpexception_404_item_id_does_not_exist(key, "key")
     return json.loads(await cache.get(key))

app/routers/transformation.py

@@ -3,7 +3,7 @@
 from typing import TYPE_CHECKING, Optional
 
 from aioredis import Redis
-from fastapi import APIRouter, Depends, status
+from fastapi import APIRouter, Depends, Request, status
 from fastapi_plugins import depends_redis
 from oteapi.models import TransformationConfig, TransformationStatus
 from oteapi.plugins import create_strategy
@@ -35,13 +35,18 @@
 )
 async def create_transformation(
     config: TransformationConfig,
+    request: Request,
     session_id: Optional[str] = None,
     cache: Redis = Depends(depends_redis),
 ) -> CreateTransformationResponse:
     """Create a new transformation configuration."""
     new_transformation = CreateTransformationResponse()
 
-    await cache.set(new_transformation.transformation_id, config.json())
+    config.token = request.headers.get("Authorization") or config.token
+
+    transformation_config = config.json()
+
+    await cache.set(new_transformation.transformation_id, transformation_config)
 
     if session_id:
         if not await cache.exists(session_id):

docker-compose.yml

@@ -10,7 +10,10 @@ services:
       OTEAPI_REDIS_HOST: redis
       OTEAPI_REDIS_PORT: 6379
       OTEAPI_prefix: "${OTEAPI_prefix:-/api/v1}"
+      OTEAPI_INCLUDE_REDISADMIN: "${OTEAPI_INCLUDE_REDISADMIN:-False}"
+      OTEAPI_EXPOSE_SECRETS: "${OTEAPI_EXPOSE_SECRETS:-True}"
       OTEAPI_PLUGIN_PACKAGES:
+      OTEAPI_AUTHENTICAION_DEPENDENCIES:
     depends_on:
       - redis
     networks:

docker-compose_dev.yml

@@ -12,8 +12,11 @@ services:
       OTEAPI_REDIS_HOST: redis
       OTEAPI_REDIS_PORT: 6379
       OTEAPI_prefix: "${OTEAPI_prefix:-/api/v1}"
+      OTEAPI_INCLUDE_REDISADMIN: "${OTEAPI_INCLUDE_REDISADMIN:-True}"
+      OTEAPI_EXPOSE_SECRETS: "${OTEAPI_EXPOSE_SECRETS:-True}"
       PATH_TO_OTEAPI_CORE:
       OTEAPI_PLUGIN_PACKAGES:
+      OTEAPI_AUTHENTICATION_DEPENDENCIES:
     depends_on:
       - redis
     networks:

tests/conftest.py

@@ -1,15 +1,15 @@
 """Fixtures and configuration for PyTest."""
 # pylint: disable=invalid-name,redefined-builtin,unused-argument,comparison-with-callable
-import os
-from pathlib import Path
 from typing import TYPE_CHECKING
 
 import pytest
-from fastapi.testclient import TestClient
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Dict, List
 
+    from fastapi.testclient import TestClient
+
 
 class DummyCache:
     """Mock cache for RedisCache."""
@@ -28,7 +28,7 @@ async def get(self, id) -> dict:
         """Mock `get()` method."""
         import json
 
-        return json.dumps(self.obj[id])
+        return json.loads(json.dumps(self.obj[id]))
 
     async def keys(self, pattern: str) -> "List[bytes]":
         """Mock `keys()` method."""
@@ -42,45 +42,56 @@ async def exists(self, key: str) -> bool:
 
 def pytest_configure(config):
     """Method that runs before pytest collects tests so no modules are imported"""
+    import os
+
     os.environ["OTEAPI_prefix"] = ""
+    os.environ["OTEAPI_INCLUDE_REDISADMIN"] = "True"
+    os.environ["OTEAPI_EXPOSE_SECRETS"] = "True"
 
 
 @pytest.fixture(scope="session")
-def top_dir() -> Path:
+def top_dir() -> "Path":
     """Resolved path to repository directory."""
+    from pathlib import Path
+
     return Path(__file__).resolve().parent.parent.resolve()
 
 
 @pytest.fixture(scope="session")
-def test_data() -> "Dict[str, dict]":
+def test_data() -> "Dict[str, str]":
     """Test data stored in DummyCache."""
+    import json
+
     return {
-        # filter
-        "filter-961f5314-9e8e-411e-a216-ba0eb8e8bc6e": {
-            "filterType": "filter/demo",
-            "configuration": {"demo_data": [1, 2]},
-        },
-        # function
-        "function-a647012a-7ab9-4f2c-9c13-2564aa6d95a1": {
-            "functionType": "function/demo",
-            "configuration": {},
-        },
-        # mapping
-        "mapping-a2d6b3d5-9b6b-48a3-8756-ae6d4fd6b81e": {
-            "mappingType": "mapping/demo",
-            "prefixes": {":": "<http://namespace.example.com/ns#"},
-            "triples": [[":a", ":has", ":b"]],
-            "configuration": {},
-        },
-        # sessions
-        "1": {"foo": "bar"},
-        "2": {"foo": "bar"},
-        # transformation
-        "transformation-f752c613-fde0-4d43-a7f6-c50f68642daa": {
-            "transformationType": "script/demo",
-            "name": "script/dummy",
-            "configuration": {},
-        },
+        key: json.dumps(value)
+        for key, value in {
+            # filter
+            "filter-961f5314-9e8e-411e-a216-ba0eb8e8bc6e": {
+                "filterType": "filter/demo",
+                "configuration": {"demo_data": [1, 2]},
+            },
+            # function
+            "function-a647012a-7ab9-4f2c-9c13-2564aa6d95a1": {
+                "functionType": "function/demo",
+                "configuration": {},
+            },
+            # mapping
+            "mapping-a2d6b3d5-9b6b-48a3-8756-ae6d4fd6b81e": {
+                "mappingType": "mapping/demo",
+                "prefixes": {":": "<http://namespace.example.com/ns#"},
+                "triples": [[":a", ":has", ":b"]],
+                "configuration": {},
+            },
+            # sessions
+            "1": {"foo": "bar"},
+            "2": {"foo": "bar"},
+            # transformation
+            "transformation-f752c613-fde0-4d43-a7f6-c50f68642daa": {
+                "transformationType": "script/demo",
+                "name": "script/dummy",
+                "configuration": {},
+            },
+        }.items()
     }
 
 
@@ -143,8 +154,9 @@ def load_test_strategies() -> None:
 
 
 @pytest.fixture(scope="session")
-def client(test_data: "Dict[str, dict]") -> TestClient:
+def client(test_data: "Dict[str, dict]") -> "TestClient":
     """Return a test client."""
+    from fastapi.testclient import TestClient
     from fastapi_plugins import depends_redis
 
     from asgi import app