Made the close/kill database exception proof to unlock the file once …

console/src/test/java/com/arcadedb/console/BaseGraphServerTest.java

@@ -308,6 +308,19 @@ protected int[] getServerToCheck() {
   }
 
   protected void deleteDatabaseFolders() {
+    if (databases != null)
+      for (int i = 0; i < databases.length; ++i) {
+        if (databases[i] != null)
+          databases[i].drop();
+      }
+
+    if (servers != null)
+      for (int i = 0; i < getServerCount(); ++i)
+        if (getServer(i).existsDatabase(getDatabaseName()))
+          getServer(i).getDatabase(getDatabaseName()).drop();
+
+    Assertions.assertTrue(DatabaseFactory.getActiveDatabaseInstances().isEmpty(), "Found active databases: " + DatabaseFactory.getActiveDatabaseInstances());
+
     for (int i = 0; i < getServerCount(); ++i)
       FileUtils.deleteRecursively(new File(getDatabasePath(i)));
     FileUtils.deleteRecursively(new File(GlobalConfiguration.SERVER_ROOT_PATH.getValueAsString() + "/replication"));

console/src/test/java/com/arcadedb/console/ConsoleTest.java

@@ -15,6 +15,7 @@
  */
 package com.arcadedb.console;
 
+import com.arcadedb.database.DatabaseFactory;
 import com.arcadedb.utility.FileUtils;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
@@ -36,6 +37,7 @@ public void populate() throws IOException {
   @AfterEach
   public void drop() {
     console.close();
+    Assertions.assertTrue(DatabaseFactory.getActiveDatabaseInstances().isEmpty(), "Found active databases: " + DatabaseFactory.getActiveDatabaseInstances());
     FileUtils.deleteRecursively(new File(DB_PATH));
   }
 

engine/src/main/java/com/arcadedb/database/DatabaseFactory.java

@@ -17,6 +17,7 @@
 
 import com.arcadedb.ContextConfiguration;
 import com.arcadedb.engine.PaginatedFile;
+import com.arcadedb.exception.DatabaseOperationException;
 import com.arcadedb.schema.EmbeddedSchema;
 import com.arcadedb.security.SecurityManager;
 
@@ -26,18 +27,19 @@
 import java.util.concurrent.*;
 
 public class DatabaseFactory implements AutoCloseable {
+  private              SecurityManager                                            security;
+  private              boolean                                                    autoTransaction      = false;
+  private final static Charset                                                    DEFAULT_CHARSET      = StandardCharsets.UTF_8;
+  private static final Map<String, Database>                                      ACTIVE_INSTANCES     = new ConcurrentHashMap<>();
   private final        ContextConfiguration                                       contextConfiguration = new ContextConfiguration();
   private final        String                                                     databasePath;
   private final        Map<DatabaseInternal.CALLBACK_EVENT, List<Callable<Void>>> callbacks            = new HashMap<>();
-  private final static Charset                                                    DEFAULT_CHARSET      = StandardCharsets.UTF_8;
-  private              SecurityManager                                            security;
-  private              boolean                                                    autoTransaction      = false;
 
   public DatabaseFactory(final String path) {
     if (path == null || path.isEmpty())
       throw new IllegalArgumentException("Missing path");
 
-    if (path.endsWith("/"))
+    if (path.endsWith("/") || path.endsWith("\\"))
       databasePath = path.substring(0, path.length() - 1);
     else
       databasePath = path;
@@ -55,21 +57,35 @@ public boolean exists() {
     return exists;
   }
 
+  public String getDatabasePath() {
+    return databasePath;
+  }
+
   public Database open() {
     return open(PaginatedFile.MODE.READ_WRITE);
   }
 
   public synchronized Database open(final PaginatedFile.MODE mode) {
+    checkForActiveInstance(databasePath);
+
     final EmbeddedDatabase database = new EmbeddedDatabase(databasePath, mode, contextConfiguration, security, callbacks);
     database.setAutoTransaction(autoTransaction);
     database.open();
+
+    registerActiveInstance(database);
+
     return database;
   }
 
   public synchronized Database create() {
+    checkForActiveInstance(databasePath);
+
     final EmbeddedDatabase database = new EmbeddedDatabase(databasePath, PaginatedFile.MODE.READ_WRITE, contextConfiguration, security, callbacks);
     database.setAutoTransaction(autoTransaction);
     database.create();
+
+    registerActiveInstance(database);
+
     return database;
   }
 
@@ -106,4 +122,28 @@ public void registerCallback(final DatabaseInternal.CALLBACK_EVENT event, Callab
     }
     callbacks.add(callback);
   }
+
+  public static Database getActiveDatabaseInstance(final String databasePath) {
+    return ACTIVE_INSTANCES.get(databasePath);
+  }
+
+  protected static void removeActiveDatabaseInstance(final String databasePath) {
+    ACTIVE_INSTANCES.remove(databasePath);
+  }
+
+  public static Collection<Database> getActiveDatabaseInstances() {
+    return Collections.unmodifiableCollection(ACTIVE_INSTANCES.values());
+  }
+
+  private static void checkForActiveInstance(final String databasePath) {
+    if (ACTIVE_INSTANCES.get(databasePath) != null)
+      throw new DatabaseOperationException("Found active instance of database '" + databasePath + "' already in use");
+  }
+
+  private static void registerActiveInstance(final EmbeddedDatabase database) {
+    if (ACTIVE_INSTANCES.putIfAbsent(database.databasePath, database) != null) {
+      database.close();
+      throw new DatabaseOperationException("Found active instance of database '" + database.databasePath + "' already in use");
+    }
+  }
 }