WIP Restapi

build.gradle

@@ -181,12 +181,12 @@ dependencies {
     implementation "org.tinylog:tinylog-api:2.5.0"
     implementation "org.tinylog:slf4j-tinylog:2.5.0"
     implementation "org.tinylog:tinylog-impl:2.5.0"
-
     implementation 'de.undercouch:citeproc-java:3.0.0-alpha.6'
 
     // jakarta.activation is already dependency of glassfish
     implementation group: 'jakarta.xml.bind', name: 'jakarta.xml.bind-api', version: '3.0.1'
     implementation group: 'org.glassfish.jaxb', name: 'jaxb-runtime', version: '3.0.2'
+    implementation 'jakarta.ws.rs:jakarta.ws.rs-api:3.0.0'
 
     implementation ('com.github.tomtung:latex2unicode_2.13:0.3.2') {
         exclude module: 'fastparse_2.13'

src/main/java/module-info.java

@@ -116,6 +116,7 @@
     requires net.harawata.appdirs;
 
     requires org.eclipse.jgit;
+    requires jakarta.ws.rs;
     uses org.eclipse.jgit.transport.SshSessionFactory;
     uses org.eclipse.jgit.lib.GpgSigner;
 }

src/main/java/org/jabref/logic/pdf/search/indexing/IndexingTaskManager.java.orig

@@ -0,0 +1,133 @@
+package org.jabref.logic.pdf.search.indexing;
+
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import org.jabref.gui.util.BackgroundTask;
+import org.jabref.gui.util.DefaultTaskExecutor;
+import org.jabref.gui.util.TaskExecutor;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.LinkedFile;
+
+/**
+ * Wrapper around {@link PdfIndexer} to execute all operations in the background.
+ */
+public class IndexingTaskManager extends BackgroundTask<Void> {
+
+    private final Queue<Runnable> taskQueue = new ConcurrentLinkedQueue<>();
+    private TaskExecutor taskExecutor;
+    private int numOfIndexedFiles = 0;
+
+    private final Object lock = new Object();
+    private boolean isRunning = false;
+    private boolean isBlockingNewTasks = false;
+
+    public IndexingTaskManager(TaskExecutor taskExecutor) {
+        this.taskExecutor = taskExecutor;
+        showToUser(true);
+        willBeRecoveredAutomatically(true);
+        DefaultTaskExecutor.runInJavaFXThread(() -> {
+            this.updateProgress(1, 1);
+            this.titleProperty().set(Localization.lang("Indexing pdf files"));
+        });
+    }
+
+    @Override
+    protected Void call() throws Exception {
+        synchronized (lock) {
+            isRunning = true;
+        }
+        updateProgress();
+        while (!taskQueue.isEmpty() && !isCanceled()) {
+            taskQueue.poll().run();
+            numOfIndexedFiles++;
+            updateProgress();
+        }
+        synchronized (lock) {
+            isRunning = false;
+        }
+        return null;
+    }
+
+    private void updateProgress() {
+        DefaultTaskExecutor.runInJavaFXThread(() -> {
+            updateMessage(Localization.lang("%0 of %1 linked files added to the index", numOfIndexedFiles, numOfIndexedFiles + taskQueue.size()));
+            updateProgress(numOfIndexedFiles, numOfIndexedFiles + taskQueue.size());
+        });
+    }
+
+    private void enqueueTask(Runnable indexingTask) {
+        if (!isBlockingNewTasks) {
+            taskQueue.add(indexingTask);
+            // What if already running?
+            synchronized (lock) {
+                if (!isRunning) {
+                    isRunning = true;
+                    this.executeWith(taskExecutor);
+                    showToUser(false);
+                }
+            }
+        }
+    }
+
+    public AutoCloseable blockNewTasks() {
+        synchronized (lock) {
+            isBlockingNewTasks = true;
+        }
+        return () -> {
+            synchronized (lock) {
+                isBlockingNewTasks = false;
+            }
+        };
+    }
+
+    public void createIndex(PdfIndexer indexer) {
+        enqueueTask(() -> indexer.createIndex());
+    }
+
+    public void updateIndex(PdfIndexer indexer, BibDatabaseContext databaseContext) {
+        Set<String> pathsToRemove = indexer.getListOfFilePaths();
+        for (BibEntry entry : databaseContext.getEntries()) {
+            for (LinkedFile file : entry.getFiles()) {
+                System.out.println("Adding file " + file.getLink());
+                enqueueTask(() -> indexer.addToIndex(entry, file, databaseContext));
+                pathsToRemove.remove(file.getLink());
+            }
+        }
+        for (String pathToRemove : pathsToRemove) {
+<<<<<<< HEAD
+=======
+            System.out.println("Removing file " + pathToRemove);
+>>>>>>> 972bac7252 (Cleanup index when opening a library)
+            enqueueTask(() -> indexer.removeFromIndex(pathToRemove));
+        }
+    }
+
+    public void addToIndex(PdfIndexer indexer, BibEntry entry, BibDatabaseContext databaseContext) {
+        enqueueTask(() -> addToIndex(indexer, entry, entry.getFiles(), databaseContext));
+    }
+
+    public void addToIndex(PdfIndexer indexer, BibEntry entry, List<LinkedFile> linkedFiles, BibDatabaseContext databaseContext) {
+        for (LinkedFile file : linkedFiles) {
+            enqueueTask(() -> indexer.addToIndex(entry, file, databaseContext));
+        }
+    }
+
+    public void removeFromIndex(PdfIndexer indexer, BibEntry entry, List<LinkedFile> linkedFiles) {
+        for (LinkedFile file : linkedFiles) {
+            enqueueTask(() -> indexer.removeFromIndex(file.getLink()));
+        }
+    }
+
+    public void removeFromIndex(PdfIndexer indexer, BibEntry entry) {
+        enqueueTask(() -> removeFromIndex(indexer, entry, entry.getFiles()));
+    }
+
+    public void updateDatabaseName(String name) {
+        DefaultTaskExecutor.runInJavaFXThread(() -> this.titleProperty().set(Localization.lang("Indexing for %0", name)));
+    }
+}

src/main/java/org/jabref/logic/shared/restserver/core/properties/ServerPropertyService.java

@@ -0,0 +1,47 @@
+package org.jabref.logic.shared.restserver.core.properties;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Properties;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ServerPropertyService {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ServerPropertyService.class);
+    private static ServerPropertyService instance;
+    private final Properties serverProperties;
+
+    private ServerPropertyService() {
+        serverProperties = loadProperties();
+    }
+
+    public static ServerPropertyService getInstance() {
+        if (instance == null) {
+            instance = new ServerPropertyService();
+        }
+        return instance;
+    }
+
+    /**
+     * Tries to determine the working directory of the library.
+     * Uses the first path it finds when resolving in this order:
+     * 1. Environment variable LIBRARY_WORKSPACE
+     * 2. Default User home with a new directory for the library
+     */
+    private Properties loadProperties() {
+        Properties properties = new Properties();
+        if (!((System.getenv("LIBRARY_WORKSPACE") == null) || System.getenv("LIBRARY_WORKSPACE").isBlank())) {
+            LOGGER.info("Environment Variable found, using defined directory: {}", System.getenv("LIBRARY_WORKSPACE"));
+            properties.setProperty("workingDirectory", System.getenv("LIBRARY_WORKSPACE"));
+        } else {
+            LOGGER.info("Working directory was not found in either the properties or the environment variables, falling back to default location: {}", System.getProperty("user.home") + "/planqk-library");
+            properties.setProperty("workingDirectory", System.getProperty("user.home") + "/planqk-library");
+        }
+        return properties;
+    }
+
+    public Path getWorkingDirectory() {
+        return Paths.get(serverProperties.getProperty("workingDirectory"));
+    }
+}

src/main/java/org/jabref/logic/shared/restserver/core/repository/CrawlTask.java

@@ -0,0 +1,33 @@
+package org.jabref.logic.shared.restserver.core.repository;
+
+import java.io.IOException;
+
+import org.jabref.logic.crawler.Crawler;
+import org.jabref.logic.exporter.SaveException;
+
+import org.eclipse.jgit.api.errors.GitAPIException;
+
+public class CrawlTask implements Runnable {
+    private final Crawler crawler;
+    private TaskStatus status;
+
+    public CrawlTask(Crawler crawler) {
+        this.crawler = crawler;
+    }
+
+    public TaskStatus getStatus() {
+        return status;
+    }
+
+    @Override
+    public void run() {
+        status = TaskStatus.RUNNING;
+        try {
+            crawler.performCrawl();
+        } catch (IOException | GitAPIException | SaveException e) {
+            status = TaskStatus.FAILED;
+            throw new RuntimeException(e);
+        }
+        status = TaskStatus.DONE;
+    }
+}