Renamed 'ServerConfig' to 'GlobalConfig' and 'get_security_config' to 'get_global_config'

Author: tieneupin

src/murfey/cli/add_user.py

@@ -4,7 +4,7 @@
 
 from murfey.server.api.auth import hash_password
 from murfey.server.murfey_db import url
-from murfey.util.config import get_security_config
+from murfey.util.config import get_global_config
 from murfey.util.db import MurfeyUser as User
 
 
@@ -21,7 +21,7 @@ def run():
     new_user = User(
         username=args.username, hashed_password=hash_password(args.password)
     )
-    _url = url(get_security_config())
+    _url = url(get_global_config())
     engine = create_engine(_url)
     with Session(engine) as murfey_db:
         murfey_db.add(new_user)

src/murfey/cli/decrypt_db_password.py

@@ -2,7 +2,7 @@
 
 from cryptography.fernet import Fernet
 
-from murfey.util.config import get_security_config
+from murfey.util.config import get_global_config
 
 
 def run():
@@ -12,6 +12,6 @@ def run():
 
     args = parser.parse_args()
 
-    security_config = get_security_config()
-    f = Fernet(security_config.crypto_key.encode("ascii"))
+    global_config = get_global_config()
+    f = Fernet(global_config.crypto_key.encode("ascii"))
     print(f.decrypt(args.password.encode("ascii")).decode())

src/murfey/cli/generate_db_password.py

@@ -3,12 +3,12 @@
 
 from cryptography.fernet import Fernet
 
-from murfey.util.config import get_security_config
+from murfey.util.config import get_global_config
 
 
 def run():
-    security_config = get_security_config()
-    f = Fernet(security_config.crypto_key.encode("ascii"))
+    global_config = get_global_config()
+    f = Fernet(global_config.crypto_key.encode("ascii"))
     alphabet = string.ascii_letters + string.digits
     password = "".join(secrets.choice(alphabet) for i in range(32))
     print(f.encrypt(password.encode("ascii")).decode())

src/murfey/cli/inject_spa_processing.py

@@ -10,7 +10,7 @@
 
 from murfey.server.ispyb import TransportManager
 from murfey.server.murfey_db import url
-from murfey.util.config import get_machine_config, get_microscope, get_security_config
+from murfey.util.config import get_global_config, get_machine_config, get_microscope
 from murfey.util.db import (
     AutoProcProgram,
     ClientEnvironment,
@@ -97,13 +97,13 @@ def run():
         os.environ["BEAMLINE"] = args.microscope
 
     machine_config = get_machine_config()
-    security_config = get_security_config()
+    global_config = get_global_config()
     _url = url(machine_config)
     engine = create_engine(_url)
     murfey_db = Session(engine)
 
     _transport_object = TransportManager(args.transport)
-    _transport_object.feedback_queue = security_config.feedback_queue
+    _transport_object.feedback_queue = global_config.feedback_queue
 
     query = (
         select(Movie)

src/murfey/cli/spa_ispyb_messages.py

@@ -22,7 +22,7 @@
 from murfey.server.ispyb import Session, TransportManager, get_session_id
 from murfey.server.murfey_db import url
 from murfey.util import db
-from murfey.util.config import get_machine_config, get_microscope, get_security_config
+from murfey.util.config import get_global_config, get_machine_config, get_microscope
 
 
 def run():
@@ -341,7 +341,7 @@ def run():
         .where(db.ProcessingJob.recipe == "em-spa-preprocess")
     ).one()
     machine_config = get_machine_config()
-    security_config = get_security_config()
+    global_config = get_global_config()
     params = db.SPARelionParameters(
         pj_id=collected_ids[2].id,
         angpix=float(metadata["pixel_size_on_image"]) * 1e10,
@@ -378,7 +378,7 @@ def run():
 
     if args.flush_preprocess:
         _transport_object = TransportManager(args.transport)
-        _transport_object.feedback_queue = security_config.feedback_queue
+        _transport_object.feedback_queue = global_config.feedback_queue
         stashed_files = murfey_db.exec(
             select(db.PreprocessStash)
             .where(db.PreprocessStash.session_id == args.session_id)

src/murfey/server/__init__.py

@@ -51,10 +51,10 @@
 from murfey.util import LogFilter
 from murfey.util.config import (
     MachineConfig,
+    get_global_config,
     get_hostname,
     get_machine_config,
     get_microscope,
-    get_security_config,
 )
 from murfey.util.spa_params import default_spa_parameters
 from murfey.util.state import global_state
@@ -74,7 +74,7 @@
 _transport_object: TransportManager | None = None
 
 try:
-    _url = url(get_security_config())
+    _url = url(get_global_config())
     engine = create_engine(_url)
     murfey_db = Session(engine, expire_on_commit=False)
 except Exception:
@@ -296,9 +296,9 @@ def run():
     # Set up logging now that the desired verbosity is known
     _set_up_logging(quiet=args.quiet, verbosity=args.verbose)
 
-    security_config = get_security_config()
+    global_config = get_global_config()
     if not args.temporary and _transport_object:
-        _transport_object.feedback_queue = security_config.feedback_queue
+        _transport_object.feedback_queue = global_config.feedback_queue
     rabbit_thread = Thread(
         target=feedback_listen,
         daemon=True,

src/murfey/server/api/auth.py

@@ -19,7 +19,7 @@
 
 from murfey.server import sanitise
 from murfey.server.murfey_db import murfey_db, url
-from murfey.util.config import get_machine_config, get_security_config
+from murfey.util.config import get_global_config, get_machine_config
 from murfey.util.db import MurfeyUser as User
 from murfey.util.db import Session as MurfeySession
 
@@ -63,19 +63,19 @@ async def __call__(self, request: Request):
 
 
 # Set up variables used for authentication
-security_config = get_security_config()
+global_config = get_global_config()
 machine_config = get_machine_config()
 auth_url = (
     machine_config[os.getenv("BEAMLINE", "")].auth_url
     if machine_config.get(os.getenv("BEAMLINE", ""))
     else ""
 )
-ALGORITHM = security_config.auth_algorithm or "HS256"
-SECRET_KEY = security_config.auth_key or secrets.token_hex(32)
-if security_config.auth_type == "password":
+ALGORITHM = global_config.auth_algorithm or "HS256"
+SECRET_KEY = global_config.auth_key or secrets.token_hex(32)
+if global_config.auth_type == "password":
     oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 else:
-    oauth2_scheme = CookieScheme(cookie_key=security_config.cookie_key)
+    oauth2_scheme = CookieScheme(cookie_key=global_config.cookie_key)
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 instrument_server_tokens: Dict[float, dict] = {}
@@ -96,7 +96,7 @@ def hash_password(password: str) -> str:
 
 # Set up database engine
 try:
-    _url = url(security_config)
+    _url = url(global_config)
     engine = create_engine(_url)
 except Exception:
     engine = None
@@ -114,7 +114,7 @@ def validate_user(username: str, password: str) -> bool:
 def validate_visit(visit_name: str, token: str) -> bool:
     if validators := entry_points().select(
         group="murfey.auth.session_validation",
-        name=security_config.auth_type,
+        name=global_config.auth_type,
     ):
         return validators[0].load()(visit_name, token)
     return True
@@ -166,12 +166,12 @@ async def validate_token(token: Annotated[str, Depends(oauth2_scheme)]):
         if auth_url:
             headers = (
                 {}
-                if security_config.auth_type == "cookie"
+                if global_config.auth_type == "cookie"
                 else {"Authorization": f"Bearer {token}"}
             )
             cookies = (
-                {security_config.cookie_key: token}
-                if security_config.auth_type == "cookie"
+                {global_config.cookie_key: token}
+                if global_config.auth_type == "cookie"
                 else {}
             )
             async with aiohttp.ClientSession(cookies=cookies) as session:
@@ -186,7 +186,7 @@ async def validate_token(token: Annotated[str, Depends(oauth2_scheme)]):
         else:
             if validators := entry_points().select(
                 group="murfey.auth.token_validation",
-                name=security_config.auth_type,
+                name=global_config.auth_type,
             ):
                 validators[0].load()(token)
             else:
@@ -290,8 +290,8 @@ async def mint_session_token(session_id: MurfeySessionID, db=murfey_db):
         db.exec(select(MurfeySession).where(MurfeySession.id == session_id)).one().visit
     )
     expiry_time = None
-    if security_config.session_token_timeout:
-        expiry_time = time.time() + security_config.session_token_timeout
+    if global_config.session_token_timeout:
+        expiry_time = time.time() + global_config.session_token_timeout
     token = create_access_token(
         {
             "session": session_id,

src/murfey/server/api/clem.py

@@ -76,6 +76,8 @@ def validate_and_sanitise(
     machine_config = get_machine_config(instrument_name=instrument_name)[
         instrument_name
     ]
+    if not machine_config.rsync_basepath:
+        raise ValueError("rsync basepath not set")
     base_path = machine_config.rsync_basepath.as_posix()
 
     # Check that full file path doesn't contain unallowed characters

src/murfey/server/main.py

@@ -21,7 +21,7 @@
 import murfey.server.websocket
 import murfey.util.models
 from murfey.server import template_files
-from murfey.util.config import get_security_config
+from murfey.util.config import get_global_config
 
 # Import Murfey server or demo server based on settings
 if os.getenv("MURFEY_DEMO"):
@@ -39,7 +39,7 @@ class Settings(BaseSettings):
     murfey_machine_configuration: str = ""
 
 
-security_config = get_security_config()
+global_config = get_global_config()
 
 settings = Settings()
 
@@ -50,7 +50,7 @@ class Settings(BaseSettings):
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=security_config.allow_origins,
+    allow_origins=global_config.allow_origins,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],

src/murfey/server/murfey_db.py

@@ -8,23 +8,23 @@
 from sqlalchemy.pool import NullPool
 from sqlmodel import Session, create_engine
 
-from murfey.util.config import ServerConfig, get_security_config
+from murfey.util.config import GlobalConfig, get_global_config
 
 
-def url(security_config: ServerConfig | None = None) -> str:
-    security_config = security_config or get_security_config()
-    with open(security_config.murfey_db_credentials, "r") as stream:
+def url(global_config: GlobalConfig | None = None) -> str:
+    global_config = global_config or get_global_config()
+    with open(global_config.murfey_db_credentials, "r") as stream:
         creds = yaml.safe_load(stream)
-    f = Fernet(security_config.crypto_key.encode("ascii"))
+    f = Fernet(global_config.crypto_key.encode("ascii"))
     p = f.decrypt(creds["password"].encode("ascii"))
     return f"postgresql+psycopg2://{creds['username']}:{p.decode()}@{creds['host']}:{creds['port']}/{creds['database']}"
 
 
 def get_murfey_db_session(
-    security_config: ServerConfig | None = None,
+    global_config: GlobalConfig | None = None,
 ) -> Session:  # type: ignore
-    _url = url(security_config)
-    if security_config and not security_config.sqlalchemy_pooling:
+    _url = url(global_config)
+    if global_config and not global_config.sqlalchemy_pooling:
         engine = create_engine(_url, poolclass=NullPool)
     else:
         engine = create_engine(_url)
@@ -37,7 +37,7 @@ def get_murfey_db_session(
 
 murfey_db_session = partial(
     get_murfey_db_session,
-    get_security_config(),
+    get_global_config(),
 )
 
 murfey_db: Session = Depends(murfey_db_session)