rcdb 2.3.2__tar.gz → 2.4.0__tar.gz

{rcdb-2.3.2/rcdb.egg-info → rcdb-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rcdb
-Version: 2.3.2
+Version: 2.4.0
 Summary: RCDB - Run Conditions DataBase
 Author-email: Dmitry Romanov <romanov@jlab.org>
 License-Expression: MIT

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/app_context.py

@@ -28,7 +28,7 @@ class RcdbApplicationContext(object):
         Python 3.13+ leaks a ``ResourceWarning: unclosed database``).
         """
         if self._db_instance is not None:
-            self._db_instance.disconnect()
+            self._db_instance.close()
             self._db_instance = None
 
     def require_connected_db(self) -> RCDBProvider:

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/cli/db.py

@@ -24,6 +24,7 @@ def db_command(ctx):
             print("ERROR connection string is missing.")
             exit(1)
         provider.connect(connection_str, check_version=False)
+        ctx.call_on_close(provider.close)
         query = select(SchemaVersion).order_by(SchemaVersion.version.desc())
         schema_version, = provider.session.execute(query).first()
         print("Schema version: {} - '{}'".format(schema_version.version, schema_version.comment))
@@ -88,6 +89,7 @@ def _print_sqlite_table_sizes(engine):
 @pass_rcdb_context
 def update(context):
     provider = RCDBProvider(context.connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
 
     # Check something exists
     if not sqlalchemy.inspect(provider.engine).has_table(SchemaVersion.__tablename__):
@@ -117,6 +119,7 @@ def update(context):
         return
 
     provider = RCDBProvider(context.connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
 
     # Create alias table
     Alias.__table__.create(provider.engine)
@@ -181,6 +184,7 @@ def init(context, drop_all, no_defaults, confirm, add_tests, add_cpp_tests):
     # That we will need for DB
     metadata = rcdb.model.Base.metadata
     provider = RCDBProvider(context.connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
 
     # Drop all if needed
     if drop_all:

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/cli/rp.py

@@ -55,6 +55,7 @@ def add(context, name, description, run_min, run_max, start_date, end_date):
 
     provider = RCDBProvider()
     provider.connect(connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
     session = provider.session
 
     # Convert date strings to Date objects if provided
@@ -104,6 +105,7 @@ def rm(context, period_id, yes):
 
     provider = RCDBProvider()
     provider.connect(connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
     session = provider.session
 
     rp_item = session.query(RunPeriod).filter(RunPeriod.id == period_id).one_or_none()
@@ -142,6 +144,7 @@ def update(context, period_id, name, description, run_min, run_max, start_date,
 
     provider = RCDBProvider()
     provider.connect(connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
     session = provider.session
 
     rp_item = session.query(RunPeriod).filter(RunPeriod.id == period_id).one_or_none()

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/provider.py

@@ -133,23 +133,33 @@ class RCDBProvider(object):
         self._connection_string = connection_string
 
         if check_version:
-            db_version = self.get_schema_version()
-            if db_version != rcdb.SQL_SCHEMA_VERSION:
-                message = "SQL schema version doesn't match. " \
-                          "Retrieved DB version is {0}, required version is {1}. " \
-                    .format(db_version, rcdb.SQL_SCHEMA_VERSION)
-                if db_version is not None and db_version < rcdb.SQL_SCHEMA_VERSION:
-                    message += "The database schema is older than this RCDB version. " \
-                               "Run 'rcdb db update' to migrate the database to the current schema."
-                else:
-                    message += "The database schema is newer than this RCDB version. " \
-                               "Update your RCDB installation to match the database."
-                raise rcdb.errors.SqlSchemaVersionError(message)
+            # This version query is the first statement that actually opens a
+            # DB connection. If it fails (unreachable host, access denied, wrong
+            # schema, ...) the engine/session we just built must be disposed
+            # here: the exception propagates out of connect()/__init__, so the
+            # caller never receives this provider to disconnect() it themselves,
+            # and the engine's open connection would otherwise leak until GC.
+            try:
+                db_version = self.get_schema_version()
+                if db_version != rcdb.SQL_SCHEMA_VERSION:
+                    message = "SQL schema version doesn't match. " \
+                              "Retrieved DB version is {0}, required version is {1}. " \
+                        .format(db_version, rcdb.SQL_SCHEMA_VERSION)
+                    if db_version is not None and db_version < rcdb.SQL_SCHEMA_VERSION:
+                        message += "The database schema is older than this RCDB version. " \
+                                   "Run 'rcdb db update' to migrate the database to the current schema."
+                    else:
+                        message += "The database schema is newer than this RCDB version. " \
+                                   "Update your RCDB installation to match the database."
+                    raise rcdb.errors.SqlSchemaVersionError(message)
+            except Exception:
+                self.close()
+                raise
 
     # ------------------------------------------------
     # Closes connection to data
     # ------------------------------------------------
-    def disconnect(self):
+    def close(self):
         """Closes connection to database.
 
         Closes the ORM session and disposes the SQLAlchemy engine so the
@@ -164,6 +174,11 @@ class RCDBProvider(object):
         if self.engine is not None:
             self.engine.dispose()
 
+    # ``disconnect`` is the historical name for ``close``; kept as an alias so
+    # existing RCDB code and users keep working while new code standardizes on
+    # ``close()`` (the conventional name other resource-holding objects use).
+    disconnect = close
+
     # -------------------------------------------------
     # indicates ether the connection is open or not
     # -------------------------------------------------

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/version.py

@@ -1,5 +1,5 @@
 # String version. Used both for setup.py and for internal code
-version = '2.3.2'
+version = '2.4.0'
 
 # version as the tuple of ints
 version_tuple = tuple(int(val) for val in version.split('.'))

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/web/__init__.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from urllib.parse import urlparse
 
 from flask import Flask, render_template, g, request, url_for
+from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import subqueryload
 
 import rcdb
@@ -60,8 +61,13 @@ app = Flask(__name__, template_folder=template_folder)
 
 app.config.from_object(__name__)
 
-@app.before_request
-def before_request():
+def _resolve_active_database():
+    """Pick the connection string for this request and expose selector state.
+
+    Sets ``g.active_db_name`` / ``g.available_databases`` (used by the navbar DB
+    selector) and returns the connection string to connect to. Does not touch
+    the database -- only reads config and the ``rcdb_database`` cookie.
+    """
     available_dbs = app.config.get("AVAILABLE_DATABASES", {})
 
     if available_dbs:
@@ -90,24 +96,93 @@ def before_request():
             # No default set, use first available
             active_name = next(iter(available_dbs))
 
-        connection_string = available_dbs[active_name]
         g.active_db_name = active_name
         g.available_databases = available_dbs
-    else:
-        # Original single-database behavior
-        connection_string = app.config["SQL_CONNECTION_STRING"]
-        g.active_db_name = None
-        g.available_databases = {}
-
-    g.tdb = rcdb.ConfigurationProvider()
-    g.tdb.connect(connection_string)
+        return available_dbs[active_name]
+
+    # Original single-database behavior
+    g.active_db_name = None
+    g.available_databases = {}
+    return app.config["SQL_CONNECTION_STRING"]
+
+
+@app.before_request
+def before_request():
+    # Never gate static assets on the database -- the graceful DB-error page
+    # below still needs its CSS/JS to load when the DB is unreachable.
+    if request.endpoint == "static":
+        return None
+
     app.jinja_env.globals['datetime_now'] = datetime.now
 
+    # Resolve the selector state first so the navbar (and the DB-error page)
+    # can render even if the connection below fails.
+    connection_string = _resolve_active_database()
+
+    # Connect fresh, per request. A DB access/connection failure (access
+    # denied, too many connections, timeout, host down, ...) must degrade
+    # gracefully instead of surfacing a raw 500 -- and must not poison any
+    # cookie or cached engine, so a later reload recovers once the DB is back.
+    try:
+        g.tdb = rcdb.ConfigurationProvider()
+        g.tdb.connect(connection_string)
+    except SQLAlchemyError:
+        return _render_db_error(connection_string)
+
+    return None
+
+
+def _render_db_error(connection_string):
+    """Log the full failure detail and render the sanitized DB-error page.
+
+    The *log* gets everything an admin needs (which database, the underlying
+    pymysql/SQLAlchemy error code + message, and the stack trace). The *page*
+    gets none of it -- no connection string, host, user, or exception text --
+    only a red "DB connection failure" strip with the top menu (and the DB
+    selector) intact so the visitor can switch to a working database.
+    """
+    logger.exception(
+        "DB connection/access failure for database '%s' (%s); serving graceful "
+        "error page instead of a 500.",
+        getattr(g, "active_db_name", None) or "<default>",
+        _connection_hint(connection_string),
+    )
+
+    # Drop the half-built provider so its engine/pool is released now rather
+    # than lingering as a broken cached connection -- the teardown below only
+    # disposes fully-connected providers.
+    broken = getattr(g, "tdb", None)
+    if broken is not None:
+        try:
+            broken.close()
+        except Exception:
+            logger.debug("Ignoring error while disposing failed DB engine.",
+                         exc_info=True)
+        g.tdb = None
+
+    # 503 Service Unavailable: the failure is transient-friendly (e.g. "too
+    # many connections" recovers), so signal a retryable condition rather than
+    # a 200 or a permanent error. A plain reload after recovery renders fine.
+    return render_template("db_error.html"), 503
+
+
+@app.errorhandler(SQLAlchemyError)
+def handle_db_error(error):
+    """Catch DB errors raised while a view runs (not just at connect time).
+
+    ``before_request`` already handles the common case (``connect()`` exercises
+    the connection via the schema-version check), but a lazily-issued query in
+    a view can still raise. Route those through the same graceful page instead
+    of a 500. ``g.active_db_name`` / ``g.available_databases`` were set by
+    ``before_request`` before the failure, so the selector still renders.
+    """
+    return _render_db_error(getattr(g.get("tdb", None), "connection_string", ""))
+
 
 @app.teardown_request
 def teardown_request(exception):
-    tdb = getattr(g, 'db', None)
-    if tdb:
+    tdb = getattr(g, 'tdb', None)
+    if tdb is not None:
         tdb.close()
 
 

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb/web/modules/runs.py

@@ -157,8 +157,11 @@ def elog(run_number):
         from urllib.request import urlopen
         from urllib.error import HTTPError
     try:
-        elog_json = urlopen('https://logbooks.jlab.org/api/elog/entries?book=hdrun&title=Run_{}&limit=1'
-                            .format(run_number)).read()
+        # Context-manage the response so the underlying socket is closed
+        # deterministically instead of leaking until GC.
+        with urlopen('https://logbooks.jlab.org/api/elog/entries?book=hdrun&title=Run_{}&limit=1'
+                     .format(run_number)) as response:
+            elog_json = response.read()
     except HTTPError as e:
         return jsonify(stat=str(e.code))
 

rcdb-2.4.0/rcdb/web/templates/db_error.html

@@ -0,0 +1,20 @@
+{% extends "layouts/base.html" %}
+
+{% block title %}Database unavailable{% endblock %}
+
+{#
+    Graceful page shown when the selected database cannot be reached or used
+    (access denied, too many connections, timeout, host down, ...). The top
+    menu -- including the database selector -- is inherited from base.html so
+    the visitor can switch to a working database and reload. No connection
+    string, host, user, or exception text is exposed here; the full detail is
+    written to the application log instead.
+#}
+
+{% block body %}
+    <div class="alert alert-danger"
+         role="alert"
+         style="text-align: center; font-weight: bold; margin-top: 20px;">
+        DB connection failure
+    </div>
+{% endblock %}

{rcdb-2.3.2 → rcdb-2.4.0/rcdb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rcdb
-Version: 2.3.2
+Version: 2.4.0
 Summary: RCDB - Run Conditions DataBase
 Author-email: Dmitry Romanov <romanov@jlab.org>
 License-Expression: MIT

{rcdb-2.3.2 → rcdb-2.4.0}/rcdb.egg-info/SOURCES.txt

@@ -155,6 +155,7 @@ rcdb/web/static/js/webintellisense-textbox.js
 rcdb/web/static/js/webintellisense.js
 rcdb/web/templates/404.html
 rcdb/web/templates/custom_column_run_table.html
+rcdb/web/templates/db_error.html
 rcdb/web/templates/default_run_table.html
 rcdb/web/templates/index.html
 rcdb/web/templates/layout.html
@@ -217,4 +218,5 @@ tests/test_save_files.py
 tests/test_select_runs.py
 tests/test_select_values.py
 tests/test_sql_schema_version.py
-tests/test_value_comparison.py
+tests/test_value_comparison.py
+tests/test_web_db_failure.py

rcdb-2.4.0/tests/test_web_db_failure.py

@@ -0,0 +1,119 @@
+"""Web DB-failure handling.
+
+A database selected in the navbar (stored in the ``rcdb_database`` cookie) may
+be unreachable or access-denied server-side (e.g. the MariaDB ``rcdb`` user has
+no GRANT on ``xem2``/``pionct`` -> pymysql ``(1044, "Access denied ...")``).
+
+These tests pin the required behaviour:
+
+* such a failure renders a graceful page (top menu + DB selector + a red
+  "DB connection failure" strip), never a raw 500;
+* no sensitive detail (connection string, host, user, error code/text) leaks
+  into the page, while the full exception is written to the application log;
+* the failure is not sticky -- reloading after the DB recovers, or switching to
+  a working DB, renders normally with no poisoned cookie or cached engine.
+"""
+
+import unittest
+
+from sqlalchemy.exc import OperationalError
+
+import rcdb
+import rcdb.provider
+import rcdb.web
+
+
+class TestWebDbFailure(unittest.TestCase):
+    def setUp(self):
+        self.app = rcdb.web.app
+        self.app.testing = True
+
+        # Save config we mutate so other tests see the app untouched.
+        self._saved = {k: self.app.config.get(k) for k in
+                       ("AVAILABLE_DATABASES", "DEFAULT_DATABASE")}
+        self.app.config["AVAILABLE_DATABASES"] = {
+            "good": "sqlite:///good",
+            "bad": "sqlite:///bad",
+        }
+        self.app.config["DEFAULT_DATABASE"] = "sqlite:///good"
+
+        self.client = self.app.test_client()
+
+        # Replace connect(): raise an access-denied-style OperationalError for the
+        # "bad" DB (while it is "down"); connect a fresh in-memory schema for the
+        # "good" one. ``bad_down`` flips to False to simulate recovery.
+        self.bad_down = True
+        self._orig_connect = rcdb.ConfigurationProvider.connect
+        test = self
+
+        def fake_connect(provider, connection_string="", check_version=True):
+            if "bad" in connection_string and test.bad_down:
+                raise OperationalError(
+                    "SELECT 1", {},
+                    Exception("(1044, \"Access denied for user 'rcdb'@'%' "
+                              "to database 'bad'\")"))
+            test._orig_connect(provider, "sqlite://", check_version=False)
+            rcdb.provider.destroy_all_create_schema(provider)
+
+        rcdb.ConfigurationProvider.connect = fake_connect
+
+    def tearDown(self):
+        rcdb.ConfigurationProvider.connect = self._orig_connect
+        for k, v in self._saved.items():
+            if v is None:
+                self.app.config.pop(k, None)
+            else:
+                self.app.config[k] = v
+
+    def _get(self, path="/", db=None):
+        # Fresh client per call so the cookie jar carries only what we set here
+        # (the Werkzeug test client ignores a raw Cookie header, hence set_cookie).
+        client = self.app.test_client()
+        if db:
+            client.set_cookie("rcdb_database", db)
+        return client.get(path)
+
+    def test_failure_renders_graceful_page_not_500(self):
+        with self.assertLogs("rcdb.web", level="ERROR") as cm:
+            resp = self._get("/", db="bad")
+
+        # Graceful, retryable status -- never a raw 500.
+        self.assertEqual(resp.status_code, 503)
+        self.assertNotEqual(resp.status_code, 500)
+
+        body = resp.get_data(as_text=True)
+        # Red strip + intact top menu incl. the DB selector to switch away.
+        self.assertIn("DB connection failure", body)
+        self.assertIn('id="dbSelector"', body)
+        self.assertIn(">bad<", body)
+        self.assertIn(">good<", body)
+
+        # No sensitive detail leaks into the page ...
+        for secret in ("1044", "Access denied", "sqlite:///bad", "rcdb@",
+                       "OperationalError", "Traceback"):
+            self.assertNotIn(secret, body)
+
+        # ... but the log has the full picture (db name + underlying error).
+        logtext = "\n".join(cm.output)
+        self.assertIn("bad", logtext)
+        self.assertIn("1044", logtext)
+
+    def test_reload_recovers_after_db_comes_back(self):
+        # Same cookie, DB down -> graceful 503.
+        self.assertEqual(self._get("/", db="bad").status_code, 503)
+
+        # DB recovers; a plain reload (identical cookie) must render normally.
+        self.bad_down = False
+        resp = self._get("/", db="bad")
+        self.assertEqual(resp.status_code, 200)
+        self.assertNotIn("DB connection failure", resp.get_data(as_text=True))
+
+    def test_switching_to_working_db_recovers(self):
+        self.assertEqual(self._get("/", db="bad").status_code, 503)
+        resp = self._get("/", db="good")
+        self.assertEqual(resp.status_code, 200)
+        self.assertNotIn("DB connection failure", resp.get_data(as_text=True))
+
+
+if __name__ == "__main__":
+    unittest.main()