Add option on desktop to remove the collections from solr #105 [skip ci]

src/main/java/com/databasepreservation/DBVTK.java

@@ -7,6 +7,7 @@
 
 import javax.servlet.http.HttpServlet;
 
+import com.databasepreservation.common.shared.client.ClientLogger;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
@@ -18,6 +19,11 @@
 import com.databasepreservation.common.server.ClientLoggerImpl;
 import com.databasepreservation.common.server.ViewerConfiguration;
 import com.databasepreservation.common.shared.ViewerConstants;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.Ordered;
+import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 
 @SpringBootApplication
 public class DBVTK {
@@ -27,6 +33,18 @@ public static void main(String[] args) {
     SpringApplication.run(DBVTK.class, args);
   }
 
+  @Configuration
+  public static class DefaultView implements WebMvcConfigurer {
+
+    @Override
+    public void addViewControllers(ViewControllerRegistry registry) {
+      if (ViewerConstants.DESKTOP.equals(System.getProperty("env", "server"))) {
+        registry.addViewController("/").setViewName("forward:/desktop.html");
+        registry.setOrder(Ordered.HIGHEST_PRECEDENCE);
+      }
+    }
+  }
+
   @Bean
   public ServletRegistrationBean<HttpServlet> browserService() {
     ServletRegistrationBean<HttpServlet> bean;

src/main/java/com/databasepreservation/common/client/BrowserService.java

@@ -96,6 +96,12 @@ void editSearch(String databaseUUID, String savedSearchUUID, String name, String
   void deleteSearch(String databaseUUID, String savedSearchUUID)
     throws AuthorizationDeniedException, GenericException, RequestNotValidException, NotFoundException;
 
+  Boolean deleteDatabaseCollection(String databaseUUID);
+
+  Boolean deleteRowsCollection(String databaseUUID);
+
+  Boolean deleteAllCollections(String databaseUUID);
+
   Boolean isAuthenticationEnabled() throws RODAException;
 
   User getAuthenticatedUser() throws RODAException;
@@ -139,10 +145,10 @@ boolean createSIARD(String UUID, ConnectionParameters connectionParameters,
     ExportOptionsParameters exportOptionsParameters, MetadataExportOptionsParameters metadataExportOptionsParameters)
     throws GenericException;
 
-  boolean migrateToDBMS(String databaseUUID, String siard, ConnectionParameters connectionParameters)
+  boolean migrateToDBMS(String databaseUUID, String siardVersion, String siardPath, ConnectionParameters connectionParameters)
     throws GenericException;
 
-  boolean migrateToSIARD(String databaseUUID, String siardPath, TableAndColumnsParameters tableAndColumnsParameters,
+  boolean migrateToSIARD(String databaseUUID, String siardVersion, String siardPath, TableAndColumnsParameters tableAndColumnsParameters,
     ExportOptionsParameters exportOptionsParameters, MetadataExportOptionsParameters metadataExportOptions)
     throws GenericException;
 

src/main/java/com/databasepreservation/common/client/BrowserServiceAsync.java

@@ -86,6 +86,12 @@ void editSearch(String databaseUUID, String savedSearchUUID, String name, String
 
   void deleteSearch(String databaseUUID, String savedSearchUUID, AsyncCallback<Void> async);
 
+  void deleteDatabaseCollection(String databaseUUID, AsyncCallback<Boolean> async);
+
+  void deleteRowsCollection(String databaseUUID, AsyncCallback<Boolean> async);
+
+  void deleteAllCollections(String databaseUUId, AsyncCallback<Boolean> async);
+
   void isAuthenticationEnabled(AsyncCallback<Boolean> async);
 
   /**
@@ -142,10 +148,10 @@ void createSIARD(String UUID, ConnectionParameters connectionParameters,
     ExportOptionsParameters exportOptionsParameters, MetadataExportOptionsParameters metadataExportOptionsParameters,
     AsyncCallback<Boolean> async);
 
-  void migrateToDBMS(String databaseUUID, String siard, ConnectionParameters connectionParameters,
+  void migrateToDBMS(String databaseUUID, String siardVersion, String siardPath, ConnectionParameters connectionParameters,
     AsyncCallback<Boolean> async);
 
-  void migrateToSIARD(String databaseUUID, String siardPath, TableAndColumnsParameters tableAndColumnsParameters,
+  void migrateToSIARD(String databaseUUID, String siardVersion, String siardPath, TableAndColumnsParameters tableAndColumnsParameters,
     ExportOptionsParameters exportOptionsParameters, MetadataExportOptionsParameters metadataExportOptionsParameters,
     AsyncCallback<Boolean> async);
 

src/main/java/com/databasepreservation/common/server/BrowserServiceImpl.java

@@ -1,5 +1,8 @@
 package com.databasepreservation.common.server;
 
+import static com.databasepreservation.common.shared.ViewerConstants.SOLR_INDEX_ROW_COLLECTION_NAME_PREFIX;
+import static com.databasepreservation.common.shared.ViewerConstants.SOLR_SEARCHES_DATABASE_UUID;
+
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
@@ -8,6 +11,7 @@
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletException;
 
+import com.databasepreservation.common.server.index.DatabaseRowsSolrManager;
 import org.apache.commons.lang3.StringUtils;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
@@ -23,6 +27,7 @@
 import org.roda.core.data.v2.index.IndexResult;
 import org.roda.core.data.v2.index.facet.Facets;
 import org.roda.core.data.v2.index.filter.Filter;
+import org.roda.core.data.v2.index.filter.SimpleFilterParameter;
 import org.roda.core.data.v2.index.sort.Sorter;
 import org.roda.core.data.v2.index.sublist.Sublist;
 import org.roda.core.data.v2.user.User;
@@ -33,6 +38,7 @@
 import com.databasepreservation.common.server.controller.SIARDController;
 import com.databasepreservation.common.server.controller.UserLoginController;
 import com.databasepreservation.common.server.index.factory.SolrClientFactory;
+import com.databasepreservation.common.server.index.schema.SolrDefaultCollectionRegistry;
 import com.databasepreservation.common.server.index.utils.SolrUtils;
 import com.databasepreservation.common.shared.ProgressData;
 import com.databasepreservation.common.shared.ValidationProgressData;
@@ -212,6 +218,40 @@ public void deleteSearch(String databaseUUID, String savedSearchUUID)
     ViewerFactory.getSolrManager().deleteSavedSearch(savedSearchUUID);
   }
 
+  @Override
+  public Boolean deleteDatabaseCollection(String databaseUUID) {
+    ViewerFactory.getSolrManager().deleteDatabasesCollection(databaseUUID);
+
+    return true;
+  }
+
+  @Override
+  public Boolean deleteRowsCollection(String databaseUUID) {
+    try {
+      final String collectionName = SOLR_INDEX_ROW_COLLECTION_NAME_PREFIX + databaseUUID;
+      if (SolrClientFactory.get().deleteCollection(collectionName)) {
+        Filter savedSearchFilter = new Filter(new SimpleFilterParameter(SOLR_SEARCHES_DATABASE_UUID, databaseUUID));
+        SolrUtils.delete(ViewerFactory.getSolrClient(), SolrDefaultCollectionRegistry.get(SavedSearch.class),
+            savedSearchFilter);
+
+        ViewerFactory.getSolrManager().markDatabaseCollection(databaseUUID, ViewerDatabase.Status.METADATA_ONLY);
+        return true;
+      }
+    } catch (GenericException | RequestNotValidException e) {
+      LOGGER.error("Error trying to remove the collection from Solr", e);
+      return false;
+    }
+    return false;
+  }
+
+  @Override
+  public Boolean deleteAllCollections(String databaseUUID) {
+    if (deleteRowsCollection(databaseUUID)) {
+      return deleteDatabaseCollection(databaseUUID);
+    }
+    return false;
+  }
+
   @Override
   public Boolean isAuthenticationEnabled() throws RODAException {
     return ViewerConfiguration.getInstance().getIsAuthenticationEnabled();
@@ -341,16 +381,18 @@ public boolean createSIARD(String UUID, ConnectionParameters connectionParameter
   }
 
   @Override
-  public boolean migrateToDBMS(String databaseUUID, String siard, ConnectionParameters connectionParameters)
+  public boolean migrateToDBMS(String databaseUUID, String siardVersion, String siardPath,
+    ConnectionParameters connectionParameters)
     throws GenericException {
-    return SIARDController.migrateToDBMS(databaseUUID, siard, connectionParameters);
+    return SIARDController.migrateToDBMS(databaseUUID, siardVersion, siardPath, connectionParameters);
   }
 
   @Override
-  public boolean migrateToSIARD(String databaseUUID, String siardPath,
+  public boolean migrateToSIARD(String databaseUUID, String siardVersion, String siardPath,
     TableAndColumnsParameters tableAndColumnsParameters, ExportOptionsParameters exportOptionsParameters,
     MetadataExportOptionsParameters metadataExportOptions) throws GenericException {
-    return SIARDController.migrateToSIARD(databaseUUID, siardPath, tableAndColumnsParameters, exportOptionsParameters,
+    return SIARDController.migrateToSIARD(databaseUUID, siardVersion, siardPath, tableAndColumnsParameters,
+      exportOptionsParameters,
       metadataExportOptions);
   }
 

src/main/java/com/databasepreservation/common/server/controller/SIARDController.java

@@ -144,20 +144,20 @@ public static boolean testConnection(String databaseUUID, String parametersJson)
     return false;
   }
 
-  public static boolean migrateToSIARD(String databaseUUID, String siard,
+  public static boolean migrateToSIARD(String databaseUUID, String siardVersion, String siardPath,
     TableAndColumnsParameters tableAndColumnsParameters, ExportOptionsParameters exportOptionsParameters,
     MetadataExportOptionsParameters metadataExportOptionsParameters) throws GenericException {
     Reporter reporter = getReporter(databaseUUID);
-    File f = new File(siard);
+    File f = new File(siardPath);
     if (f.exists() && !f.isDirectory()) {
       LOGGER.info("starting to convert database");
       final DatabaseMigration databaseMigration = initializeDatabaseMigration(reporter);
 
       databaseMigration.filterFactories(new ArrayList<>());
 
       // BUILD Import Module
-      databaseMigration.importModule(new SIARD2ModuleFactory());
-      databaseMigration.importModuleParameter(SIARD2ModuleFactory.PARAMETER_FILE, siard);
+      databaseMigration.importModule(getSIARDImportModuleFactory(siardVersion));
+      databaseMigration.importModuleParameter(SIARD2ModuleFactory.PARAMETER_FILE, siardPath);
 
       // BUILD Export Module
       setupSIARDExportModule(databaseMigration, tableAndColumnsParameters, exportOptionsParameters,
@@ -180,19 +180,19 @@ public static boolean migrateToSIARD(String databaseUUID, String siard,
     }
   }
 
-  public static boolean migrateToDBMS(String databaseUUID, String siard, ConnectionParameters connectionParameters)
+  public static boolean migrateToDBMS(String databaseUUID, String siardVersion, String siardPath, ConnectionParameters connectionParameters)
     throws GenericException {
     Reporter reporter = getReporter(databaseUUID);
-    File f = new File(siard);
+    File f = new File(siardPath);
     if (f.exists() && !f.isDirectory()) {
       LOGGER.info("starting to convert database");
       final DatabaseMigration databaseMigration = initializeDatabaseMigration(reporter);
 
       databaseMigration.filterFactories(new ArrayList<>());
 
       // BUILD Import Module
-      databaseMigration.importModule(new SIARD2ModuleFactory());
-      databaseMigration.importModuleParameter(SIARD2ModuleFactory.PARAMETER_FILE, siard);
+      databaseMigration.importModule(getSIARDImportModuleFactory(siardVersion));
+      databaseMigration.importModuleParameter(SIARD2ModuleFactory.PARAMETER_FILE, siardPath);
 
       // BUILD Export Module
       final DatabaseModuleFactory exportModuleFactory = getDatabaseExportModuleFactory(
@@ -386,7 +386,7 @@ public static String getDatabaseExportModules() throws GenericException {
     Set<DatabaseModuleFactory> databaseModuleFactories = ReflectionUtils.collectDatabaseModuleFactories();
     for (DatabaseModuleFactory factory : databaseModuleFactories) {
       if (!factory.getModuleName().equals("list-tables")) {
-        if (!factory.getModuleName().toLowerCase().contains("siard")) {
+        if (!factory.getModuleName().toLowerCase().contains("siard") && !factory.getModuleName().toLowerCase().equals("internal-dbvtk-export")) {
           if (factory.isEnabled() && factory.producesExportModules()) {
             getDatabaseModulesParameters(factory, dbptkModule);
           }
@@ -715,6 +715,29 @@ private static DatabaseModuleFactory getDatabaseImportModuleFactory(String modul
     return factory;
   }
 
+  private static DatabaseModuleFactory getSIARDImportModuleFactory(String version) {
+    Set<DatabaseModuleFactory> databaseModuleFactories = ReflectionUtils.collectDatabaseModuleFactories();
+    final String moduleName;
+    if (version.equals("2.0") || version.equals("2.1")) {
+      moduleName = "siard-2";
+    } else if (version.equals("1.0")) {
+      moduleName = "siard-1";
+    } else {
+      moduleName = "";
+    }
+
+    DatabaseModuleFactory factory = null;
+
+    for (DatabaseModuleFactory dbFactory : databaseModuleFactories) {
+      if (dbFactory.isEnabled() && dbFactory.producesImportModules()) {
+        if (dbFactory.getModuleName().equals(moduleName))
+          factory = dbFactory;
+      }
+    }
+
+    return factory;
+  }
+
   private static DatabaseModuleFactory getDatabaseExportModuleFactory(String moduleName) {
     Set<DatabaseModuleFactory> databaseModuleFactories = ReflectionUtils.collectDatabaseModuleFactories();
 

src/main/java/com/databasepreservation/common/server/index/DatabaseRowsSolrManager.java

@@ -7,6 +7,7 @@
 import java.util.Arrays;
 import java.util.List;
 
+import com.databasepreservation.common.server.index.schema.collections.DatabasesCollection;
 import org.apache.solr.client.solrj.SolrClient;
 import org.apache.solr.client.solrj.SolrRequest;
 import org.apache.solr.client.solrj.SolrServerException;
@@ -104,8 +105,8 @@ public void removeDatabase(ViewerDatabase database, Path lobFolder) throws Viewe
     }
 
     // delete related saved searches
-    Filter savedSearchFilter = new Filter(
-      new SimpleFilterParameter(ViewerConstants.SOLR_SEARCHES_DATABASE_UUID, database.getUUID()));
+      Filter savedSearchFilter = new Filter(
+        new SimpleFilterParameter(ViewerConstants.SOLR_SEARCHES_DATABASE_UUID, database.getUUID()));
     try {
       SolrUtils.delete(client, SolrDefaultCollectionRegistry.get(SavedSearch.class), savedSearchFilter);
       LOGGER.debug("Deleted saved searches for database {}", database.getUUID());
@@ -222,6 +223,17 @@ public void deleteSavedSearch(String uuid) {
     }
   }
 
+  public void deleteDatabasesCollection(final String UUID) {
+    try {
+      client.deleteById(ViewerConstants.SOLR_INDEX_DATABASES_COLLECTION_NAME, UUID);
+      client.commit(ViewerConstants.SOLR_INDEX_DATABASES_COLLECTION_NAME, true, true);
+    } catch (SolrServerException e) {
+      LOGGER.debug("Solr error while attempting to delete search", e);
+    } catch (IOException e) {
+      LOGGER.debug("IOException while attempting to delete search", e);
+    }
+  }
+
   private <T extends IsIndexed> void insertDocument(Class<T> objClass, T obj) throws ViewerException {
     SolrCollection<T> solrCollection = SolrDefaultCollectionRegistry.get(objClass);
     try {
@@ -284,12 +296,17 @@ private void insertDocument(String collection, SolrInputDocument doc) throws Vie
     }
   }
 
+  public void markDatabaseCollection(final String databaseUUID, ViewerDatabase.Status status) {
+    updateDatabaseFields(databaseUUID, Pair.of(ViewerConstants.SOLR_DATABASES_STATUS, status.toString()));
+  }
+
   public void markDatabaseAsReady(ViewerDatabaseFromToolkit viewerDatabase) throws ViewerException {
     updateDatabaseFields(viewerDatabase.getUUID(),
       Pair.of(ViewerConstants.SOLR_DATABASES_STATUS, ViewerDatabase.Status.AVAILABLE.toString()));
   }
 
-  private void updateDatabaseFields(String databaseUUID, Pair<String, ?>... fields) {
+  @SafeVarargs
+  private final void updateDatabaseFields(String databaseUUID, Pair<String, ?>... fields) {
     // create document to update this DB
     SolrInputDocument doc = new SolrInputDocument();
     doc.addField(ViewerConstants.INDEX_ID, databaseUUID);

src/main/java/com/databasepreservation/common/server/index/factory/CloudSolrClientFactory.java

@@ -193,6 +193,23 @@ protected boolean createCollection(String collection, Path configPath) {
         return ret;
     }
 
+    @Override
+    public boolean deleteCollection(String collection) {
+        try {
+            CollectionAdminRequest.Delete deleteCollection = CollectionAdminRequest.deleteCollection(collection);
+            final CollectionAdminResponse response = deleteCollection.process(getSolrClient());
+            if (!response.isSuccess()) {
+                LOGGER.error("Could not create collection {}: {}", collection, response.getErrorMessages());
+                return false;
+            } else {
+                return true;
+            }
+        } catch (SolrServerException | SolrException | IOException e) {
+            LOGGER.error("Error creating collection {}", collection, e);
+            return false;
+        }
+    }
+
     @Override
     protected Collection<String> getCollectionList() {
         Collection<String> ret = new ArrayList<>();

src/main/java/com/databasepreservation/common/server/index/factory/EmbeddedSolrClientFactory.java

@@ -97,4 +97,17 @@ protected boolean createCollection(String collection, Path configPath) {
         return ret;
     }
 
+  @Override
+  public boolean deleteCollection(String collection) {
+    try {
+      CoreContainer coreContainer = getSolrClient().getCoreContainer();
+      coreContainer.unload(collection, true, true, true);
+
+      return true;
+    } catch (SolrException e) {
+      LOGGER.error("Error deleting collection {}", collection, e);
+      return false;
+    }
+  }
+
 }

src/main/java/com/databasepreservation/common/server/index/factory/SolrClientFactory.java

@@ -90,6 +90,8 @@ protected void bootstrapDefaultCollections() throws IOException {
 
     protected abstract boolean createCollection(String collection, Path config);
 
+    public abstract boolean deleteCollection(String collection);
+
     protected abstract Collection<String> getCollectionList();
 
     public boolean createCollection(String collection) {

src/main/java/com/databasepreservation/common/shared/ViewerConstants.java

@@ -286,6 +286,9 @@ public class ViewerConstants {
   public static final String SIARD2 = "siard-2";
   public static final String SIARDDK = "siard-dk";
   public static final String SIARD2_1 = "siard-2.1";
+  public static final String SIARD_V10 = "1.0";
+  public static final String SIARD_V20 = "2.0";
+  public static final String SIARD_V21 = "2.1";
 
   /*
    * DBPTK Metadata