jaaql-middleware-python 5.3.2__tar.gz → 5.3.4__tar.gz

{jaaql_middleware_python-5.3.2/jaaql_middleware_python.egg-info → jaaql_middleware_python-5.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaaql-middleware-python
-Version: 5.3.2
+Version: 5.3.4
 Summary: The jaaql package, allowing for rapid development and deployment of RESTful HTTP applications
 Home-page: https://github.com/JAAQL/JAAQL-middleware-python
 Author: Software Quality Measurement and Improvement bv

{jaaql_middleware_python-5.3.2 → jaaql_middleware_python-5.3.4}/jaaql/constants.py

@@ -218,5 +218,5 @@ ROLE__dba = "dba"
 
 PROTOCOL__postgres = "postgresql://"
 
-VERSION = "5.3.2"
+VERSION = "5.3.4"
 

{jaaql_middleware_python-5.3.2 → jaaql_middleware_python-5.3.4}/jaaql/db/db_interface.py

@@ -77,6 +77,11 @@ class DBInterface(ABC):
             logging.warning(exc, exc_info=False)
 
     def __attempt_commit_rollback(self, conn, err):
+        # Returns the commit failure rather than swallowing it. A failed commit means the transaction
+        # did NOT persist, so the caller must not report success. Silently swallowing it turned lost
+        # writes into a misleading downstream error - e.g. create_account's CREATE ROLE lost on a
+        # connection killed by a \wipe dbms reboot, then "GRANT registered TO <role>" failing with
+        # "role does not exist" on the very next statement.
         try:
             if err is None:
                 self.commit(conn)
@@ -84,9 +89,11 @@ class DBInterface(ABC):
                 self.rollback(conn)
         except Exception as ex:
             if err is None:
-                self.log_warning(ex)  # error committing. User stuffed up the SQL
+                self.log_warning(ex)  # commit failed - the transaction did not persist
+                return ex
             else:
                 self.log_critical(ex)  # error rolling back. It is serious
+        return None
 
     def __err_to_exception(self, err, echo):
         if err is not None:
@@ -102,18 +109,28 @@ class DBInterface(ABC):
                 raise ex
 
     def handle_error(self, conn, err, echo=ECHO__none):
-        self.__attempt_commit_rollback(conn, err)
+        commit_err = self.__attempt_commit_rollback(conn, err)
+        if err is None and commit_err is not None:
+            raise HttpStatusException("Commit failed, transaction not persisted: " + str(commit_err),
+                                      HTTPStatus.INTERNAL_SERVER_ERROR)
         self.__err_to_exception(err, echo)
 
     def put_conn_handle_error(self, conn, err, echo=ECHO__none, skip_rollback_commit: bool = False):
+        commit_err = None
         if not skip_rollback_commit:
-            self.__attempt_commit_rollback(conn, err)
+            commit_err = self.__attempt_commit_rollback(conn, err)
 
         try:
             self.put_conn(conn)
         except Exception as ex:
             self.log_warning(ex)
 
+        # A failed commit persisted nothing; surface it (instead of the old silent swallow) so the
+        # caller does not treat lost writes as success and hit a misleading error further on.
+        if err is None and commit_err is not None:
+            raise HttpStatusException("Commit failed, transaction not persisted: " + str(commit_err),
+                                      HTTPStatus.INTERNAL_SERVER_ERROR)
+
         self.__err_to_exception(err, echo)
 
     @abstractmethod

{jaaql_middleware_python-5.3.2 → jaaql_middleware_python-5.3.4}/jaaql/db/db_pg_interface.py

@@ -22,6 +22,18 @@ PGCONN__max_conns = 10
 
 TIMEOUT = 2.5
 
+# Upper bound on how long a request waits for the parallel auth verifier's verdict before failing
+# closed. Kept below the nginx proxy read timeout so the worker unwinds and returns its connection
+# rather than the request dying at the proxy while the worker hangs on holding an open transaction.
+WAIT_HOOK__timeout = 30
+ERR__verification_timed_out = "Authorization verification timed out"
+
+# libpq TCP keepalives: detect a peer that vanishes (DB reboot, network drop) within ~25s so the
+# socket errors instead of a read blocking indefinitely. Without this the single serial
+# auth-verification thread can wedge forever on a dead connection and, via the wait below, take
+# every authenticated request down with it. Ignored by libpq for unix-socket connections.
+CONN_STR__keepalives = " keepalives=1 keepalives_idle=10 keepalives_interval=5 keepalives_count=3"
+
 ERR__invalid_role = "Role not allowed, invalid format!"
 ERR__must_use_canned_query = "Must use canned query as you are not an admin!"
 
@@ -135,6 +147,21 @@ class DBPGInterface(DBInterface):
         DBPGInterface.HOST_POOLS = {}
         DBPGInterface.HOST_POOLS_QUEUES = {}
 
+    @staticmethod
+    def check_all_pools():
+        # Force a synchronous liveness check of every pooled connection, discarding and replacing any
+        # that are broken. clean() reboots Postgres, and background activity (the per-minute cron, the
+        # auth verifier) can re-open pools DURING the reboot/reinstall window, caching connections to
+        # the old postmaster. psycopg_pool only detects those lazily, so the first real request after
+        # the wipe (e.g. \register @dba) gets handed a dead connection whose commit then fails "the
+        # connection is lost". Calling this once Postgres is stable makes the refresh deterministic.
+        for _, user_pool_dict in DBPGInterface.HOST_POOLS.items():
+            for _, pool in user_pool_dict.items():
+                try:
+                    pool.check()
+                except Exception:
+                    pass
+
     @staticmethod
     def _process_returned_conn(username: str, db_name: str, conn, do_reset: bool):
         if isinstance(conn, JaaqlPGConnection) and conn.jaaql_has_pending_auth():
@@ -199,6 +226,8 @@ class DBPGInterface(DBInterface):
                 if str(port) != "5432":
                     conn_str += " port=" + str(port)
 
+                conn_str += CONN_STR__keepalives
+
                 self.conn_str = conn_str
 
                 if self.db_name not in user_pool:
@@ -309,7 +338,14 @@ class DBPGInterface(DBInterface):
                     do_prepare = prepare and _statement_is_preparable(query)
 
                     if wait_hook:
-                        res, err, code = wait_hook.get()
+                        try:
+                            res, err, code = wait_hook.get(timeout=WAIT_HOOK__timeout)
+                        except queue.Empty:
+                            # The parallel verifier never delivered a verdict (its single serial thread
+                            # wedged, e.g. on a connection killed by a DB reboot). Fail closed and let
+                            # the worker unwind - without this bound the worker blocks forever holding
+                            # an open transaction, and enough of them starve the pool into nginx 504s.
+                            raise Exception(ERR__verification_timed_out)
                         if not res:
                             if code == 500:
                                 raise Exception(err)

{jaaql_middleware_python-5.3.2 → jaaql_middleware_python-5.3.4}/jaaql/mvc/model.py

@@ -1457,6 +1457,11 @@ WHERE
             self.vault.get_obj(VAULT_KEY__jaaql_db_password)
         )
 
+        # Postgres was just rebooted and reinstalled. Discard any connections opened against the old
+        # postmaster during that window (by the cron/verifier/install) so the next request cannot be
+        # handed a dead connection whose commit silently fails. Runs once per wipe - no per-request cost.
+        DBPGInterface.check_all_pools()
+
     def execute_migrations(self, connection: DBInterface):
         self.is_super_admin(connection)
 

{jaaql_middleware_python-5.3.2 → jaaql_middleware_python-5.3.4/jaaql_middleware_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaaql-middleware-python
-Version: 5.3.2
+Version: 5.3.4
 Summary: The jaaql package, allowing for rapid development and deployment of RESTful HTTP applications
 Home-page: https://github.com/JAAQL/JAAQL-middleware-python
 Author: Software Quality Measurement and Improvement bv