Fix for postgres instance process closing

CHANGELOG.md

@@ -41,6 +41,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We added "Hanging Indent" as the default selected bibliography body format for CSL styles that specify it (e.g. APA). [melting-pot#894](https://github.com/JabRef/jabref-issue-melting-pot/issues/894)
 - We fixed an issue where bibliography entries generated from CSL styles had leading spaces. [#13074](https://github.com/JabRef/jabref/pull/13074)
 - We fixed an issue where the preview area in the "Select Style" dialog of the LibreOffice integration was too small to display full content. [#13051](https://github.com/JabRef/jabref/issues/13051)
+- We fixed an issue where postgres processes remain running after JabRef crashes or is forcefully terminated. [#12927](https://github.com/JabRef/jabref/pull/12927)
 
 ### Removed
 

jabgui/src/main/java/org/jabref/Launcher.java

@@ -23,6 +23,7 @@
 import org.jabref.logic.preferences.CliPreferences;
 import org.jabref.logic.remote.RemotePreferences;
 import org.jabref.logic.remote.client.RemoteClient;
+import org.jabref.logic.search.PostgreProcessCleaner;
 import org.jabref.logic.search.PostgreServer;
 import org.jabref.logic.util.BuildInfo;
 import org.jabref.logic.util.Directories;
@@ -46,6 +47,9 @@ public class Launcher {
     public static void main(String[] args) {
         initLogging(args);
 
+        // Clean up old Postgres instance if needed
+        PostgreProcessCleaner.getInstance().checkAndCleanupOldInstances();
+
         Injector.setModelOrService(BuildInfo.class, new BuildInfo());
 
         final JabRefGuiPreferences preferences = JabRefGuiPreferences.getInstance();
@@ -77,6 +81,9 @@ public static void main(String[] args) {
 
         CSLStyleLoader.loadInternalStyles();
 
+        // Register shutdown hook
+        Runtime.getRuntime().addShutdownHook(new Thread(postgreServer::shutdown));
+
         JabRefGUI.setup(uiCommands, preferences);
         JabRefGUI.launch(JabRefGUI.class, args);
     }

jablib/build.gradle.kts

@@ -202,6 +202,8 @@ dependencies {
     implementation("io.zonky.test.postgres:embedded-postgres-binaries-darwin-arm64v8")
     implementation("io.zonky.test.postgres:embedded-postgres-binaries-linux-arm64v8")
 
+    implementation("com.github.oshi:oshi-core:6.8.1")
+
     testImplementation(project(":test-support"))
 
     // loading of .fxml files in localization tests requires JabRef's GUI classes

jablib/src/main/java/module-info.java

@@ -246,5 +246,6 @@
     requires mslinks;
     requires org.antlr.antlr4.runtime;
     requires org.libreoffice.uno;
+    requires com.github.oshi;
     // endregion
 }

jablib/src/main/java/org/jabref/logic/search/PostgreProcessCleaner.java

@@ -0,0 +1,110 @@
+package org.jabref.logic.search;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import oshi.SystemInfo;
+import oshi.software.os.OSProcess;
+import oshi.software.os.OperatingSystem;
+
+public class PostgreProcessCleaner {
+    private static final Logger LOGGER = LoggerFactory.getLogger(PostgreProcessCleaner.class);
+    private static final PostgreProcessCleaner INSTANCE = new PostgreProcessCleaner();
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+    private static final Path TEMP_DIR = Path.of(System.getProperty("java.io.tmpdir"));
+    private static final SystemInfo SYSTEM_INFO = new SystemInfo();
+    private static final OperatingSystem OS = SYSTEM_INFO.getOperatingSystem();
+    private static final String FILE_PREFIX = "jabref-postgres-info-";
+    private static final String FILE_SUFFIX = ".json";
+    private static final int POSTGRES_SHUTDOWN_WAIT_MILLIS = 1500;
+
+    private PostgreProcessCleaner() {
+    }
+
+    public static PostgreProcessCleaner getInstance() {
+        return INSTANCE;
+    }
+
+    public void checkAndCleanupOldInstances() {
+        try (Stream<Path> files = Files.list(TEMP_DIR)) {
+            files.filter(path -> path.getFileName().toString().startsWith(FILE_PREFIX))
+                    .filter(path -> path.getFileName().toString().endsWith(FILE_SUFFIX))
+                    .forEach(this::cleanupIfDeadProcess);
+        } catch (IOException e) {
+            LOGGER.warn("Failed to list temp directory for Postgres metadata cleanup: {}", e.getMessage(), e);
+        }
+    }
+
+    private void cleanupIfDeadProcess(Path metadataPath) {
+        try {
+            Map<String, Object> metadata = new HashMap<>(OBJECT_MAPPER.readValue(Files.readAllBytes(metadataPath), HashMap.class));
+            long javaPid = ((Number) metadata.get("javaPid")).longValue();
+            if (isJavaProcessAlive(javaPid)) {
+                return;
+            }
+            int postgresPort = ((Number) metadata.get("postgresPort")).intValue();
+            destroyPostgresProcess(postgresPort);
+            Files.deleteIfExists(metadataPath);
+        } catch (IOException e) {
+            LOGGER.warn("Failed to read or parse metadata file '{}': {}", metadataPath, e.getMessage(), e);
+        } catch (InterruptedException e) {
+            LOGGER.warn("Cleanup was interrupted for '{}': {}", metadataPath, e.getMessage(), e);
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+            LOGGER.warn("Unexpected error during cleanup of '{}': {}", metadataPath, e.getMessage(), e);
+        }
+    }
+
+    private void destroyPostgresProcess(int port) throws InterruptedException {
+        if (isPortOpen(port)) {
+            long pid = getPidUsingPort(port);
+            if (pid != -1) {
+                LOGGER.info("Old Postgres instance found on port {} (PID {}). Killing it.", port, pid);
+                destroyProcessByPID(pid);
+            } else {
+                LOGGER.warn("Could not determine PID using port {}. Skipping kill step.", port);
+            }
+        }
+    }
+
+    private void destroyProcessByPID(long pid) throws InterruptedException {
+        Optional<ProcessHandle> aliveProcess = ProcessHandle.of(pid).filter(ProcessHandle::isAlive);
+        if (aliveProcess.isPresent()) {
+            aliveProcess.get().destroy();
+            Thread.sleep(PostgreProcessCleaner.POSTGRES_SHUTDOWN_WAIT_MILLIS);
+        }
+    }
+
+    private boolean isJavaProcessAlive(long javaPid) {
+        Optional<ProcessHandle> handle = ProcessHandle.of(javaPid);
+        return handle.map(ProcessHandle::isAlive).orElse(false);
+    }
+
+    private boolean isPortOpen(int port) {
+        try (Socket _ = new Socket("localhost", port)) {
+            return true;
+        } catch (IOException ex) {
+            return false;
+        }
+    }
+
+    private long getPidUsingPort(int port) {
+        for (OSProcess process : OS.getProcesses()) {
+            String command = process.getCommandLine();
+            if (command != null && command.toLowerCase().contains("postgres")
+                    && command.contains(String.valueOf(port))) {
+                return process.getProcessID();
+            }
+        }
+        return -1L;
+    }
+}

jablib/src/main/java/org/jabref/logic/search/PostgreServer.java

@@ -16,6 +16,7 @@
 
 public class PostgreServer {
     private static final Logger LOGGER = LoggerFactory.getLogger(PostgreServer.class);
+
     private final EmbeddedPostgres embeddedPostgres;
     private final DataSource dataSource;
 
@@ -26,6 +27,7 @@ public PostgreServer() {
                                                .setOutputRedirector(ProcessBuilder.Redirect.DISCARD)
                                                .start();
             LOGGER.info("Postgres server started, connection port: {}", embeddedPostgres.getPort());
+            PostgresMetadataWriter.write(embeddedPostgres.getPort());
         } catch (IOException e) {
             LOGGER.error("Could not start Postgres server", e);
             this.embeddedPostgres = null;

jablib/src/main/java/org/jabref/logic/search/PostgresMetadataWriter.java

@@ -0,0 +1,50 @@
+package org.jabref.logic.search;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.jabref.logic.util.Directories.getTmpDirectory;
+
+public class PostgresMetadataWriter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(PostgresMetadataWriter.class);
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+    private static final String JAVA_PID = "javaPid";
+    private static final String POSTGRES_PORT = "postgresPort";
+    private static final String STARTED_BY = "startedBy";
+    private static final String STARTED_AT = "startedAt";
+    private static final String JABREF = "jabref";
+
+    private PostgresMetadataWriter() {
+    }
+
+    public static Path getMetadataFilePath() {
+        return getTmpDirectory().resolve("jabref-postgres-info-" + ProcessHandle.current().pid() + ".json");
+    }
+
+    public static void write(int port) {
+        try {
+            Path path = getMetadataFilePath();
+            OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValue(path.toFile(), createMetadata(port));
+            LOGGER.info("Postgres metadata file path: {}", path);
+        } catch (IOException e) {
+            LOGGER.warn("Failed to write Postgres metadata file.", e);
+        }
+    }
+
+    private static Map<String, Object> createMetadata(int port) {
+        Map<String, Object> meta = new HashMap<>();
+        meta.put(JAVA_PID, ProcessHandle.current().pid());
+        meta.put(POSTGRES_PORT, port);
+        meta.put(STARTED_BY, JABREF);
+        meta.put(STARTED_AT, DateTimeFormatter.ISO_INSTANT.format(Instant.now()));
+        return meta;
+    }
+}

jablib/src/main/java/org/jabref/logic/util/Directories.java

@@ -59,4 +59,8 @@ public static Path getSslDirectory() {
                                              "ssl",
                                              OS.APP_DIR_APP_AUTHOR));
     }
+
+    public static Path getTmpDirectory() {
+        return Path.of(System.getProperty("java.io.tmpdir"));
+    }
 }