Fix for postgres instance process closing

CHANGELOG.md

@@ -108,6 +108,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We fixed an issue where downloading PDFs from URLs to empty entries resulted in meaningless filenames like "-.pdf". [#12917](https://github.com/JabRef/jabref/issues/12917)
 - We fixed an issue where pasting a PDF URL into the main table caused an import error instead of creating a new entry. [#12911](https://github.com/JabRef/jabref/pull/12911)
 - We fixed an issue where libraries would sometimes be hidden when closing tabs with the Welcome tab open. [#12894](https://github.com/JabRef/jabref/issues/12894)
+- We fixed an issue where postgres processes remain running after JabRef crashes or is forcefully terminated. [#12927](https://github.com/JabRef/jabref/pull/12927)
 - We fixed an issue with deleting entries in large libraries that caused it to take a long time. [#8976](https://github.com/JabRef/jabref/issues/8976)
 
 ### Removed

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

@@ -9,6 +9,7 @@
 import org.jabref.gui.util.DefaultFileUpdateMonitor;
 import org.jabref.logic.UiCommand;
 import org.jabref.logic.preferences.CliPreferences;
+import org.jabref.logic.search.PostgreProcessCleaner;
 import org.jabref.logic.search.PostgreServer;
 import org.jabref.logic.util.HeadlessExecutorService;
 import org.jabref.migrations.PreferencesMigrations;
@@ -26,6 +27,9 @@ public class Launcher {
     public static void main(String[] args) {
         JabKit.initLogging(args);
 
+        // Clean up old Postgres instance if needed
+        PostgreProcessCleaner.getInstance().checkAndCleanupOldInstances();
+
         // Initialize preferences
         final JabRefGuiPreferences preferences = JabRefGuiPreferences.getInstance();
         Injector.setModelOrService(CliPreferences.class, preferences);
@@ -42,6 +46,9 @@ public static void main(String[] args) {
         PostgreServer postgreServer = new PostgreServer();
         Injector.setModelOrService(PostgreServer.class, postgreServer);
 
+        // Register shutdown hook
+        Runtime.getRuntime().addShutdownHook(new Thread(postgreServer::shutdown));
+
         JabRefGUI.setup(uiCommands, preferences, fileUpdateMonitor);
         JabRefGUI.launch(JabRefGUI.class, args);
     }

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

@@ -0,0 +1,169 @@
+package org.jabref.logic.search;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+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 org.jabref.logic.os.OS;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+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 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) {
+        try {
+            Process process = createPortLookupProcess(port);
+            if (process == null) {
+                return -1;
+            }
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+                return extractPidFromOutput(reader);
+            }
+        } catch (Exception e) {
+            LOGGER.warn("Failed to get PID for port {}: {}", port, e.getMessage(), e);
+        }
+        return -1;
+    }
+
+    private Process createPortLookupProcess(int port) throws IOException {
+        if (OS.LINUX || OS.OS_X) {
+            return new ProcessBuilder("lsof", "-i", "tcp:" + port, "-sTCP:LISTEN", "-Pn")
+                    .redirectErrorStream(true).start();
+        } else if (OS.WINDOWS) {
+            return executeWindowsCommand(port);
+        }
+        return null;
+    }
+
+    private Process executeWindowsCommand(int port) throws IOException {
+        String systemRoot = System.getenv("SystemRoot");
+        if (systemRoot != null && !systemRoot.isBlank()) {
+            String netStatPath = systemRoot + "\\System32\\netstat.exe";
+            String findStrPath = systemRoot + "\\System32\\findstr.exe";
+            String command = netStatPath + " -ano | " + findStrPath + " :" + port;
+            return new ProcessBuilder("cmd.exe", "/c", command)
+                    .redirectErrorStream(true).start();
+        }
+        return null;
+    }
+
+    private long extractPidFromOutput(BufferedReader reader) throws IOException {
+        String line;
+        while ((line = reader.readLine()) != null) {
+            if (OS.LINUX || OS.OS_X) {
+                Long pid = parsePidFromLine(line);
+                if (pid != null) {
+                    return pid;
+                }
+            } else if (OS.WINDOWS) {
+                Long pid = parseWindowsPidFromLine(line);
+                if (pid != null) {
+                    return pid;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private Long parsePidFromLine(String line) {
+        String[] parts = line.trim().split("\\s+");
+        if (parts.length > 1 && parts[1].matches("\\d+")) {
+            return Long.parseLong(parts[1]);
+        }
+        return null;
+    }
+
+    private Long parseWindowsPidFromLine(String line) {
+        String[] parts = line.trim().split("\\s+");
+        if (parts.length >= 5 && parts[parts.length - 1].matches("\\d+")) {
+            return Long.parseLong(parts[parts.length - 1]);
+        }
+        return null;
+    }
+}

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;

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

@@ -0,0 +1,44 @@
+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;
+
+public class PostgresMetadataWriter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(PostgresMetadataWriter.class);
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    private PostgresMetadataWriter() {
+    }
+
+    public static Path getMetadataFilePath() {
+        return Path.of(System.getProperty("java.io.tmpdir"),
+                       "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("javaPid", ProcessHandle.current().pid());
+        meta.put("postgresPort", port);
+        meta.put("startedBy", "jabref");
+        meta.put("startedAt", DateTimeFormatter.ISO_INSTANT.format(Instant.now()));
+        return meta;
+    }
+}