Retire SQL workers even when connection-pool cleanup fails

Author: BenCodez

SimpleAPI/src/main/java/com/bencodez/simpleapi/sql/mysql/MySQL.java

@@ -126,12 +126,17 @@ public boolean connect(MysqlConfig config, boolean emitDiagnostics) {
 	 * Close all connections and the data source.
 	 */
 	public void disconnect() {
-		if (connectionManager != null) {
-			connectionManager.close();
-		}
-		if (threadPool != null) {
-			threadPool.shutdown();
-		}
+        try {
+            if (connectionManager != null) connectionManager.close();
+        } catch (RuntimeException | Error failure) {
+            // Pool cleanup and worker retirement are independent responsibilities.
+            try { if (threadPool != null) threadPool.shutdown(); }
+            catch (RuntimeException | Error cleanup) {
+                if (cleanup != failure) failure.addSuppressed(cleanup);
+            }
+            throw failure;
+        }
+        if (threadPool != null) threadPool.shutdown();
 	}
 
 	/**

SimpleAPI/src/test/java/com/bencodez/simpleapi/sql/mysql/MySQLDisconnectTest.java

@@ -0,0 +1,59 @@
+package com.bencodez.simpleapi.sql.mysql;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.sql.SQLException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+
+class MySQLDisconnectTest {
+    static Stream<Throwable[]> failures() {
+        return Stream.of(
+                pair(null, null),
+                pair(new IllegalStateException("pool close"), null),
+                pair(new LinkageError("pool close"), null),
+                pair(null, new IllegalStateException("worker shutdown")),
+                pair(null, new LinkageError("worker shutdown")),
+                pair(new IllegalStateException("pool close"), new LinkageError("worker shutdown")),
+                pair(new LinkageError("pool close"), new IllegalStateException("worker shutdown")));
+    }
+    private static Throwable[] pair(Throwable pool, Throwable worker) { return new Throwable[] {pool, worker}; }
+    @Test void everyCleanupIsAttemptedAndPrimaryFailureIsPreserved() throws Exception {
+        for (Throwable[] failures : failures().toList()) checkCleanup(failures[0], failures[1]);
+    }
+    private void checkCleanup(Throwable poolFailure, Throwable workerFailure) throws Exception {
+        var worker = mock(ExecutorService.class); var manager = mock(ConnectionManager.class);
+        if (poolFailure != null) doThrow(poolFailure).when(manager).close();
+        if (workerFailure != null) doThrow(workerFailure).when(worker).shutdown();
+        try (var executors = mockStatic(Executors.class)) {
+            executors.when(() -> Executors.newFixedThreadPool(anyInt())).thenReturn(worker);
+            var mysql = mysql();
+            var field = MySQL.class.getDeclaredField("connectionManager"); field.setAccessible(true); field.set(mysql, manager);
+            Throwable primary = poolFailure == null ? workerFailure : poolFailure;
+            if (primary == null) assertDoesNotThrow(mysql::disconnect);
+            else {
+                Throwable thrown = assertThrows(primary.getClass(), mysql::disconnect);
+                assertSame(primary, thrown);
+                if (poolFailure != null && workerFailure != null)
+                    assertArrayEquals(new Throwable[] { workerFailure }, thrown.getSuppressed());
+                else assertEquals(0, thrown.getSuppressed().length);
+            }
+            verify(manager).close(); verify(worker).shutdown();
+        }
+    }
+    @Test void disconnectBeforeConnectAndRepeatedDisconnectAreSafe() {
+        var mysql = mysql();
+        assertDoesNotThrow(mysql::disconnect); assertDoesNotThrow(mysql::disconnect);
+        assertTrue(mysql.getThreadPool().isShutdown());
+    }
+    private static MySQL mysql() {
+        return new MySQL(1) {
+            public void debug(SQLException failure) { fail("Unexpected diagnostics"); }
+            public void debug(String message) { fail("Unexpected diagnostics"); }
+            public void severe(String message) { fail("Unexpected diagnostics"); }
+        };
+    }
+}

docs/sql-initialization-lifecycle.md

@@ -17,3 +17,9 @@ and invoke `init()` after construction. The legacy non-deferred constructors
 still initialize the table using subclass schema hooks; subclasses whose hooks
 need instance fields should use the existing deferred constructor. Successful
 external `MySQL.connect(config)` calls retain their debug diagnostics.
+
+Disconnect attempts both connection-pool closure and worker shutdown. A pool-close
+failure remains the primary exception; any independent worker-shutdown failure is
+attached as suppressed evidence. Worker retirement is still attempted after failed
+pool cleanup, including during aborted table construction. Normal shutdown remains
+graceful and does not interrupt accepted worker tasks.