Create and mount application level data direcory rather than just a scan directory

src/openflexure_microscope_server/server/__init__.py

@@ -11,7 +11,8 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 import uvicorn
-from fastapi.middleware.cors import CORSMiddleware  # vue3 migration
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
 from uvicorn.main import Server
 
 import labthings_fastapi as lt
@@ -35,6 +36,15 @@ DEVELOPER_MODE = os.getenv("OFM_SERVER_DEV_MODE", "false").lower() == "true"
 _TEMPLATE_PATH = Path(__file__).with_name("fallback.html.jinja")
 
 
+class OFMApplicationData(BaseModel):
+    """Application data for the OpenFlexure Microscope."""
+
+    log_folder: str
+    """The directory to save the logs in."""
+    data_folder: str
+    """The directory for Things to save data in."""
+
+
 def set_shutdown_function(shutdown_function: Callable[[], None]) -> None:
     """Ensure a function is called before the shutdown.
 
@@ -62,10 +72,10 @@ def set_shutdown_function(shutdown_function: Callable[[], None]) -> None:
 
 
 def customise_server(
-    server: lt.ThingServer, log_folder: str, scans_folder: Optional[str]
+    server: lt.ThingServer, application_config: OFMApplicationData
 ) -> None:
     """Customise the server with additional endpoints, etc."""
-    configure_logging(log_folder)
+    configure_logging(application_config.log_folder)
 
     if DEVELOPER_MODE:
         # Allow CORS in developer mode for easier testing with the webapp
@@ -78,27 +88,13 @@ def customise_server(
         )
 
     add_v2_endpoints(server)
-    add_static_files(server.app, scans_folder)
+    add_static_files(server.app, application_config.data_folder)
 
     # Add an endpoint to get the logs - (directly calling the FastAPI decorator)
     server.app.get("/log/")(retrieve_log)
     server.app.get("/logfile/")(retrieve_log_from_file)
 
 
-def _get_scans_dir(config: dict) -> Optional[str]:
-    """Read the config and return the scans directory.
-
-    Return is None if there is no smart_scan thing loaded.
-    """
-    if "smart_scan" in config["things"]:
-        try:
-            return config["things"]["smart_scan"]["kwargs"]["scans_folder"]
-        except KeyError as e:
-            msg = "Configuration error: smart scan should have scans_folder kwarg set"
-            raise RuntimeError(msg) from e
-    return None
-
-
 def serve_from_cli(argv: Optional[list[str]] = None) -> None:
     """Start the server from the command line."""
     args = lt.cli.parse_args(argv)
@@ -112,12 +108,10 @@ def serve_from_cli(argv: Optional[list[str]] = None) -> None:
     lt_config = None
     server = None
     try:
-        lt_config, internal_config = _full_config_from_args(args)
+        lt_config, application_config = _full_config_from_args(args)
 
         server = lt.ThingServer.from_config(lt_config)
-        customise_server(
-            server, internal_config["log_folder"], internal_config["scans_folder"]
-        )
+        customise_server(server, application_config)
 
         def shutdown_call() -> None:
             try:
@@ -172,7 +166,9 @@ def serve_from_cli(argv: Optional[list[str]] = None) -> None:
             raise e
 
 
-def _full_config_from_args(args: Namespace) -> tuple[ThingServerConfig, dict[str, Any]]:
+def _full_config_from_args(
+    args: Namespace,
+) -> tuple[ThingServerConfig, OFMApplicationData]:
     """Load configuration from LabThings args allowing patching.
 
     This returns the labthings ThingServerConfig model and a dictionary of the config
@@ -181,16 +177,14 @@ def _full_config_from_args(args: Namespace) -> tuple[ThingServerConfig, dict[str
     This provides similar functionarlity to lt.cli.config_from_args except allows the
     configuration file to specify a base config, and optionally patches.
     """
-    internal_config = {"log_folder": "./openflexure/logs", "scans_folder": None}
-    # If no config file specified let LabThings handle it.
+    # Don't allow configuration to be set as an argument as then we cannot handle
+    # application_config
     if not args.config:
-        return lt.cli.config_from_args(args), internal_config
+        raise RuntimeError(
+            "OpenFlexure Microscope Server must have a configuration file specified."
+        )
 
     patched_config = load_patched_config(args.config)
-    log_folder = patched_config.pop("log_folder", None)
-    if log_folder is not None:
-        internal_config["log_folder"] = log_folder
-    scans_folder = _get_scans_dir(patched_config)
-    if scans_folder is not None:
-        internal_config["scans_folder"] = scans_folder
-    return ThingServerConfig(**patched_config), internal_config
+    application_config = OFMApplicationData(**patched_config.pop("application_config"))
+
+    return ThingServerConfig(**patched_config), application_config

src/openflexure_microscope_server/server/serve_static_files.py

@@ -1,7 +1,6 @@
 """Add endpoints for static files to the underlying FastAPI server."""
 
 import os
-from typing import Optional
 
 from fastapi import FastAPI
 from fastapi.responses import FileResponse, RedirectResponse
@@ -36,7 +35,7 @@ def add_static_file(app: FastAPI, fname: str, folder: str) -> None:
     )
 
 
-def add_static_files(app: FastAPI, scans_folder: Optional[str]) -> None:
+def add_static_files(app: FastAPI, data_folder: str) -> None:
     """Add the static files responsible for the webapp app to the FastAPI app.
 
     Note that any file in the root of the static dir will not be cached. However, the
@@ -45,7 +44,7 @@ def add_static_files(app: FastAPI, scans_folder: Optional[str]) -> None:
     important file not to cache is "index.html".
 
     :param app: The FastAPI app to add to, in this case the OpenFlexure server
-    :param scans_folder: The directory for the scans.
+    :param data_folder: The directory for any data.
     """
     check_static_dir()
 
@@ -65,16 +64,17 @@ def add_static_files(app: FastAPI, scans_folder: Optional[str]) -> None:
                 name=f"static_{fname}",
             )
 
-    # If scans folder is None, there is not smart scan thing. So nothing to mount.
-    if scans_folder is not None:
-        # Mount the scan directory to .../scans/, to allow dzi viewing
-        if not os.path.isdir(scans_folder):
-            os.makedirs(scans_folder)
-        app.mount(
-            "/scans/",
-            StaticFiles(directory=scans_folder),
-            name="scans",
-        )
+    # We need a data folder
+    if data_folder is None:
+        raise ValueError("No data folder is set, cannot start server")
+    # Mount the scan directory to .../data/, to allow dzi viewing
+    if not os.path.isdir(data_folder):
+        os.makedirs(data_folder)
+    app.mount(
+        "/data/",
+        StaticFiles(directory=data_folder),
+        name="data",
+    )
 
 
 def check_static_dir() -> None: