From d430a4f05709062566e48bb652873c4e23283f26 Mon Sep 17 00:00:00 2001 From: Hand Sonic <8078023+HandSonic@users.noreply.github.com> Date: Sun, 20 Sep 2026 19:08:52 +0800 Subject: [PATCH] fix(h2): share one driver classloader across sessions --- .../main/java/com/dbx/agent/h2/H2Agent.java | 57 ++-- .../java/com/dbx/agent/h2/H2DriverLoader.java | 50 +++- .../com/dbx/agent/h2/H2DriverVersion.java | 21 +- .../com/dbx/agent/h2/H2FileConnections.java | 106 ++++++++ .../dbx/agent/h2/H2FileFormatDetector.java | 26 +- .../com/dbx/agent/h2/H2AgentProcessTest.java | 251 ++++++++++++++++++ .../java/com/dbx/agent/h2/H2AgentTest.java | 125 +++++++++ 7 files changed, 607 insertions(+), 29 deletions(-) create mode 100644 agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileConnections.java diff --git a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java index 53312ee895..008a367396 100644 --- a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java +++ b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java @@ -59,38 +59,53 @@ public class H2Agent extends AbstractJdbcAgent { @Override protected void loadDriver(ConnectParams params) throws Exception { + // Selection and physical opens must not race a first connection's file lock. + synchronized (H2FileConnections.class) { + selectDriver(params); + } + } + + private void selectDriver(ConnectParams params) throws Exception { H2DriverVersion selected = H2DriverVersion.select(params); if (selected == H2DriverVersion.CUSTOM) { - H2DriverLoader.LoadedDriver external = H2DriverLoader.loadExternal( + loadedDriver = H2DriverLoader.loadExternal( params.getJdbc_driver_paths(), params.getJdbc_driver_class() ); - if (loadedDriver == null || !loadedDriver.identity().equals(external.identity())) { - replaceLoadedDriver(external); - } else { - external.classLoader().close(); - } - } else if (loadedDriver == null || loadedDriver.version() != selected) { - replaceLoadedDriver(H2DriverLoader.load(selected)); + } else { + loadedDriver = H2DriverLoader.load(selected); } driverVersion = selected; } - private void replaceLoadedDriver(H2DriverLoader.LoadedDriver replacement) throws Exception { - H2DriverLoader.LoadedDriver previous = loadedDriver; - if (previous != null) { - try { - previous.classLoader().close(); - } catch (Exception error) { - replacement.classLoader().close(); - throw error; - } - } - loadedDriver = replacement; - } - @Override protected Connection openConnection(ConnectParams params) throws Exception { + String url = buildJdbcUrl(params); + if (H2FileFormatDetector.localDatabaseBasePath(url) != null) { + synchronized (H2FileConnections.class) { + selectDriver(params); + H2DriverLoader.LoadedDriver active = H2FileConnections.find(url); + if (active != null && !active.identity().equals(loadedDriver.identity())) { + throw new SQLException("This H2 file is already open with a different driver; use the same H2 driver profile or disconnect it first"); + } + Connection opened = connectWithDriver(params); + try { + H2FileConnections.register(url, opened, loadedDriver); + } catch (Exception error) { + try { + opened.close(); + } catch (Exception closeError) { + error.addSuppressed(closeError); + } + throw error; + } + return opened; + } + } + return connectWithDriver(params); + } + + private Connection connectWithDriver(ConnectParams params) throws Exception { if (loadedDriver == null) { throw new IllegalStateException("H2 JDBC driver was not loaded"); } diff --git a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverLoader.java b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverLoader.java index 9b23386a85..1704a32ba0 100644 --- a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverLoader.java +++ b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverLoader.java @@ -1,5 +1,6 @@ package com.dbx.agent.h2; +import com.dbx.agent.ConnectParams; import java.io.IOException; import java.io.InputStream; import java.net.URL; @@ -10,18 +11,46 @@ import java.nio.file.StandardCopyOption; import java.security.MessageDigest; import java.sql.Driver; import java.util.ArrayList; +import java.util.EnumMap; +import java.util.HashMap; import java.util.HexFormat; import java.util.List; +import java.util.Map; +import java.util.Properties; import java.util.UUID; final class H2DriverLoader { private static final Object EXTRACTION_LOCK = new Object(); private static final Path CACHE_ROOT = Path.of(System.getProperty("java.io.tmpdir"), "dbx-h2-drivers"); + // H2's engine registry is classloader-scoped. Keep one engine per driver for + // the Agent process, not one per logical session (which fights for file locks). + private static final Map BUNDLED = new EnumMap<>(H2DriverVersion.class); + private static final Map EXTERNAL = new HashMap<>(); private H2DriverLoader() { } - static LoadedDriver load(H2DriverVersion version) throws Exception { + static boolean autoServerEnabled(ConnectParams params) throws Exception { + // Use H2's parser so escaped INIT statements and duplicate options keep JDBC semantics. + Class connectionInfo = load(H2DriverVersion.V3).classLoader().loadClass("org.h2.engine.ConnectionInfo"); + Properties properties = new Properties(); + if (params.getUsername() != null) { + properties.setProperty("user", params.getUsername()); + } + if (params.getPassword() != null) { + properties.setProperty("password", params.getPassword()); + } + Object info = connectionInfo.getConstructor(String.class, Properties.class, String.class, Object.class) + .newInstance(H2Agent.buildUrl(params), properties, null, null); + return Boolean.TRUE.equals(connectionInfo.getMethod("getProperty", String.class, boolean.class) + .invoke(info, "AUTO_SERVER", false)); + } + + static synchronized LoadedDriver load(H2DriverVersion version) throws Exception { + LoadedDriver cached = BUNDLED.get(version); + if (cached != null) { + return cached; + } Path jar = extract(version); URLClassLoader classLoader = new URLClassLoader( new URL[]{jar.toUri().toURL()}, @@ -29,7 +58,9 @@ final class H2DriverLoader { ); try { Driver driver = (Driver) Class.forName("org.h2.Driver", true, classLoader).getDeclaredConstructor().newInstance(); - return new LoadedDriver(version, version.version(), driver, classLoader); + LoadedDriver loaded = new LoadedDriver(version, version.version(), driver, classLoader); + BUNDLED.put(version, loaded); + return loaded; } catch (Exception error) { closeAfterFailure(classLoader, error); throw error; @@ -39,7 +70,7 @@ final class H2DriverLoader { } } - static LoadedDriver loadExternal(List driverPaths, String driverClass) throws Exception { + static synchronized LoadedDriver loadExternal(List driverPaths, String driverClass) throws Exception { if (driverPaths == null || driverPaths.isEmpty()) { throw new IllegalArgumentException("Custom H2 driver profile requires at least one JDBC JAR path"); } @@ -50,17 +81,26 @@ final class H2DriverLoader { if (!Files.isRegularFile(path)) { throw new IOException("Custom H2 JDBC JAR does not exist: " + path); } - urls.add(path.toUri().toURL()); + path = path.toRealPath(); identities.add(path + ":" + sha256(path)); + // Keep the original location for relative Manifest Class-Path entries. + urls.add(path.toUri().toURL()); } String effectiveDriverClass = driverClass == null || driverClass.isBlank() ? "org.h2.Driver" : driverClass.trim(); + String identity = effectiveDriverClass + "|" + String.join("|", identities); + LoadedDriver cached = EXTERNAL.get(identity); + if (cached != null) { + return cached; + } URLClassLoader classLoader = new URLClassLoader( urls.toArray(new URL[0]), H2DriverLoader.class.getClassLoader() ); try { Driver driver = (Driver) Class.forName(effectiveDriverClass, true, classLoader).getDeclaredConstructor().newInstance(); - return new LoadedDriver(H2DriverVersion.CUSTOM, effectiveDriverClass + "|" + String.join("|", identities), driver, classLoader); + LoadedDriver loaded = new LoadedDriver(H2DriverVersion.CUSTOM, identity, driver, classLoader); + EXTERNAL.put(identity, loaded); + return loaded; } catch (Exception error) { closeAfterFailure(classLoader, error); throw error; diff --git a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverVersion.java b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverVersion.java index 1bd4e9656b..6fbbcead61 100644 --- a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverVersion.java +++ b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2DriverVersion.java @@ -47,8 +47,25 @@ enum H2DriverVersion { case "h2-v3" -> V3; case "h2-custom" -> CUSTOM; case "", "h2", "h2-auto", "h2_embedded", "h2_server" -> { - java.util.OptionalInt detected = H2FileFormatDetector.detect(H2Agent.buildUrl(params)); - yield detected.isPresent() ? fromStorageFormat(detected.getAsInt()) : V3; + String url = H2Agent.buildUrl(params); + H2DriverLoader.LoadedDriver active = H2FileConnections.find(url); + if (active != null) { + if (active.version() == CUSTOM) { + throw new IllegalArgumentException("This H2 file is already open with a custom driver; select the same custom H2 driver profile"); + } + yield active.version(); + } + try { + java.util.OptionalInt detected = H2FileFormatDetector.detect(url); + yield detected.isPresent() ? fromStorageFormat(detected.getAsInt()) : V3; + } catch (H2FileFormatDetector.HeaderReadException error) { + // Another Agent may own the file. H2's AUTO_SERVER path negotiates + // the wire protocol and validates the lock/server key itself. + if (H2FileFormatDetector.hasAutoServerLock(url) && H2DriverLoader.autoServerEnabled(params)) { + yield V3; + } + throw error; + } } default -> throw new IllegalArgumentException("Unsupported H2 driver profile: " + profile); }; diff --git a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileConnections.java b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileConnections.java new file mode 100644 index 0000000000..390098090b --- /dev/null +++ b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileConnections.java @@ -0,0 +1,106 @@ +package com.dbx.agent.h2; + +import java.lang.ref.WeakReference; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Path; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** Tracks physical connections and embedded engines without extending their lifetimes. */ +final class H2FileConnections { + private static final Map> CONNECTIONS = new HashMap<>(); + + private H2FileConnections() { + } + + static synchronized H2DriverLoader.LoadedDriver find(String jdbcUrl) throws Exception { + CONNECTIONS.values().forEach(entries -> entries.removeIf(entry -> !entry.isOpen())); + CONNECTIONS.values().removeIf(List::isEmpty); + List entries = CONNECTIONS.get(key(jdbcUrl)); + return entries == null ? null : entries.get(0).driver(); + } + + static synchronized void register(String jdbcUrl, Connection connection, H2DriverLoader.LoadedDriver driver) throws Exception { + Path key = key(jdbcUrl); + if (key != null) { + EmbeddedDatabase database = embeddedDatabase(connection); + List entries = CONNECTIONS.computeIfAbsent(key, ignored -> new ArrayList<>()); + if (database != null && entries.stream().anyMatch(entry -> entry.database() != null + && entry.database().reference().get() == database.reference().get())) { + return; + } + entries.add(new OpenConnection(new WeakReference<>(connection), database, driver)); + } + } + + private static EmbeddedDatabase embeddedDatabase(Connection connection) { + try { + // Public H2 accessors differ only in their return types across bundled versions. + Object session = connection.getClass().getMethod("getSession").invoke(connection); + if (session == null) { + return null; + } + Object database = session.getClass().getMethod("getDatabase").invoke(session); + if (database == null) { + return null; + } + return new EmbeddedDatabase(new WeakReference<>(database), database.getClass().getMethod("isClosing")); + } catch (ReflectiveOperationException ignored) { + // AUTO_SERVER remote sessions and custom wrappers may expose no embedded engine. + return null; + } + } + + private static Path key(String jdbcUrl) throws Exception { + Path base = H2FileFormatDetector.localDatabaseBasePath(jdbcUrl); + if (base == null) { + return null; + } + for (String suffix : List.of(".mv.db", ".h2.db")) { + Path file = Path.of(base + suffix); + if (Files.isRegularFile(file)) { + return file.toRealPath(); + } + } + return base; + } + + private record EmbeddedDatabase(WeakReference reference, Method isClosing) { + boolean isOpen() { + Object database = reference.get(); + if (database == null) { + return false; + } + synchronized (database) { + try { + return Boolean.FALSE.equals(isClosing.invoke(database)); + } catch (ReflectiveOperationException ignored) { + return false; + } + } + } + } + + private record OpenConnection( + WeakReference reference, + EmbeddedDatabase database, + H2DriverLoader.LoadedDriver driver + ) { + boolean isOpen() { + Connection connection = reference.get(); + try { + if (connection != null && !connection.isClosed()) { + return true; + } + } catch (SQLException ignored) { + } + // DB_CLOSE_DELAY can keep the engine and its file lock alive after JDBC close. + return database != null && database.isOpen(); + } + } +} diff --git a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileFormatDetector.java b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileFormatDetector.java index aa0ccd3449..5cfbd44ec9 100644 --- a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileFormatDetector.java +++ b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2FileFormatDetector.java @@ -9,6 +9,7 @@ import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.OptionalInt; +import java.util.Properties; final class H2FileFormatDetector { private static final int BLOCK_SIZE = 4096; @@ -37,10 +38,33 @@ final class H2FileFormatDetector { return OptionalInt.of(readMvStoreFormat(mvStore)); } + static boolean hasAutoServerLock(String jdbcUrl) { + Path base = localDatabaseBasePath(jdbcUrl); + if (base == null) { + return false; + } + Properties lock = new Properties(); + try (InputStream input = Files.newInputStream(withSuffix(base, ".lock.db"))) { + lock.load(input); + return !lock.getProperty("server", "").isBlank() && !lock.getProperty("id", "").isBlank(); + } catch (IOException | IllegalArgumentException ignored) { + return false; + } + } + + static final class HeaderReadException extends IOException { + HeaderReadException(Path file, IOException cause) { + super("Cannot read H2 file headers: " + file + ". " + cause.getMessage() + + ". Check file permissions and close other applications using this database, or connect through its H2 TCP server.", cause); + } + } + private static int readMvStoreFormat(Path file) throws IOException { byte[] bytes; try (InputStream input = Files.newInputStream(file)) { bytes = input.readNBytes(BLOCK_SIZE * 2); + } catch (IOException error) { + throw new HeaderReadException(file, error); } if (bytes.length < BLOCK_SIZE * 2) { throw new IOException("H2 MVStore file is too small to contain valid headers: " + file); @@ -131,7 +155,7 @@ final class H2FileFormatDetector { return (s2 << 16) | s1; } - private static Path localDatabaseBasePath(String jdbcUrl) { + static Path localDatabaseBasePath(String jdbcUrl) { String prefix = "jdbc:h2:"; if (jdbcUrl == null || !jdbcUrl.regionMatches(true, 0, prefix, 0, prefix.length())) { return null; diff --git a/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentProcessTest.java b/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentProcessTest.java index ea3307e135..9c3fbd6e48 100644 --- a/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentProcessTest.java +++ b/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentProcessTest.java @@ -23,8 +23,259 @@ import java.util.concurrent.atomic.AtomicInteger; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; +import org.junit.jupiter.api.io.TempDir; class H2AgentProcessTest { + @TempDir + Path tempDirectory; + + @Test + @Timeout(90) + void fileSessionsShareTheDriverAcrossProfilesAndConnectionTests() throws Exception { + try (RpcProcess rpc = new RpcProcess(Path.of(System.getProperty("dbx.h2.agent.jar")))) { + for (String profile : List.of("h2-v1", "h2-v2", "h2-v3")) { + String database = "file:" + tempDirectory.resolve(profile).toString().replace('\\', '/'); + JsonObject first = connectParams(profile + "-first", profile); + first.addProperty("database", database); + rpc.result(rpc.request("open_session", first)); + rpc.result(rpc.request("execute_query", queryParams(profile + "-first", "CREATE TABLE SHARED_DATA (ID INT PRIMARY KEY)"))); + rpc.result(rpc.request("execute_query", queryParams(profile + "-first", "INSERT INTO SHARED_DATA VALUES (42)"))); + + JsonObject second = connectParams(profile + "-second", profile); + second.addProperty("database", database + ";IFEXISTS=TRUE"); + second.addProperty("sessionRole", "metadata"); + rpc.result(rpc.request("open_session", second)); + Assertions.assertEquals("42", firstCell(rpc.result(rpc.request("execute_query", queryParams(profile + "-second", "SELECT ID FROM SHARED_DATA"))))); + + JsonObject auto = connectParams(profile + "-auto", "h2"); + auto.addProperty("database", database + ";IFEXISTS=TRUE"); + rpc.result(rpc.request("open_session", auto)); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", auto)).get("ok").getAsBoolean()); + rpc.result(rpc.request("close_session", sessionParams(profile + "-first"))); + Assertions.assertEquals("42", firstCell(rpc.result(rpc.request("execute_query", queryParams(profile + "-auto", "SELECT ID FROM SHARED_DATA"))))); + rpc.result(rpc.request("close_session", sessionParams(profile + "-second"))); + rpc.result(rpc.request("close_session", sessionParams(profile + "-auto"))); + } + } + } + + @Test + @Timeout(60) + void autoServerFileSessionsSupportConnectionTestsAndDatabaseSelection() throws Exception { + try (RpcProcess rpc = new RpcProcess(Path.of(System.getProperty("dbx.h2.agent.jar")))) { + JsonObject params = connectParams("file-metadata", "h2"); + String database = "file:" + tempDirectory.resolve("auto-server") + ";AUTO_SERVER=TRUE"; + params.addProperty("database", database); + params.addProperty("connection_string", "jdbc:h2:" + database); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", params)).get("ok").getAsBoolean()); + params.addProperty("sessionRole", "metadata"); + rpc.result(rpc.request("open_session", params)); + rpc.resultArray(rpc.request("list_databases", sessionParams("file-metadata"))); + JsonObject workload = params.deepCopy(); + workload.addProperty("agentSessionId", "file-workload"); + workload.addProperty("sessionRole", "workload"); + rpc.result(rpc.request("open_session", workload)); + Assertions.assertEquals("1", firstCell(rpc.result(rpc.request("execute_query", queryParams("file-workload", "SELECT 1"))))); + } + } + + @Test + @Timeout(60) + void autoFileSessionReopensAfterConnectionTestWithDelayedClose() throws Exception { + Path jar = Path.of(System.getProperty("dbx.h2.agent.jar")); + for (String profile : List.of("h2-v1", "h2-v2", "h2-v3")) { + String database = "file:" + tempDirectory.resolve("delayed-" + profile) + ";AUTO_SERVER=TRUE"; + JsonObject params = connectParams("delayed-close", profile); + params.addProperty("database", database); + // Persist the setting, then start a fresh Agent just like a client restart. + try (RpcProcess creator = new RpcProcess(jar)) { + creator.result(creator.request("open_session", params)); + creator.result(creator.request("execute_query", queryParams("delayed-close", "SET DB_CLOSE_DELAY -1"))); + } + params.addProperty("driver_profile", "h2"); + try (RpcProcess rpc = new RpcProcess(jar)) { + Assertions.assertTrue(rpc.result(rpc.request("test_connection", params)).get("ok").getAsBoolean()); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", params)).get("ok").getAsBoolean()); + rpc.result(rpc.request("open_session", params)); + Assertions.assertEquals("1", firstCell(rpc.result(rpc.request("execute_query", queryParams("delayed-close", "SELECT 1"))))); + rpc.result(rpc.request("close_session", sessionParams("delayed-close"))); + rpc.result(rpc.request("open_session", params)); + } + } + } + + @Test + @Timeout(60) + void failedFirstAutoFileOpenDoesNotMaskAuthenticationError() throws Exception { + Path jar = Path.of(System.getProperty("dbx.h2.agent.jar")); + for (String profile : List.of("h2-v1", "h2-v2", "h2-v3")) { + JsonObject params = connectParams("failed-first", profile); + params.addProperty("database", "file:" + tempDirectory.resolve("failed-first-" + profile) + + ";AUTO_SERVER=TRUE;DB_CLOSE_DELAY=-1"); + params.addProperty("password", "owner-secret"); + try (RpcProcess creator = new RpcProcess(jar)) { + creator.result(creator.request("open_session", params)); + } + params.addProperty("driver_profile", "h2"); + try (RpcProcess rpc = new RpcProcess(jar)) { + JsonObject denied = params.deepCopy(); + denied.addProperty("password", "wrong-secret"); + for (int attempt = 0; attempt < 2; attempt++) { + JsonObject response = rpc.request("test_connection", denied); + Assertions.assertTrue(response.has("error")); + JsonObject errorData = response.getAsJsonObject("error").getAsJsonObject("data"); + Assertions.assertTrue(errorData.has("sqlState"), response.toString()); + Assertions.assertEquals("28000", errorData.get("sqlState").getAsString(), response.toString()); + } + rpc.result(rpc.request("open_session", params)); + Assertions.assertEquals("1", firstCell(rpc.result(rpc.request("execute_query", queryParams("failed-first", "SELECT 1"))))); + } + } + } + + @Test + @Timeout(60) + void delayedCloseEngineStillChecksProfileAndCredentials() throws Exception { + try (RpcProcess rpc = new RpcProcess(Path.of(System.getProperty("dbx.h2.agent.jar")))) { + JsonObject owner = connectParams("delayed-owner", "h2-v1"); + owner.addProperty("database", "file:" + tempDirectory.resolve("protected-delayed") + ";DB_CLOSE_DELAY=-1"); + owner.addProperty("password", "owner-secret"); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", owner)).get("ok").getAsBoolean()); + JsonObject other = owner.deepCopy(); + other.addProperty("driver_profile", "h2-v3"); + JsonObject mismatch = rpc.request("test_connection", other); + Assertions.assertTrue(mismatch.has("error")); + Assertions.assertTrue(mismatch.getAsJsonObject("error").get("message").getAsString().contains("different driver")); + other.addProperty("driver_profile", "h2"); + other.addProperty("password", "wrong-secret"); + Assertions.assertTrue(rpc.request("test_connection", other).has("error")); + owner.addProperty("driver_profile", "h2"); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", owner)).get("ok").getAsBoolean()); + } + } + + @Test + @Timeout(60) + void shutdownReleasesRetainedEngineAndAllowsFormatRedetection() throws Exception { + try (RpcProcess rpc = new RpcProcess(Path.of(System.getProperty("dbx.h2.agent.jar")))) { + Path base = tempDirectory.resolve("shutdown-delayed"); + JsonObject params = connectParams("before-shutdown", "h2-v1"); + params.addProperty("database", "file:" + base + ";DB_CLOSE_DELAY=60"); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", params)).get("ok").getAsBoolean()); + params.addProperty("driver_profile", "h2"); + rpc.result(rpc.request("open_session", params)); + JsonObject shutdown = rpc.request("execute_query", queryParams("before-shutdown", "SHUTDOWN")); + if (shutdown.has("error")) { + // H2 1.x can report database-closed when the executor inspects SHUTDOWN's result. + Assertions.assertEquals(90121, shutdown.getAsJsonObject("error").getAsJsonObject("data").get("vendorCode").getAsInt()); + } else { + rpc.result(shutdown); + } + rpc.result(rpc.request("close_session", sessionParams("before-shutdown"))); + Files.delete(Path.of(base + ".mv.db")); + + params.addProperty("database", "file:" + base); + params.addProperty("driver_profile", "h2-v2"); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", params)).get("ok").getAsBoolean()); + params.addProperty("driver_profile", "h2"); + JsonObject reopened = rpc.result(rpc.request("test_connection", params)); + Assertions.assertTrue(reopened.getAsJsonObject("databaseInfo").get("driverVersion").getAsString().startsWith("2.1.214")); + } + } + + @Test + @Timeout(60) + void autoFileSessionCanBeOpenedAgainWhileThePoolKeepsItOpen() throws Exception { + try (RpcProcess rpc = new RpcProcess(Path.of(System.getProperty("dbx.h2.agent.jar")))) { + JsonObject first = connectParams("auto-first", "h2"); + first.addProperty("database", "file:" + tempDirectory.resolve("auto").toString().replace('\\', '/')); + rpc.result(rpc.request("open_session", first)); + rpc.result(rpc.request("close_session", sessionParams("auto-first"))); + JsonObject second = first.deepCopy(); + second.addProperty("agentSessionId", "auto-second"); + rpc.result(rpc.request("open_session", second)); + Assertions.assertTrue(rpc.result(rpc.request("test_connection", second)).get("ok").getAsBoolean()); + } + } + + @Test + @Timeout(60) + void concurrentAutoFileSessionsShareOneEngine() throws Exception { + try (RpcProcess rpc = new RpcProcess(Path.of(System.getProperty("dbx.h2.agent.jar")))) { + List requests = new java.util.ArrayList<>(); + for (int index = 0; index < 6; index++) { + JsonObject params = connectParams("concurrent-" + index, "h2"); + params.addProperty("database", "file:" + tempDirectory.resolve("concurrent").toString().replace('\\', '/') + + ";LOCK_TIMEOUT=" + (1000 + index)); + requests.add(rpc.send("open_session", params)); + } + for (int request : requests) { + rpc.result(rpc.await(request, Duration.ofSeconds(20))); + } + rpc.result(rpc.request("execute_query", queryParams("concurrent-0", "CREATE TABLE SHARED_VALUE (ID INT)"))); + rpc.result(rpc.request("execute_query", queryParams("concurrent-0", "INSERT INTO SHARED_VALUE VALUES (7)"))); + for (int index = 1; index < 6; index++) { + Assertions.assertEquals("7", firstCell(rpc.result(rpc.request("execute_query", queryParams("concurrent-" + index, "SELECT ID FROM SHARED_VALUE"))))); + } + } + } + + @Test + @Timeout(60) + void autoServerFileCanBeOpenedFromAnotherAgentProcess() throws Exception { + Path jar = Path.of(System.getProperty("dbx.h2.agent.jar")); + for (String profile : List.of("h2-v1", "h2-v2", "h2-v3")) { + try (RpcProcess owner = new RpcProcess(jar); RpcProcess other = new RpcProcess(jar)) { + JsonObject params = connectParams("auto-server-owner", profile); + String database = "file:" + tempDirectory.resolve("shared-server-" + profile); + params.addProperty("database", database + ";AUTO_SERVER=TRUE;DB_CLOSE_DELAY=-1"); + params.addProperty("password", "owner-secret"); + owner.result(owner.request("open_session", params)); + owner.result(owner.request("execute_query", queryParams("auto-server-owner", "CREATE TABLE OWNER_DATA (ID INT)"))); + owner.result(owner.request("execute_query", queryParams("auto-server-owner", "INSERT INTO OWNER_DATA VALUES (99)"))); + + JsonObject test = params.deepCopy(); + test.addProperty("driver_profile", "h2-v3"); + Assertions.assertTrue(other.result(other.request("test_connection", test)).get("ok").getAsBoolean()); + test.addProperty("driver_profile", "h2"); + test.addProperty("agentSessionId", "auto-server-guest"); + JsonObject denied = test.deepCopy(); + denied.addProperty("database", database); + Assertions.assertTrue(other.request("test_connection", denied).has("error")); + denied.addProperty("database", database + ";AUTO_SERVER=FALSE"); + Assertions.assertTrue(other.request("test_connection", denied).has("error")); + denied = test.deepCopy(); + denied.addProperty("password", "wrong-secret"); + Assertions.assertTrue(other.request("test_connection", denied).has("error")); + Assertions.assertTrue(other.result(other.request("test_connection", test)).get("ok").getAsBoolean()); + other.result(other.request("open_session", test)); + Assertions.assertEquals("99", firstCell(other.result(other.request("execute_query", queryParams("auto-server-guest", "SELECT ID FROM OWNER_DATA"))))); + Assertions.assertTrue(other.resultArray(other.request("list_objects", metadataParams("auto-server-guest", "PUBLIC"))) + .asList().stream().anyMatch(value -> "OWNER_DATA".equals(value.getAsJsonObject().get("name").getAsString()))); + Assertions.assertEquals("99", firstCell(owner.result(owner.request("execute_query", queryParams("auto-server-owner", "SELECT ID FROM OWNER_DATA"))))); + } + } + } + + @Test + @Timeout(60) + void externalProcessLockIsNotBypassedAndOwnerKeepsWorking() throws Exception { + Path jar = Path.of(System.getProperty("dbx.h2.agent.jar")); + try (RpcProcess owner = new RpcProcess(jar); RpcProcess other = new RpcProcess(jar)) { + JsonObject params = connectParams("owner", "h2-v3"); + params.addProperty("database", "file:" + tempDirectory.resolve("externally-locked").toString().replace('\\', '/')); + owner.result(owner.request("open_session", params)); + owner.result(owner.request("execute_query", queryParams("owner", "CREATE TABLE OWNER_DATA (ID INT)"))); + owner.result(owner.request("execute_query", queryParams("owner", "INSERT INTO OWNER_DATA VALUES (99)"))); + JsonObject test = params.deepCopy(); + test.addProperty("driver_profile", "h2"); + Assertions.assertTrue(other.request("test_connection", test).has("error")); + test.addProperty("driver_profile", "h2-v3"); + Assertions.assertTrue(other.request("test_connection", test).has("error")); + Assertions.assertEquals("99", firstCell(owner.result(owner.request("execute_query", queryParams("owner", "SELECT ID FROM OWNER_DATA"))))); + } + } + @Test @Timeout(45) void shadedAgentSupportsIsolatedMultiVersionSessions() throws Exception { diff --git a/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java b/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java index 50829aadde..1e44537328 100644 --- a/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java +++ b/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java @@ -21,6 +21,7 @@ import java.nio.file.attribute.FileTime; import java.util.List; import java.util.Map; import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -127,6 +128,89 @@ class H2AgentMigrationTest { Assertions.assertEquals(3, H2FileFormatDetector.detect("jdbc:h2:file:" + base).orElseThrow()); } + @Test + void closedFileConnectionsDoNotPinTheDetectedVersion() throws Exception { + Path base = tempDirectory.resolve("replaceable"); + H2Agent first = new H2Agent(); + first.connect(profileParams("h2", "file:" + base)); + first.disconnect(); + Files.delete(Path.of(base + ".mv.db")); + H2Agent older = new H2Agent(); + older.connect(profileParams("h2-v2", "file:" + base)); + older.disconnect(); + H2Agent detected = new H2Agent(); + try { + detected.connect(profileParams("h2", "file:" + base + ";IFEXISTS=TRUE")); + Assertions.assertEquals(H2DriverVersion.V2, detected.driverVersion()); + } finally { + detected.disconnect(); + } + } + + @Test + void activeFileRejectsDifferentDriverAndWrongCredentials() { + Path base = tempDirectory.resolve("protected"); + H2Agent owner = new H2Agent(); + H2Agent other = new H2Agent(); + try { + ConnectParams params = profileParams("h2-v3", "file:" + base); + params.setPassword("owner-secret"); + owner.connect(params); + RuntimeException mismatch = Assertions.assertThrows(RuntimeException.class, + () -> other.connect(profileParams("h2-v2", "file:" + base))); + Assertions.assertTrue(hasCauseMessage(mismatch, "different driver")); + Assertions.assertThrows(RuntimeException.class, + () -> other.testConnectionWithInfo(profileParams("h2", "file:" + base))); + Assertions.assertEquals(List.of(List.of(1)), owner.executeQuery("SELECT 1", null, new ExecuteQueryOptions()).getRows()); + } finally { + other.disconnect(); + owner.disconnect(); + } + } + + @Test + void autoServerOptionsUseH2ParsingRules() throws Exception { + String base = "file:" + tempDirectory.resolve("options"); + Assertions.assertFalse(H2DriverLoader.autoServerEnabled(profileParams("h2", base))); + Assertions.assertFalse(H2DriverLoader.autoServerEnabled(profileParams("h2", base + ";AUTO_SERVER=FALSE"))); + Assertions.assertTrue(H2DriverLoader.autoServerEnabled(profileParams("h2", base + ";auto_server=TRUE"))); + Assertions.assertTrue(H2DriverLoader.autoServerEnabled(profileParams("h2", base + ";AUTO_SERVER=1"))); + Assertions.assertFalse(H2DriverLoader.autoServerEnabled(profileParams("h2", base + + ";INIT=SET @NOTE 'x\\;AUTO_SERVER=TRUE'"))); + Assertions.assertThrows(Exception.class, () -> H2DriverLoader.autoServerEnabled(profileParams("h2", base + + ";AUTO_SERVER=FALSE;AUTO_SERVER=TRUE"))); + } + + @Test + void autoServerLockDoesNotBypassCorruptHeaderValidation() throws Exception { + Path base = tempDirectory.resolve("corrupt-auto-server"); + Path file = Path.of(base + ".mv.db"); + byte[] corrupt = new byte[8192]; + java.util.Arrays.fill(corrupt, (byte) 0x5a); + Files.write(file, corrupt); + Files.writeString(Path.of(base + ".lock.db"), "server=127.0.0.1:1\nid=test-key\n"); + String url = "jdbc:h2:file:" + base + ";AUTO_SERVER=TRUE"; + Assertions.assertTrue(H2FileFormatDetector.hasAutoServerLock(url)); + RuntimeException error = Assertions.assertThrows(RuntimeException.class, + () -> new H2Agent().connect(profileParams("h2", "file:" + base + ";AUTO_SERVER=TRUE"))); + Assertions.assertTrue(hasCauseMessage(error, "Cannot determine the H2 MVStore format")); + Assertions.assertArrayEquals(corrupt, Files.readAllBytes(file)); + } + + @Test + void autoServerLockRequiresValidServerAndKeyProperties() throws Exception { + Path base = tempDirectory.resolve("invalid-lock"); + Path lock = Path.of(base + ".lock.db"); + String url = "jdbc:h2:file:" + base; + Assertions.assertFalse(H2FileFormatDetector.hasAutoServerLock(url)); + Files.writeString(lock, "server=127.0.0.1:1\n"); + Assertions.assertFalse(H2FileFormatDetector.hasAutoServerLock(url)); + Files.writeString(lock, "id=test-key\n"); + Assertions.assertFalse(H2FileFormatDetector.hasAutoServerLock(url)); + Files.writeString(lock, "server=\\uZZZZ\nid=test-key\n"); + Assertions.assertFalse(H2FileFormatDetector.hasAutoServerLock(url)); + } + @Test void autoRejectsCorruptMvStoreWithoutModifyingIt() throws Exception { Path base = tempDirectory.resolve("corrupt"); @@ -231,6 +315,23 @@ class H2AgentMigrationTest { } } + @Test + void customDriverPreservesManifestRelativeClasspath() throws Exception { + Path driverJar = copyBundledDriver("h2-2.1.214.jar"); + Path entryJar = tempDirectory.resolve("driver-entry.jar"); + Manifest manifest = new Manifest(); + manifest.getMainAttributes().putValue("Manifest-Version", "1.0"); + manifest.getMainAttributes().putValue("Class-Path", driverJar.getFileName().toString()); + try (JarOutputStream ignored = new JarOutputStream(Files.newOutputStream(entryJar), manifest)) { + } + H2DriverLoader.LoadedDriver driver = H2DriverLoader.loadExternal(List.of(entryJar.toString()), "org.h2.Driver"); + try (java.sql.Connection connection = driver.driver().connect("jdbc:h2:mem:manifest-classpath", new java.util.Properties())) { + Assertions.assertTrue(connection.getMetaData().getDriverVersion().startsWith("2.1.214")); + } finally { + driver.classLoader().close(); + } + } + @Test void loadsCustomH2DriverFromExternalClasspath() throws Exception { Path helperJar = tempDirectory.resolve("helper.jar"); @@ -250,6 +351,30 @@ class H2AgentMigrationTest { Assertions.assertEquals(List.of("CUSTOM_DRIVER_PROBE"), agent.listTables("PUBLIC").stream().map(TableInfo::getName).toList()); } finally { agent.disconnect(); + H2DriverLoader.loadExternal(params.getJdbc_driver_paths(), params.getJdbc_driver_class()).classLoader().close(); + } + } + + @Test + void customFileConnectionsShareDriver() throws Exception { + Path jar = copyBundledDriver("h2-2.1.214.jar"); + ConnectParams params = profileParams("h2-custom", "file:" + tempDirectory.resolve("custom-shared")); + params.setJdbc_driver_paths(List.of(jar.toString())); + params.setJdbc_driver_class("org.h2.Driver"); + H2Agent first = new H2Agent(); + H2Agent second = new H2Agent(); + try { + first.connect(params); + first.executeQuery("CREATE TABLE SHARED_CUSTOM (ID INT)", null, new ExecuteQueryOptions()); + first.executeQuery("INSERT INTO SHARED_CUSTOM VALUES (42)", null, new ExecuteQueryOptions()); + second.connect(params); + Assertions.assertEquals(List.of(List.of(42)), second.executeQuery("SELECT ID FROM SHARED_CUSTOM", null, new ExecuteQueryOptions()).getRows()); + first.disconnect(); + Assertions.assertEquals(List.of(List.of(42)), second.executeQuery("SELECT ID FROM SHARED_CUSTOM", null, new ExecuteQueryOptions()).getRows()); + } finally { + first.disconnect(); + second.disconnect(); + H2DriverLoader.loadExternal(params.getJdbc_driver_paths(), params.getJdbc_driver_class()).classLoader().close(); } }