Separate server endpoints into different routers

Dockerfiles/murfey-instrument-server

@@ -2,7 +2,7 @@
 # podman build --build-arg groupid=<groupid> --build-arg userid=<userid> --build-arg groupname=<groupname> --no-cache -f path/to/Dockerfiles/murfey-instrument-server -t murfey-instrument-server:<version> path/to/python-murfey
 
 # Set up the base image to build with
-FROM docker.io/library/python:3.12.8-slim-bullseye AS base
+FROM docker.io/library/python:3.12.10-slim-bookworm AS base
 
 # Install Vim in base image
 RUN apt-get update && \

Dockerfiles/murfey-rsync

@@ -1,7 +1,7 @@
 # Template build command
 # podman build --build-arg groupid=<groupid> --build-arg userid=<userid> --build-arg groupname=<groupname> --no-cache -f path/to/Dockerfiles/murfey-rsync
 
-FROM docker.io/library/alpine:3.20
+FROM docker.io/library/alpine:3.21
 # FROM alpine:3.14
 
 ARG groupid

Dockerfiles/murfey-server

@@ -2,7 +2,7 @@
 # podman build --build-arg groupid=<groupid> --build-arg userid=<userid> --build-arg groupname=<groupname> --no-cache -f path/to/Dockerfiles/murfey-server -t murfey-server:<version> path/to/python-murfey
 
 # Set up the base image to build with
-FROM docker.io/library/python:3.12.8-slim-bullseye AS base
+FROM docker.io/library/python:3.12.10-slim-bookworm AS base
 
 # Install Vim and PostgreSQL dependencies in base image
 RUN apt-get update && \

pyproject.toml

@@ -87,9 +87,10 @@ GitHub = "https://github.com/DiamondLightSource/python-murfey"
 "murfey.decrypt_password" = "murfey.cli.decrypt_db_password:run"
 "murfey.generate_key" = "murfey.cli.generate_crypto_key:run"
 "murfey.generate_password" = "murfey.cli.generate_db_password:run"
+"murfey.generate_route_manifest" = "murfey.cli.generate_route_manifest:run"
 "murfey.instrument_server" = "murfey.instrument_server:run"
 "murfey.repost_failed_calls" = "murfey.cli.repost_failed_calls:run"
-"murfey.server" = "murfey.server:run"
+"murfey.server" = "murfey.server.run:run"
 "murfey.sessions" = "murfey.cli.db_sessions:run"
 "murfey.simulate" = "murfey.cli.dummy:run"
 "murfey.spa_inject" = "murfey.cli.inject_spa_processing:run"
@@ -117,6 +118,7 @@ zip-safe = false
 
 [tool.setuptools.package-data]
 "murfey.client.tui" = ["*.css"]
+"murfey.util" = ["route_manifest.yaml"]
 
 [tool.setuptools.packages.find]
 where = ["src", "tests"]

src/murfey/bootstrap/__main__.py

@@ -7,9 +7,11 @@
 import pathlib
 import subprocess
 import sys
-from urllib.parse import urlparse
+from urllib.parse import ParseResult, urlparse
 from urllib.request import urlopen
 
+from murfey.util.api import url_path_for
+
 """
 A script to simplify installing Murfey on a network-isolated machine.
 This could in theory be invoked by
@@ -64,10 +66,13 @@
     # Construct a minimal base path string
     # Extract the host name for pip installation purposes
     try:
-        murfey_url = urlparse(args.server)
+        murfey_url: ParseResult = urlparse(args.server)
     except Exception:
         exit(f"{args.server} is not a valid URL")
+    murfey_proxy_path = murfey_url.path.rstrip("/")
     murfey_base = f"{murfey_url.scheme}://{murfey_url.netloc}"
+    if murfey_proxy_path:
+        murfey_base = f"{murfey_base}{murfey_proxy_path}"
     murfey_hostname = murfey_url.netloc.split(":")[0]
 
     # Check that Python version is supported
@@ -82,7 +87,10 @@
     # Step 1: Download pip wheel
     print()
     print(f"1/4 -- Connecting to murfey server on {murfey_base}...")
-    _download_to_file(f"{murfey_base}/bootstrap/pip.whl", "pip.whl")
+    _download_to_file(
+        f"{murfey_base}{url_path_for('bootstrap.bootstrap', 'get_pip_wheel')}",
+        "pip.whl",
+    )
 
     # Step 2: Get pip to install itself
     print()
@@ -96,7 +104,7 @@
             "--trusted-host",
             murfey_hostname,
             "-i",
-            f"{murfey_base}/pypi",
+            f"{murfey_base}{url_path_for('bootstrap.pypi', 'get_pypi_index')}",
             "pip",
         ]
     )
@@ -116,7 +124,7 @@
             "--trusted-host",
             murfey_hostname,
             "-i",
-            f"{murfey_base}/pypi",
+            f"{murfey_base}{url_path_for('bootstrap.pypi', 'get_pypi_index')}",
             "--upgrade",
             "pip",
         ]
@@ -135,7 +143,7 @@
             "--trusted-host",
             murfey_hostname,
             "-i",
-            f"{murfey_base}/pypi",
+            f"{murfey_base}{url_path_for('bootstrap.pypi', 'get_pypi_index')}",
             "murfey[client]",
         ]
     )

src/murfey/cli/generate_route_manifest.py

@@ -0,0 +1,138 @@
+"""
+CLI to generate a manifest of the FastAPI router paths present in both the instrument
+server and backend server to enable lookup of the URLs based on function name.
+"""
+
+import importlib
+import inspect
+import pkgutil
+from argparse import ArgumentParser
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+import yaml
+from fastapi import APIRouter
+
+import murfey
+
+
+def find_routers(name: str) -> dict[str, APIRouter]:
+
+    def _extract_routers_from_module(module: ModuleType):
+        routers = {}
+        for name, obj in inspect.getmembers(module):
+            if isinstance(obj, APIRouter):
+                module_path = module.__name__
+                key = f"{module_path}.{name}"
+                routers[key] = obj
+        return routers
+
+    routers = {}
+
+    # Import the module or package
+    try:
+        root = importlib.import_module(name)
+    except ImportError:
+        raise ImportError(
+            f"Cannot import '{name}'. Please ensure that you've installed all the "
+            "dependencies for the client, instrument server, and backend server "
+            "before running this command."
+        )
+
+    # If it's a package, walk through submodules and extract routers from each
+    if hasattr(root, "__path__"):
+        module_list = pkgutil.walk_packages(root.__path__, prefix=name + ".")
+        for _, module_name, _ in module_list:
+            try:
+                module = importlib.import_module(module_name)
+            except ImportError:
+                raise ImportError(
+                    f"Cannot import '{module_name}'. Please ensure that you've "
+                    "installed all the dependencies for the client, instrument "
+                    "server, and backend server before running this command."
+                )
+
+            routers.update(_extract_routers_from_module(module))
+
+    # Extract directly from single module
+    else:
+        routers.update(_extract_routers_from_module(root))
+
+    return routers
+
+
+def get_route_manifest(routers: dict[str, APIRouter]):
+
+    manifest = {}
+
+    for router_name, router in routers.items():
+        routes = []
+        for route in router.routes:
+            path_params = []
+            for param in route.dependant.path_params:
+                param_type = param.type_ if param.type_ is not None else Any
+                param_info = {
+                    "name": param.name if hasattr(param, "name") else "",
+                    "type": (
+                        param_type.__name__
+                        if hasattr(param_type, "__name__")
+                        else str(param_type)
+                    ),
+                }
+                path_params.append(param_info)
+            route_info = {
+                "path": route.path if hasattr(route, "path") else "",
+                "function": route.name if hasattr(route, "name") else "",
+                "path_params": path_params,
+                "methods": list(route.methods) if hasattr(route, "methods") else [],
+            }
+            routes.append(route_info)
+        manifest[router_name] = routes
+    return manifest
+
+
+def run():
+    # Set up additional args
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        default=False,
+        help=("Outputs the modules being inspected when creating the route manifest"),
+    )
+    args = parser.parse_args()
+
+    # Find routers
+    print("Finding routers...")
+    routers = {
+        **find_routers("murfey.instrument_server.api"),
+        **find_routers("murfey.server.api"),
+    }
+    # Generate the manifest
+    print("Extracting route information")
+    manifest = get_route_manifest(routers)
+
+    # Verify
+    if args.debug:
+        for router_name, routes in manifest.items():
+            print(f"Routes found in {router_name!r}")
+            for route in routes:
+                for key, value in route.items():
+                    print(f"\t{key}: {value}")
+                print()
+
+    # Save the manifest
+    murfey_dir = Path(murfey.__path__[0])
+    manifest_file = murfey_dir / "util" / "route_manifest.yaml"
+    with open(manifest_file, "w") as file:
+        yaml.dump(manifest, file, default_flow_style=False, sort_keys=False)
+    print(
+        "Route manifest for instrument and backend servers saved to "
+        f"{str(manifest_file)!r}"
+    )
+    exit()
+
+
+if __name__ == "__main__":
+    run()

src/murfey/cli/spa_ispyb_messages.py

@@ -18,10 +18,11 @@
 from sqlmodel import create_engine, select
 
 from murfey.client.contexts.spa import _get_xml_list_index
-from murfey.server import _murfey_id, _register
+from murfey.server.feedback import _murfey_id, _register
 from murfey.server.ispyb import ISPyBSession, TransportManager, get_session_id
 from murfey.server.murfey_db import url
 from murfey.util import db
+from murfey.util.api import url_path_for
 from murfey.util.config import get_machine_config, get_microscope, get_security_config
 
 
@@ -69,7 +70,7 @@
         help="Path to directory containing image files",
     )
     parser.add_argument(
-        "--suffic",
+        "--suffix",
         dest="suffix",
         required=True,
         type=str,
@@ -203,7 +204,9 @@
         ]
     )
     binning_factor = 1
-    server_config = requests.get(f"{args.url}/machine").json()
+    server_config = requests.get(
+        f"{args.url}{url_path_for('session_control.router', 'machine_info_by_instrument', instrument_name=args.microscope)}"
+    ).json()
     if server_config.get("superres"):
         # If camera is capable of superres and collection is in superres
         binning_factor = 2

src/murfey/cli/transfer.py

@@ -3,13 +3,14 @@
 import argparse
 import subprocess
 from pathlib import Path
-from urllib.parse import urlparse
+from urllib.parse import ParseResult, urlparse
 
 import requests
 from rich.console import Console
 from rich.prompt import Confirm
 
 from murfey.client import read_config
+from murfey.util.api import url_path_for
 from murfey.util.config import MachineConfig
 
 
@@ -35,11 +36,11 @@
     args = parser.parse_args()
 
     console = Console()
-    murfey_url = urlparse(args.server, allow_fragments=False)
+    murfey_url: ParseResult = urlparse(args.server, allow_fragments=False)
 
     machine_data = MachineConfig(
         requests.get(
-            f"{murfey_url.geturl()}/instruments/{instrument_name}/machine"
+            f"{murfey_url.geturl()}{url_path_for('session_control.router', 'machine_info_by_instrument', instrument_name=instrument_name)}"
         ).json()
     )
     if Path(args.source or ".").resolve() in machine_data.data_directories:

src/murfey/client/__init__.py

@@ -26,13 +26,26 @@
 from murfey.client.instance_environment import MurfeyInstanceEnvironment
 from murfey.client.tui.app import MurfeyTUI
 from murfey.client.tui.status_bar import StatusBar
-from murfey.util.client import _get_visit_list, authorised_requests, read_config
+from murfey.util.api import url_path_for
+from murfey.util.client import authorised_requests, read_config
+from murfey.util.models import Visit
 
 log = logging.getLogger("murfey.client")
 
 requests.get, requests.post, requests.put, requests.delete = authorised_requests()
 
 
+def _get_visit_list(api_base: ParseResult, instrument_name: str):
+    proxy_path = api_base.path.rstrip("/")
+    get_visits_url = api_base._replace(
+        path=f"{proxy_path}{url_path_for('session_control.router', 'get_current_visits', instrument_name=instrument_name)}"
+    )
+    server_reply = requests.get(get_visits_url.geturl())
+    if server_reply.status_code != 200:
+        raise ValueError(f"Server unreachable ({server_reply.status_code})")
+    return [Visit.parse_obj(v) for v in server_reply.json()]
+
+
 def write_config(config: configparser.ConfigParser):
     mcch = os.environ.get("MURFEY_CLIENT_CONFIG_HOME")
     murfey_client_config_home = Path(mcch) if mcch else Path.home()
@@ -262,7 +275,9 @@
     rich_handler.setLevel(logging.DEBUG if args.debug else logging.INFO)
 
     # Set up websocket app and handler
-    client_id = requests.get(f"{murfey_url.geturl()}/new_client_id/").json()
+    client_id = requests.get(
+        f"{murfey_url.geturl()}{url_path_for('session_control.router', 'new_client_id')}"
+    ).json()
     ws = murfey.client.websocket.WSApp(
         server=args.server,
         id=client_id["new_id"],
@@ -279,7 +294,7 @@
 
     # Load machine data for subsequent sections
     machine_data = requests.get(
-        f"{murfey_url.geturl()}/instruments/{instrument_name}/machine"
+        f"{murfey_url.geturl()}{url_path_for('session_control.router', 'machine_info_by_instrument', instrument_name=instrument_name)}"
     ).json()
     gain_ref: Path | None = None
 

src/murfey/client/analyser.py

@@ -82,6 +82,9 @@ def __init__(
             else {}
         )
 
+    def __repr__(self) -> str:
+        return f"<Analyser ({self._basepath})>"
+
     def _find_extension(self, file_path: Path):
         """
         Identifies the file extension and stores that information in the class.