ENH: Create user session explicitly as primary auth

Author: mferrera

src/fmu_settings_api/deps.py

@@ -8,7 +8,7 @@
 from fmu.settings._init import init_user_fmu_directory
 
 from fmu_settings_api.config import settings
-from fmu_settings_api.session import Session, session_manager
+from fmu_settings_api.session import ProjectSession, Session, session_manager
 
 api_token_header = APIKeyHeader(name=settings.TOKEN_HEADER_NAME)
 
@@ -22,6 +22,9 @@ async def verify_auth_token(req_token: TokenHeaderDep) -> TokenHeaderDep:
     return req_token
 
 
+AuthTokenDep = Annotated[TokenHeaderDep, Depends(verify_auth_token)]
+
+
 async def ensure_user_fmu_directory() -> UserFMUDirectory:
     """Ensures the user's FMU Directory exists.
 
@@ -64,7 +67,7 @@ async def ensure_user_fmu_directory() -> UserFMUDirectory:
 UserFMUDirDep = Annotated[UserFMUDirectory, Depends(ensure_user_fmu_directory)]
 
 
-async def get_fmu_session(fmu_settings_session: str | None = Cookie(None)) -> Session:
+async def get_session(fmu_settings_session: str | None = Cookie(None)) -> Session:
     """Gets a session from the session manager."""
     if not fmu_settings_session:
         raise HTTPException(
@@ -87,4 +90,20 @@ async def get_fmu_session(fmu_settings_session: str | None = Cookie(None)) -> Se
         raise HTTPException(status_code=500, detail=f"Session error: {e}") from e
 
 
-SessionDep = Annotated[Session, Depends(get_fmu_session)]
+SessionDep = Annotated[Session, Depends(get_session)]
+
+
+async def get_project_session(
+    fmu_settings_session: str | None = Cookie(None),
+) -> ProjectSession:
+    """Gets a session with an FMU Project opened from the session manager."""
+    session = await get_session(fmu_settings_session)
+    if not isinstance(session, ProjectSession):
+        raise HTTPException(
+            status_code=401,
+            detail="No FMU project directory open",
+        )
+    return session
+
+
+ProjectSessionDep = Annotated[ProjectSession, Depends(get_project_session)]

src/fmu_settings_api/models/__init__.py

@@ -1,6 +1,6 @@
 """Models used for messages and responses at API endpoints."""
 
-from .common import Message
-from .fmu import FMUDirPath, FMUProject
+from .common import APIKey, Message, SessionResponse
+from .project import FMUDirPath, FMUProject
 
-__all__ = ["FMUDirPath", "FMUProject", "Message"]
+__all__ = ["FMUDirPath", "FMUProject", "Message", "SessionResponse", "APIKey"]

src/fmu_settings_api/models/common.py

@@ -1,7 +1,17 @@
 """Common response models from the API."""
 
+from fmu.settings.models.user_config import UserConfig
 from pydantic import BaseModel, SecretStr
 
+from .project import FMUProject
+
+
+class SessionResponse(BaseModel):
+    """Information returned when a session is initially created."""
+
+    user_config: UserConfig
+    fmu_project: FMUProject | None = None
+
 
 class Message(BaseModel):
     """A generic message to return to the GUI."""

src/fmu_settings_api/models/fmu.py src/fmu_settings_api/models/project.pysrc/fmu_settings_api/models/fmu.py renamed to src/fmu_settings_api/models/project.py

@@ -3,19 +3,21 @@
 from pathlib import Path
 
 from fmu.settings.models.project_config import ProjectConfig
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class FMUDirPath(BaseModel):
     """Path where a .fmu directory may exist."""
 
-    path: Path
-    """Path to the directory which should or will contain a .fmu directory."""
+    path: Path = Field(examples=["/path/to/project.2038.02.02"])
+    """Absolute path to the directory which maybe contains a .fmu directory."""
 
 
 class FMUProject(FMUDirPath):
     """Information returned when 'opening' an FMU Directory."""
 
-    project_dir_name: str
+    project_dir_name: str = Field(examples=["project.2038.02.02"])
+    """The directory name, not the path, that contains the .fmu directory."""
+
     config: ProjectConfig
     """The configuration of an FMU project's .fmu directory."""

src/fmu_settings_api/session.py

@@ -1,6 +1,6 @@
 """Functionality for managing sessions."""
 
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 from datetime import UTC, datetime, timedelta
 from typing import Self
 from uuid import uuid4
@@ -11,18 +11,28 @@
 from fmu_settings_api.config import settings
 
 
+class SessionNotFoundError(ValueError):
+    """Raised when getting a session id that does not exist."""
+
+
 @dataclass
 class Session:
     """Represents session information when working on an FMU Directory."""
 
     id: str
-    fmu_directory: ProjectFMUDirectory
     user_fmu_directory: UserFMUDirectory
     created_at: datetime
     expires_at: datetime
     last_accessed: datetime
 
 
+@dataclass
+class ProjectSession(Session):
+    """A session with an FMU project attached."""
+
+    project_fmu_directory: ProjectFMUDirectory
+
+
 class SessionManager:
     """Manages sessions started when an FMU Directory as been opened.
 
@@ -31,7 +41,7 @@ class SessionManager:
     it simply uses a dictionary backend.
     """
 
-    Storage = dict[str, Session]
+    Storage = dict[str, Session | ProjectSession]
     """Type alias for the storage backend instance."""
 
     storage: Storage
@@ -41,15 +51,21 @@ def __init__(self: Self) -> None:
         """Initializes the session manager singleton."""
         self.storage = {}
 
-    async def _store_session(self: Self, session_id: str, session: Session) -> None:
+    async def _store_session(
+        self: Self, session_id: str, session: Session | ProjectSession
+    ) -> None:
         """Stores a newly created session."""
         self.storage[session_id] = session
 
-    async def _retrieve_session(self: Self, session_id: str) -> Session | None:
+    async def _retrieve_session(
+        self: Self, session_id: str
+    ) -> Session | ProjectSession | None:
         """Retrieves a session from the storage backend."""
         return self.storage.get(session_id, None)
 
-    async def _update_session(self: Self, session_id: str, session: Session) -> None:
+    async def _update_session(
+        self: Self, session_id: str, session: Session | ProjectSession
+    ) -> None:
         """Stores an updated session back into the session backend."""
         self.storage[session_id] = session
 
@@ -61,7 +77,6 @@ async def destroy_session(self: Self, session_id: str) -> None:
 
     async def create_session(
         self: Self,
-        fmu_directory: ProjectFMUDirectory,
         user_fmu_directory: UserFMUDirectory,
         expire_seconds: int = settings.SESSION_EXPIRE_SECONDS,
     ) -> str:
@@ -72,7 +87,6 @@ async def create_session(
 
         session = Session(
             id=session_id,
-            fmu_directory=fmu_directory,
             user_fmu_directory=user_fmu_directory,
             created_at=now,
             expires_at=now + expiration_duration,
@@ -82,7 +96,9 @@ async def create_session(
 
         return session_id
 
-    async def get_session(self: Self, session_id: str) -> Session | None:
+    async def get_session(
+        self: Self, session_id: str
+    ) -> Session | ProjectSession | None:
         """Get the session data for a session id."""
         session = await self._retrieve_session(session_id)
         if not session:
@@ -102,14 +118,60 @@ async def get_session(self: Self, session_id: str) -> Session | None:
 
 
 async def create_fmu_session(
-    fmu_directory: ProjectFMUDirectory,
     user_fmu_directory: UserFMUDirectory,
     expire_seconds: int = settings.SESSION_EXPIRE_SECONDS,
 ) -> str:
     """Creates a new session and stores it in the session mananger."""
-    return await session_manager.create_session(
-        fmu_directory, user_fmu_directory, expire_seconds
-    )
+    return await session_manager.create_session(user_fmu_directory, expire_seconds)
+
+
+async def add_fmu_project_to_session(
+    session_id: str,
+    project_fmu_directory: ProjectFMUDirectory,
+) -> ProjectSession:
+    """Adds an opened project FMU directory instance to the session.
+
+    Returns:
+        The updated ProjectSession
+
+    Raises:
+        SessionNotFoundError: If no session was found
+    """
+    session = await session_manager.get_session(session_id)
+    if not session:
+        raise SessionNotFoundError(f"No session with id {session_id} found")
+
+    if isinstance(session, ProjectSession):
+        project_session = session
+        project_session.project_fmu_directory = project_fmu_directory
+    else:
+        project_session = ProjectSession(
+            **asdict(session), project_fmu_directory=project_fmu_directory
+        )
+    await session_manager._store_session(session_id, project_session)
+    return project_session
+
+
+async def remove_fmu_project_from_session(session_id: str) -> Session:
+    """Removes (closes) an open project FMU directory from a session.
+
+    Returns:
+        The update session
+
+    Raises:
+        SessionNotFoundError: If no session was found
+    """
+    maybe_project_session = await session_manager.get_session(session_id)
+
+    if maybe_project_session is None:
+        raise SessionNotFoundError(f"No session with id {session_id} found")
+    if isinstance(maybe_project_session, Session):
+        return maybe_project_session
+
+    project_session_dict = asdict(maybe_project_session)
+    session = Session(**project_session_dict)
+    await session_manager._store_session(session_id, session)
+    return session
 
 
 async def destroy_fmu_session(session_id: str) -> None:

src/fmu_settings_api/v1/main.py

@@ -1,23 +1,79 @@
 """The main router for /api/v1."""
 
-from fastapi import APIRouter, Depends
+import contextlib
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, HTTPException, Response
+from fmu.settings import find_nearest_fmu_directory
+from fmu.settings.models.user_config import UserConfig
 
 from fmu_settings_api.config import settings
-from fmu_settings_api.deps import verify_auth_token
+from fmu_settings_api.deps import (
+    AuthTokenDep,
+    UserFMUDirDep,
+    get_session,
+    verify_auth_token,
+)
+from fmu_settings_api.models import FMUProject, SessionResponse
+from fmu_settings_api.session import (
+    add_fmu_project_to_session,
+    create_fmu_session,
+)
 
-from .routes import config, fmu, user
+from .routes import project, user
 
-api_v1_router = APIRouter(
-    prefix=settings.API_V1_PREFIX,
-    tags=["v1"],
-    dependencies=[Depends(verify_auth_token)],
-)
-api_v1_router.include_router(fmu.router)
-api_v1_router.include_router(config.router)
-api_v1_router.include_router(user.router)
+api_v1_router = APIRouter(prefix=settings.API_V1_PREFIX, tags=["v1"])
+
+api_v1_router.include_router(project.router, dependencies=[Depends(get_session)])
+api_v1_router.include_router(user.router, dependencies=[Depends(get_session)])
 
 
-@api_v1_router.get("/health")
+@api_v1_router.get("/health", dependencies=[Depends(get_session)])
 async def v1_health_check() -> dict[str, str]:
     """Simple health check endpoint."""
     return {"status": "ok"}
+
+
+@api_v1_router.post(
+    "/session",
+    response_model=SessionResponse,
+    dependencies=[Depends(verify_auth_token)],
+)
+async def create_session(
+    response: Response, auth_token: AuthTokenDep, user_fmu_dir: UserFMUDirDep
+) -> SessionResponse:
+    """Establishes a user session."""
+    try:
+        session_id = await create_fmu_session(user_fmu_dir)
+        response.set_cookie(
+            key=settings.SESSION_COOKIE_KEY,
+            value=session_id,
+            httponly=True,
+            secure=True,
+            samesite="lax",
+        )
+        config_dict = user_fmu_dir.config.load().model_dump()
+
+        # Overwrite secret keys with obfuscated keys
+        for k, v in config_dict["user_api_keys"].items():
+            if v is not None:
+                # Convert SecretStr("*********") to "*********"
+                config_dict["user_api_keys"][k] = str(v)
+
+        user_config = UserConfig.model_validate(config_dict)
+
+        session_response = SessionResponse(user_config=user_config)
+
+        with contextlib.suppress(FileNotFoundError):
+            path = Path.cwd()
+            project_fmu_dir = find_nearest_fmu_directory(path)
+            _ = await add_fmu_project_to_session(session_id, project_fmu_dir)
+            session_response.fmu_project = FMUProject(
+                path=project_fmu_dir.base_path,
+                project_dir_name=project_fmu_dir.base_path.name,
+                config=project_fmu_dir.config.load(),
+            )
+
+        return session_response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e