GitLab

at 2020-04-14T00:49:37+02:00

Accumulation de fichiers - Closes #1462

 transient = true

 final = true

+[option temporaryDirectory]

+description = observe.config.temporaryDirectory.description

+key = temporary.directory

+type = file

+defaultValue = ${data.directory}/tmp

+transient = true

+final = true

+

 [option tmpDirectory]

-description = observe.config.defaultTmpDirectory.description

+description = observe.config.temporaryDirectory.description

 key = tmp.directory

 type = file

 defaultValue = ${data.directory}/tmp

 type = fr.ird.observe.validation.SeineBycatchObservedSystemConfig

 defaultValue = {\"fr.ird.referential.common.Species#1239832684290#0.04680507324710936\": [\"fr.ird.referential.ps.observation.ObservedSystem#0#1.0\",\"fr.ird.referential.ps.observation.ObservedSystem#0#1.1\"]}

+[option temporaryFilesTimeout]

+description = observe.config.temporaryFilesTimeout.description

+key = observe.config.temporaryFilesTimeout

+type = int

+defaultValue = 120

+

 [action help]

 description = observe.action.commandline.help

 action = "fr.ird.observe.client.ObserveCLAction#help"

 observe.config.defaultMapDirectory.description

 observe.config.defaultReportDirectory.description

 observe.config.defaultResourcesDirectory.description

-observe.config.defaultTmpDirectory.description

 observe.config.defaultValidationReportDirectory.description

 observe.config.h2.can.editReferential.description

 observe.config.h2.can.migrate.description

 observe.config.speciesList.seine.observation.targetCatch

 observe.config.swingSessionFile.description

 observe.config.temperature.format

+observe.config.temporaryDirectory.description

+observe.config.temporaryFilesTimeout.description

 observe.config.ui.autoPopupNumberEditor

 observe.config.ui.blockStateColor

 observe.config.ui.busyStateColor

 import fr.ird.observe.gson.ObserveDtoGsonSupplier;

 import fr.ird.observe.navigation.model.edit.ObserveEditModel;

 import fr.ird.observe.navigation.model.select.ObserveSelectModel;

+import fr.ird.observe.services.service.CleanTemporaryFilesTaskConfiguration;

 import io.ultreia.java4all.application.context.spi.ApplicationComponentInstantiateStrategy;

 import io.ultreia.java4all.application.context.spi.GenerateApplicationComponent;

 import io.ultreia.java4all.application.template.TemplateGeneratorConfig;

         hints = {

                 TemplateGeneratorConfig.class,

                 ObServeSwingSessionConfig.class,

-                ReferentialLocaleConfig.class},

+                ReferentialLocaleConfig.class,

+                CleanTemporaryFilesTaskConfiguration.class},

         instantiateStrategy = ApplicationComponentInstantiateStrategy.SUPPLIER,

         instantiateSupplier = ClientConfigFinder.class

 )

 @GenerateTemplate(template = "about.ftl")

-public class ClientConfig extends GeneratedClientConfig implements TemplateGeneratorConfig, ObServeSwingSessionConfig, ReferentialLocaleConfig, NavigationTreeConfig {

+public class ClientConfig extends GeneratedClientConfig implements TemplateGeneratorConfig, ObServeSwingSessionConfig, ReferentialLocaleConfig, NavigationTreeConfig, CleanTemporaryFilesTaskConfiguration {

     public static final String DB_NAME = "obstuna";

     public static final List<ClientConfigOption> MAP_LAYERS = ImmutableList.of(

         resourceManager.createDirectory(this, ClientConfigOption.TMP_DIRECTORY);

         // suppression du contenu du répertoire temporaire

-        FileUtils.cleanDirectory(this.getTmpDirectory());

+        FileUtils.cleanDirectory(this.getTemporaryDirectory());

         // 3 - backup directory

 import fr.ird.observe.dto.decoration.DecoratorService;

 import fr.ird.observe.dto.decoration.DecoratorServiceApplicationComponent;

 import fr.ird.observe.dto.decoration.ObserveI18nDecoratorHelper;

+import fr.ird.observe.services.service.CleanTemporaryFilesTask;

 import io.ultreia.java4all.application.context.ApplicationContext;

 import io.ultreia.java4all.application.context.spi.GenerateApplicationComponent;

 import io.ultreia.java4all.i18n.I18n;

 import java.awt.event.WindowAdapter;

 import java.awt.event.WindowEvent;

 import java.beans.PropertyChangeListener;

+import java.io.Closeable;

 import java.util.List;

 import java.util.Locale;

 import java.util.Objects;

+import java.util.Timer;

 import static io.ultreia.java4all.i18n.I18n.t;

 import static javax.swing.JOptionPane.CLOSED_OPTION;

         ObserveSwingSessionHelper.class,

         ActionExecutor.class

 })

-public class ClientUIContext {

+public class ClientUIContext implements Closeable {

     private static final Logger log = LogManager.getLogger(ClientUIContext.class);

     private final ActionExecutor actionExecutor;

     private ObserveMainUI mainUI;

     private ObserveUICallbackManager uiCallbackManager;

+    private Timer deleteTemporaryFilesTimer;

     private final BusyModel busyModel;

+

     public ClientUIContext(DecoratorService decoratorService, ClientConfig clientConfig, ObserveSwingSessionHelper observeSwingSessionHelper, ActionExecutor actionExecutor) {

         this.decoratorService = decoratorService;

         this.clientConfig = clientConfig;

         this.busyModel = new BusyModel();

     }

+    public void initDeleteTemporaryFilesTimer() {

+        if (deleteTemporaryFilesTimer != null) {

+            closeDeleteTemporaryFilesTimer();

+        }

+        deleteTemporaryFilesTimer = CleanTemporaryFilesTask.create(getClientConfig());

+    }

+

     public static void displayInfo(String text) {

         JFrame ui = ClientUIContextApplicationComponent.value().getMainUI();

         if (ui == null) {

         return observeSwingSessionHelper;

     }

+    @Override

     public void close() {

+        closeDeleteTemporaryFilesTimer();

         mainUI = null;

     }

     public BusyModel getBusyModel() {

         return busyModel;

     }

+

+

+    void closeDeleteTemporaryFilesTimer() {

+        if (deleteTemporaryFilesTimer != null) {

+            try {

+                deleteTemporaryFilesTimer.cancel();

+            } catch (Exception e) {

+                log.error("Could not terminates delete temporary files timer...", e);

+            }

+        }

+    }

+

 }
 package fr.ird.observe.client;

 import fr.ird.observe.client.configuration.ClientConfig;

+import fr.ird.observe.client.configuration.ClientConfigApplicationComponent;

 import fr.ird.observe.services.ObserveServiceMainFactory;

 import fr.ird.observe.services.ObserveServiceMainFactoryApplicationComponent;

 import fr.ird.observe.spi.DtoModelHelper;

         //FIXME Je ne comprends pas pourquoi cela ne fonctionne plus.

 //        config.get().setOption("user.home", SystemUtils.USER_HOME);

-        log.debug("Init model helper: " + DtoModelHelper.class);

+        log.debug(String.format("Init model helper: %s", DtoModelHelper.class));

         ObserveServiceMainFactory serviceMainFactory = ObserveServiceMainFactoryApplicationComponent.value();

-        log.info("Initialize services factory: " + serviceMainFactory);

+        log.info(String.format("Initialize services factory: %s", serviceMainFactory));

+        ClientUIContext clientUIContext = ClientUIContextApplicationComponent.value();

+        log.info("Initialize delete temporary files task.");

+        clientUIContext.initDeleteTemporaryFilesTimer();

     }

     // We put here the i18n keys from the client-runner module, otherwise we need yet another module before observe-i18n

     public ObserveSwingDataSource newTemporaryH2DataSource(String label) {

-        File tmpDirectory = config.getTmpDirectory();

+        File tmpDirectory = config.getTemporaryDirectory();

         File dbDirectory = new File(tmpDirectory, ClientConfig.DB_NAME + UUID.randomUUID().toString());

         Locale locale = config.getLocale();

-        File tmpDirectory = config.getTmpDirectory();

+        File tmpDirectory = config.getTemporaryDirectory();

         ReferentialLocale referentialLocale = ReferentialLocale.valueOf(locale);

 observe.config.defaultMapDirectory.description=Default directory where to store map layers

 observe.config.defaultReportDirectory.description=Default directory where to store report definition files

 observe.config.defaultResourcesDirectory.description=Default user resources directory

-observe.config.defaultTmpDirectory.description=Default temporary directory used by application and clean at each launch.

 observe.config.defaultValidationReportDirectory.description=Default validation report directory

 observe.config.devMode=Dev mode

 observe.config.floatingObjectPresets.description=Floating Objects references

 observe.config.speciesList.seine.observation.targetCatch=Species for target catches

 observe.config.swingSessionFile.description=Swing session file.

 observe.config.temperature.format=Default temperature format

+observe.config.temporaryDirectory.description=Default temporary directory used by application and clean at each launch.

+observe.config.temporaryFilesTimeout.description=Temporary files delete (in hours)

 observe.config.ui.autoPopupNumberEditor=Flag sets to true when number editor show automaticly popup

 observe.config.ui.blockStateColor=Color of block state

 observe.config.ui.busyStateColor=Color of busy state

 observeweb.host.description=Application host

 observeweb.httpTimeout.description=Http timeout in milli seconds

 observeweb.log4jConfigurationFile.description=Path to log configuration file

-observeweb.sessionExpirationDelay.description=Session expiration deplay (in minutes)

+observeweb.sessionExpirationDelay.description=Session expiration delay (in minutes)

 observeweb.sessionMaximumSize.description=Session maximum size

 observeweb.temporaryDirectory.description=Path to temporary directory

 observeweb.usersConfigurationFile.description=Path to users configuration file
 observe.config.defaultMapDirectory.description=El directorio donde se ubican los mapas.

 observe.config.defaultReportDirectory.description=Directorio por defecto de los informes de la aplicación

 observe.config.defaultResourcesDirectory.description=Directorio de almacenamiento de los recursos de usuario como las traducciones o la consultas de informes

-observe.config.defaultTmpDirectory.description=Directorio temporal por defecto

 observe.config.defaultValidationReportDirectory.description=Directorio por defecto de almacenamiento de los informes de validación

 observe.config.devMode=Modo desarrollador

 observe.config.floatingObjectPresets.description=Objetos flotantes de referencia

 observe.config.speciesList.seine.observation.targetCatch=Especies par las capturas objetivo

 observe.config.swingSessionFile.description=Copia de seguridad del estado del UI.

 observe.config.temperature.format=Unidad de temperatura

+observe.config.temporaryDirectory.description=Directorio temporal por defecto

+observe.config.temporaryFilesTimeout.description=Temporary files delete (in hours) \#TODO

 observe.config.ui.autoPopupNumberEditor=Para mostrar automáticamente el editor numérico durante la edición de un número

 observe.config.ui.blockStateColor=Color of block state \#TODO

 observe.config.ui.busyStateColor=Color of busy state \#TODO

 observe.config.defaultMapDirectory.description=Le répertoire où sont stockées les cartes.

 observe.config.defaultReportDirectory.description=Répertoire par défaut des rapports de l'application

 observe.config.defaultResourcesDirectory.description=Le répertoire où sont stockées les ressources de l'utilisateur comme les traductions ou les requêtes de rapports.

-observe.config.defaultTmpDirectory.description=Le répertoire temporaire par défaut

 observe.config.defaultValidationReportDirectory.description=Le répertoire par défaut où sont stockés les rapports de validation

 observe.config.devMode=Mode développeur

 observe.config.floatingObjectPresets.description=Objets flottants de référence

 observe.config.speciesList.seine.observation.targetCatch=Espèces pour les captures cible

 observe.config.swingSessionFile.description=Fichier de sauvegarde des états des UI.

 observe.config.temperature.format=Unité de température

+observe.config.temporaryDirectory.description=Le répertoire temporaire par défaut

+observe.config.temporaryFilesTimeout.description=Nettoyage des fichiers temporaires (en heures)

 observe.config.ui.autoPopupNumberEditor=Pour afficher automatiquement l'éditeur numérique lors de l'édition d'un nombre

 observe.config.ui.blockStateColor=Couleur lorsque l'on bloque une partie de l'application

 observe.config.ui.busyStateColor=Couleur lorsque l'application est occupée

-package fr.ird.observe.entities;

-

-/*

- * #%L

- * ObServe :: Persistence

- * %%

- * Copyright (C) 2008 - 2020 IRD, Code Lutin, Ultreia.io

- * %%

- * This program is free software: you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as

- * published by the Free Software Foundation, either version 3 of the

- * License, or (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public

- * License along with this program.  If not, see

- * <http://www.gnu.org/licenses/gpl-3.0.html>.

- * #L%

- */

-

-import org.nuiton.topia.persistence.internal.AbstractTopiaDao;

-import org.nuiton.topia.persistence.support.TopiaSqlQuery;

-

-import java.sql.Connection;

-import java.sql.PreparedStatement;

-import java.sql.ResultSet;

-import java.sql.SQLException;

-import java.sql.Timestamp;

-import java.util.Date;

-import java.util.List;

-import java.util.Map;

-

-public abstract class AbstractObserveTopiaDao<E extends Entity> extends AbstractTopiaDao<E> {

-

-    private final GetLastUpdateDateSqlQuery getLastUpdateDateSqlQuery;

-

-    protected AbstractObserveTopiaDao() {

-        String schemaName = getTopiaEntityEnum().dbSchemaName();

-        String tableName = getTopiaEntityEnum().dbTableName();

-        getLastUpdateDateSqlQuery = new GetLastUpdateDateSqlQuery(schemaName, tableName);

-    }

-

-    public Date getLastUpdateDate() {

-        return topiaSqlSupport.findSingleResult(getLastUpdateDateSqlQuery);

-    }

-

-    public <O> List<O> findAllFromHql(String hql, Map<String, Object> hqlParameters) {

-        return findAll(hql, hqlParameters);

-    }

-

-    private static class GetLastUpdateDateSqlQuery extends TopiaSqlQuery<Timestamp> {

-

-        protected final String sql;

-

-        private GetLastUpdateDateSqlQuery(String schemaName, String tableName) {

-            this.sql = "SELECT max(" + Entity.PROPERTY_LAST_UPDATE_DATE + ") FROM " + schemaName + "." + tableName;

-        }

-

-        @Override

-        public PreparedStatement prepareQuery(Connection connection) throws SQLException {

-            return connection.prepareStatement(sql);

-        }

-

-        @Override

-        public Timestamp prepareResult(ResultSet set) throws SQLException {

-            return set.getTimestamp(1);

-        }

-

-    }

-

-

-}
-package fr.ird.observe.entities;

-

-/*

- * #%L

- * ObServe :: Persistence

- * %%

- * Copyright (C) 2008 - 2020 IRD, Code Lutin, Ultreia.io

- * %%

- * This program is free software: you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as

- * published by the Free Software Foundation, either version 3 of the

- * License, or (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public

- * License along with this program.  If not, see

- * <http://www.gnu.org/licenses/gpl-3.0.html>.

- * #L%

- */

-

-import org.nuiton.topia.persistence.BeanTopiaConfiguration;

-import org.nuiton.topia.persistence.HibernateAvailableSettings;

-import org.nuiton.topia.persistence.jdbc.JdbcConfiguration;

-

-import java.io.IOException;

-import java.io.InputStream;

-import java.util.Map;

-import java.util.Properties;

-import java.util.TreeMap;

-

-/**

- * Created on 23/08/15.

- *

- * @author Tony Chemit - dev@tchemit.fr

- */

-public class ObserveTopiaConfiguration extends BeanTopiaConfiguration {

-

-    private static final long serialVersionUID = 1L;

-

-    private final boolean h2Configuration;

-    protected final boolean showSql;

-    private static final Map<String, String> HIBERNATE_GLOBAL_PROPERTIES;

-

-    static {

-

-        Properties p = new Properties();

-        try (InputStream stream = ObserveTopiaPersistenceContext.class.getResourceAsStream("/hibernate.properties")) {

-            try {

-                p.load(stream);

-            } catch (IOException e) {

-                throw new IllegalStateException(e);

-            }

-        } catch (IOException e) {

-            throw new IllegalStateException(e);

-        }

-        HIBERNATE_GLOBAL_PROPERTIES = new TreeMap<>();

-        for (String s : p.stringPropertyNames()) {

-            HIBERNATE_GLOBAL_PROPERTIES.put(s, p.getProperty(s));

-        }

-

-    }

-

-    public ObserveTopiaConfiguration(JdbcConfiguration jdbcConfiguration, boolean h2Configuration, boolean showSql) {

-        super(jdbcConfiguration);

-        this.h2Configuration = h2Configuration;

-        this.showSql = showSql;

-        if (showSql) {

-            hibernateExtraConfiguration.put(HibernateAvailableSettings.SHOW_SQL, Boolean.TRUE.toString());

-        }

-        hibernateExtraConfiguration.putAll(HIBERNATE_GLOBAL_PROPERTIES);

-    }

-

-    public boolean isH2Configuration() {

-        return h2Configuration;

-    }

-

-    public boolean isShowSql() {

-        return showSql;

-    }

-}
-package fr.ird.observe.entities;

-

-/*

- * #%L

- * ObServe :: Persistence

- * %%

- * Copyright (C) 2008 - 2020 IRD, Code Lutin, Ultreia.io

- * %%

- * This program is free software: you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as

- * published by the Free Software Foundation, either version 3 of the

- * License, or (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public

- * License along with this program.  If not, see

- * <http://www.gnu.org/licenses/gpl-3.0.html>.

- * #L%

- */

-

-import org.apache.logging.log4j.Logger;

-import org.apache.logging.log4j.LogManager;

-import org.nuiton.topia.persistence.jdbc.JdbcConfiguration;

-import org.nuiton.topia.persistence.jdbc.JdbcConfigurationBuilder;

-import org.nuiton.topia.service.migration.TopiaMigrationService;

-import org.nuiton.topia.service.script.TopiaSqlScriptGeneratorServiceImpl;

-

-import java.io.File;

-

-/**

- * Created on 23/08/15.

- *

- * @author Tony Chemit - dev@tchemit.fr

- */

-public class ObserveTopiaConfigurationFactory {

-

-    /** l'url d'acces a la base locale */

-    private static final String H2_LOCAL_URL =

-            "jdbc:h2:file:%s;" +

-                    // on peut aussi utiliser file, socket

-                    "FILE_LOCK=file;" +

-                    //1 or 2 is needed to restore avec crash

-                    // 0: logging is disabled (faster),

-                    // 1: logging of the data is enabled, but logging of the index

-                    // changes is disabled (default), 2: logging of both data and index

-                    // changes are enabled

-                    "LOG=0;" +

-                    // on peut aussi utiliser hsqldb, mysql ou postgresql

-                    "MODE=postgresql;" +

-                    //"MODE=hsqldb;" +

-                    // Sets the default lock timeout (in milliseconds) in this

-                    // database that is used for the new sessions.

-                    "DEFAULT_LOCK_TIMEOUT=100;" +

-                    // -1: the database is never closed until the close delay is set to

-                    // some other rev or SHUTDOWN is called., 0: no delay (default; the

-                    // database is closed if the last connection to it is closed)., n:

-                    // the database is left open for n second after the last connection

-                    // is closed.

-                    "DB_CLOSE_DELAY=0;" +

-                    // 0: no locking (should only be used for testing),

-                    // 1: table level locking (default),

-                    // 2: table level locking with garbage collection (if the

-                    // application does not close all connections).

-                    // LOCK_MODE 3 (READ_COMMITTED). Table level locking, but only when

-                    // writing (no read locks).

-                    "LOCK_MODE=3;" +

-                    // Levels: 0=off, 1=error, 2=info, 3=debug.

-                    "TRACE_LEVEL_FILE=0;" +

-                    // on system.out: 0=off, 1=error, 2=info, 3=debug.

-                    "TRACE_LEVEL_SYSTEM_OUT=0;" +

-                    // maximumn cache to improve performance...

-                    "CACHE_SIZE=65536;" +

-                    // avoid timeout on reading tables (see http://stackoverflow.com/questions/4162557/timeout-error-trying-to-lock-table-in-h2)

-                    "MVCC=true";

-

-    private static final JdbcConfigurationBuilder JDBC_CONFIGURATION_BUILDER = new JdbcConfigurationBuilder();

-    private static final Logger log = LogManager.getLogger(ObserveTopiaConfigurationFactory.class);

-

-    public static ObserveTopiaConfiguration forPostgresqlDatabase(String jdbcUrl,

-                                                                  String username,

-                                                                  String password,

-                                                                  boolean initSchema,

-                                                                  boolean traceSql) {

-

-        JdbcConfiguration jdbcConfiguration = JDBC_CONFIGURATION_BUILDER.forPostgresqlDatabase(jdbcUrl, username, password);

-

-        ObserveTopiaConfiguration topiaConfiguration = createTopiaConfiguration(jdbcConfiguration,

-                                                                                initSchema,

-                                                                                false,

-                                                                                traceSql);

-

-        log.debug("PG topia configuration: " + topiaConfiguration);

-        return topiaConfiguration;

-

-    }

-

-    public static ObserveTopiaConfiguration forH2Database(File dbDirectory,

-                                                          String dbName,

-                                                          String username,

-                                                          String password,

-                                                          boolean initSchema,

-                                                          boolean traceSql) {

-

-        String dbPath = new File(dbDirectory, dbName).getPath();

-        String jdbcUrl = String.format(H2_LOCAL_URL, dbPath);

-

-        JdbcConfiguration jdbcConfiguration = JDBC_CONFIGURATION_BUILDER.forH2Database(jdbcUrl, username, password);

-

-        ObserveTopiaConfiguration topiaConfiguration = createTopiaConfiguration(jdbcConfiguration,

-                                                                                initSchema,

-                                                                                true,

-                                                                                traceSql);

-

-        log.debug("H2 topia configuration: " + topiaConfiguration);

-        return topiaConfiguration;

-

-    }

-

-    private static ObserveTopiaConfiguration createTopiaConfiguration(JdbcConfiguration jdbcConfiguration,

-                                                                      boolean initSchema,

-                                                                      boolean h2Configuration,

-                                                                      boolean traceSql) {

-

-        ObserveTopiaConfiguration topiaConfiguration = new ObserveTopiaConfiguration(jdbcConfiguration, h2Configuration, traceSql);

-        topiaConfiguration.setTopiaIdFactoryClass(ObserveTopiaIdFactory.class);

-        topiaConfiguration.setInitSchema(initSchema);

-        topiaConfiguration.setValidateSchema(false);

-        topiaConfiguration.setUseHikariForJdbcConnectionPooling(true);

-

-        log.debug("jdbcUrl: " + topiaConfiguration.getJdbcConnectionUrl());

-

-        topiaConfiguration.addDeclaredService(ObserveTopiaApplicationContext.MIGRATION_SERVICE_NAME, TopiaMigrationService.class);

-        topiaConfiguration.addDeclaredService(ObserveTopiaApplicationContext.SQL_SCRIPT_GENERATOR_BATCH_SERVICE_NAME, TopiaSqlScriptGeneratorServiceImpl.class);

-

-        return topiaConfiguration;

-

-    }

-

-}
-package fr.ird.observe.persistence;

+package fr.ird.observe.entities;

 /*-

  * #%L

  * #L%

  */

-import fr.ird.observe.entities.ObserveTopiaApplicationContext;

-import fr.ird.observe.entities.ObserveTopiaConfiguration;

-import fr.ird.observe.entities.ObserveTopiaConfigurationFactory;

 import fr.ird.observe.test.TestHelper;

 import fr.ird.observe.test.TestSupportWithConfig;

 import org.junit.Assert;

         File testBasedir = TestHelper.getTestBasedir(getClass());

-        ObserveTopiaConfiguration observeTopiaConfiguration = ObserveTopiaConfigurationFactory.forH2Database(testBasedir, "testReplicateModel", "sa", "sa", true, false);

+        ObserveTopiaConfiguration observeTopiaConfiguration = ObserveTopiaConfigurationFactory.forH2Database(testBasedir, "testReplicateModel", "sa", "sa", testBasedir.toPath().resolve("temporary"), true, false);

         try (ObserveTopiaApplicationContext applicationContext = new ObserveTopiaApplicationContext(observeTopiaConfiguration)) {

             TopiaSqlTables tripLonglineTables = applicationContext.getTripLonglineTables();

             Assert.assertNotNull(tripLonglineTables);

   <parent>

     <groupId>io.ultreia.maven</groupId>

     <artifactId>pom</artifactId>

-    <version>2020.15</version>

+    <version>2020.17</version>

   </parent>

   <groupId>fr.ird.observe</groupId>

     <maven.build.timestamp.format>dd/MM/yyyy HH:mm z</maven.build.timestamp.format>

     <buildDate>${maven.build.timestamp}</buildDate>

-    <lib.version.toolkit>4.27</lib.version.toolkit>

+    <lib.version.toolkit>4.28</lib.version.toolkit>

     <lib.version.nuiton.validation>3.1</lib.version.nuiton.validation>

     <!--can't use 1.4.197 (date has changed + blob also)-->

     <lib.version.h2>1.4.196</lib.version.h2>

     <!--<lib.version.java4all.i18n>4.0-beta-3-SNAPSHOT</lib.version.java4all.i18n>-->

     <!--<lib.version.java4all.config>1.0.8-SNAPSHOT</lib.version.java4all.config>-->

     <!--<lib.version.nuiton.topia>3.4.2-SNAPSHOT</lib.version.nuiton.topia>-->

-    <!--<lib.version.java4all.topia>1.14</lib.version.java4all.topia>-->

+<!--    <lib.version.java4all.topia>1.19-SNAPSHOT</lib.version.java4all.topia>-->

     <!--<lib.version.java4all.http>1.0.17-SNAPSHOT</lib.version.java4all.http>-->

     <!-- license header configuration -->

       <version>${project.version}</version>

       <scope>provided</scope>

     </dependency>

-

+    <dependency>

+      <groupId>${project.groupId}</groupId>

+      <artifactId>services</artifactId>

+      <version>${project.version}</version>

+    </dependency>

     <dependency>

       <groupId>io.ultreia.java4all</groupId>

       <artifactId>application-context</artifactId>

 type = int

 defaultValue = 30000

+[option temporaryFilesTimeout]

+description = observe.config.temporaryFilesTimeout.description

+key = observeweb.temporaryFilesTimeout

+type = int

+defaultValue = 120

+
 ObserveWebApplicationConfig.description

+observe.config.temporaryFilesTimeout.description

 observe.model.version

 observeweb.adminApiKey.description

 observeweb.baseDirectory.description

 import fr.ird.observe.dto.ObserveUtil;

 import fr.ird.observe.dto.decoration.ReferentialLocaleConfig;

+import fr.ird.observe.services.service.CleanTemporaryFilesTaskConfiguration;

 import io.ultreia.java4all.application.context.spi.GenerateApplicationComponent;

 import io.ultreia.java4all.application.template.TemplateGeneratorConfig;

 import io.ultreia.java4all.config.ApplicationConfig;

  * @author Tony Chemit - dev@tchemit.fr

  */

 @GenerateApplicationComponent(name = "ObServe Web configuration",

-        hints = {TemplateGeneratorConfig.class, ReferentialLocaleConfig.class})

-public class ServerConfig extends GeneratedServerConfig {

+        hints = {TemplateGeneratorConfig.class, ReferentialLocaleConfig.class, CleanTemporaryFilesTaskConfiguration.class})

+public class ServerConfig extends GeneratedServerConfig implements CleanTemporaryFilesTaskConfiguration {

     private static Logger log = LogManager.getLogger(ServerConfig.class);

 import fr.ird.observe.server.configuration.user.impl.ObserveWebUsersImmutable;

 import fr.ird.observe.server.security.ObserveWebSecurityApplicationContext;

 import fr.ird.observe.server.security.ObserveWebSecurityApplicationContextApplicationComponent;

+import fr.ird.observe.services.service.CleanTemporaryFilesTask;

 import fr.ird.observe.services.ObserveServiceFactory;

 import fr.ird.observe.services.ObserveServiceInitializer;

 import fr.ird.observe.services.ObserveServiceMainFactoryApplicationComponent;

 import fr.ird.observe.services.service.actions.consolidate.dcp.FloatingObjectModification;

 import io.ultreia.java4all.application.context.ApplicationComponent;

 import io.ultreia.java4all.application.context.ApplicationContext;

+import org.apache.logging.log4j.LogManager;

+import org.apache.logging.log4j.Logger;

 import org.debux.webmotion.server.call.HttpContext;

 import org.nuiton.version.Version;

 import javax.servlet.ServletContext;

 import java.util.Map;

+import java.util.Timer;

 /**

  * @author Tony Chemit - dev@tchemit.fr

     private static final String MISSING_APPLICATION_CONTEXT =

             String.format("%s not found. You probably forgot to register %s in your web.xml", ObserveWebApplicationContext.class.getSimpleName(), ObserveWebApplicationListener.class.getName());

+    private static final Logger log = LogManager.getLogger(ObserveWebApplicationContext.class);

+

     private ObserveDtoGsonSupplier gsonSupplier;

     private ServerConfig applicationConfiguration;

     private ObserveServiceFactory mainServiceFactory;

     private ObserveWebSecurityApplicationContext securityApplicationContext;

     private static ServerConfig applicationConfiguration1;

+    private Timer deleteTemporaryFilesTimer;

     static ObserveWebApplicationContext getApplicationContext(HttpContext context) {

                 }

             };

         }

+        if (deleteTemporaryFilesTimer != null) {

+            closeDeleteTemporaryFilesTimer();

+        }

+        deleteTemporaryFilesTimer = CleanTemporaryFilesTask.create(getApplicationConfiguration());

+    }

+

+    @Override

+    public void close() {

+

+        closeDeleteTemporaryFilesTimer();

+        super.close();

     }

-//    @Override

-//    public void close() {

-//

-//        // Supprimer le cache des sessions

-//        securityApplicationContext.close();

-//

-//        // Fermer l'usine de services

-//        mainServiceFactory.close();

-//

-//    }

+    void closeDeleteTemporaryFilesTimer() {

+        try {

+            deleteTemporaryFilesTimer.cancel();

+        } catch (Exception e) {

+            log.error("Could not terminates delete temporary files timer...", e);

+        }

+    }

     public ObserveDtoGsonSupplier getGsonSupplier() {

         return gsonSupplier;

 import fr.ird.observe.dto.db.ObserveDbUserDto;

 import fr.ird.observe.entities.Entities;

 import fr.ird.observe.entities.ObserveTopiaApplicationContext;

+import fr.ird.observe.entities.ObserveTopiaConfiguration;

 import org.apache.commons.lang3.tuple.Pair;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 import org.nuiton.topia.migration.mappings.TMSVersionHibernateDao;

 import org.nuiton.topia.persistence.TopiaEntityEnum;

 import org.nuiton.topia.persistence.TopiaException;

-import org.nuiton.topia.persistence.jdbc.JdbcConfiguration;

 import org.nuiton.topia.persistence.jdbc.JdbcPostgresHelper;

 import org.nuiton.topia.persistence.script.SqlScriptConsumer;

 import org.nuiton.topia.persistence.script.SqlScriptWriter;

     private static final String SCHEMA_PUBLIC = "public";

     private static final Logger log = LogManager.getLogger(ObserveSecurityHelper.class);

     private final JdbcPostgresHelper jdbcHelper;

+    private final Path temporaryDirectory;

-    public ObserveSecurityHelper(JdbcConfiguration jdbcConfiguration) {

+    public ObserveSecurityHelper(ObserveTopiaConfiguration jdbcConfiguration) {

         this.jdbcHelper = new JdbcPostgresHelper(jdbcConfiguration);

+        this.temporaryDirectory = jdbcConfiguration.getTemporaryDirectory();

     }

     public void applySecurity(Set<ObserveDbUserDto> users) {

         }

         Path scriptPath;

         try {

-            scriptPath = Files.createTempFile("topia-sql-script-", ".sql");

+            scriptPath = Files.createTempFile(temporaryDirectory, "topia-sql-script-", ".sql");

         } catch (IOException e) {

             throw new IllegalStateException("Can't create temporary path", e);

         }

                 configuration.getJdbcUrl(),

                 configuration.getUsername(),

                 String.valueOf(configuration.getPassword()),

+                configuration.getTemporaryDirectory(),

                 initSchema,

                 configuration.isTraceSql()

         );

                 configuration.getDbName(),

                 configuration.getUsername(),

                 String.valueOf(configuration.getPassword()),

+                configuration.getTemporaryDirectory(),

                 initSchema,

                 configuration.isTraceSql()

         );

 import java.io.File;

 import java.io.IOException;

 import java.nio.file.Files;

+import java.nio.file.Path;

 import java.util.LinkedHashSet;

 import java.util.Optional;

 import java.util.Set;

     public ObserveDataSourceInformation checkCanConnectOrBeEmpty(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException {

         ObserveDataSourceConfigurationTopiaSupport dataSourceConfigurationTopiaSupport = (ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration;

+        Path temporaryDirectory = serviceContext.getTemporaryDirectoryRoot().toPath();

         ObserveDataSourceInformation dataSourceInformation;

         if (dataSourceConfigurationTopiaSupport.isH2Database()) {

                                                                                                           h2DataSourceConfiguration.getDbName(),

                                                                                                           h2DataSourceConfiguration.getUsername(),

                                                                                                           new String(h2DataSourceConfiguration.getPassword()),

-                                                                                                          false,

+                                                                                                          temporaryDirectory, false,

                                                                                                           false);

             ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forPostgresqlDatabase(pgDataSourceConfiguration.getJdbcUrl(),

                                                                                                                   pgDataSourceConfiguration.getUsername(),

                                                                                                                   new String(pgDataSourceConfiguration.getPassword()),

-                                                                                                                  false,

+                                                                                                                  temporaryDirectory, false,

                                                                                                                   false);

             try {

     @Override

     public ObserveDataSourceInformation checkCanConnect(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException {

+        Path temporaryDirectory = getTemporaryDirectory(dataSourceConfiguration);

         ObserveDataSourceConfigurationTopiaSupport dataSourceConfigurationTopiaSupport = (ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration;

         ObserveDataSourceInformation dataSourceInformation;

                                                                                                           h2DataSourceConfiguration.getDbName(),

                                                                                                           h2DataSourceConfiguration.getUsername(),

                                                                                                           new String(h2DataSourceConfiguration.getPassword()),

+                                                                                                          temporaryDirectory,

                                                                                                           false,

                                                                                                           false);

             ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forPostgresqlDatabase(pgDataSourceConfiguration.getJdbcUrl(),

                                                                                                                   pgDataSourceConfiguration.getUsername(),

                                                                                                                   new String(pgDataSourceConfiguration.getPassword()),

+                                                                                                                  temporaryDirectory,

                                                                                                                   false,

                                                                                                                   false);

     }

+    Path getTemporaryDirectory(ObserveDataSourceConfiguration dataSourceConfiguration) {

+        Path temporaryDirectory = dataSourceConfiguration.getTemporaryDirectory();

+        if (temporaryDirectory == null) {

+            temporaryDirectory = serviceContext.getTemporaryDirectoryRoot().toPath();

+            dataSourceConfiguration.setTemporaryDirectory(temporaryDirectory);

+        }

+        return temporaryDirectory;

+    }

+

     @Override

     public ObserveDataSourceConnectionTopia create(ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration)

             throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,

             BabModelVersionException, DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {

         dataSourceCreateConfiguration.validateConfiguration();

-

+        Path temporaryDirectory = getTemporaryDirectory(dataSourceConfiguration);

         boolean initSchema = !dataSourceCreateConfiguration.isImportDatabase();

         ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.createTopiaApplicationContext((ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration, initSchema);

             } else { // base postgres

                 // on realise les import dans un base H2 temporaire

-                // FIXME il faut obtenir le repertoit temporaire d'observe plutot que celui du système

                 File tmpDir;

                 try {

-                    tmpDir = Files.createTempDirectory("obstuna").toFile();

+                    tmpDir = Files.createTempDirectory(temporaryDirectory, "obstuna").toFile();

                 } catch (IOException e) {

                     throw new IllegalStateException("could not create temporary directory ", e);

                 }

     @Override

     public ObserveDataSourceConnectionTopia open(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {

-

+        Path temporaryDirectory = getTemporaryDirectory(dataSourceConfiguration);

+        log.debug("Will use temporary directory: " + temporaryDirectory);

         ObserveDataSourceInformation dataSourceInformation = checkCanConnect(dataSourceConfiguration);

         Version dbVersion = dataSourceInformation.getVersion();

     @Override

     public void applySecurity(ObserveDataSourceConfiguration dataSourceConfiguration, ImmutableSet<ObserveDbUserDto> users) {

+        Path temporaryDirectory = getTemporaryDirectory(dataSourceConfiguration);

+        log.debug("Will use temporary directory: " + temporaryDirectory);

+

         // pas de securité  pour les bases autres que postgresql

         if (dataSourceConfiguration instanceof ObserveDataSourceConfigurationTopiaPG) {

     @Override

     public void migrateData(ObserveDataSourceConfiguration dataSourceConfiguration) {

+        Path temporaryDirectory = getTemporaryDirectory(dataSourceConfiguration);

+        log.debug("Will use temporary directory: " + temporaryDirectory);

+

         ObserveTopiaApplicationContext topiaApplicationContext = ObserveTopiaApplicationContextFactory.getOrCreateTopiaApplicationContext((ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration);

         topiaApplicationContext.getMigrationService().runSchemaMigration();

     }

     public ObserveDataSourceConfigurationTopiaH2 createDataSourceConfiguration(Version dbVersion, String dbName, File targetPath, String login, char[] password) throws DataSourceCreateWithNoReferentialImportException, IOException, IncompatibleDataSourceCreateConfigurationException, DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException {

         ObserveDataSourceConfigurationTopiaH2 sharedDatabaseConfiguration = dataSourcesForTestManager.createSharedDataSourceConfigurationH2(dbVersion, dbName, login, password);

-

         File sharedDatabaseFile = sharedDatabaseConfiguration.getDatabaseFile();

         ObserveDataSourceConfigurationTopiaH2 dataSourceConfiguration;

             if (log.isInfoEnabled()) {

                 log.info("Create shared database: " + dbVersion.toString() + "/" + dbName + " to " + sharedDatabaseFile);

             }

+            sharedDatabaseConfiguration.setTemporaryDirectory(getTemporaryDirectoryRoot());

             try (DataSourceService dataSourceService = newService(sharedDatabaseConfiguration, DataSourceService.class)) {

                 DataSourceCreateConfigurationDto createConfiguration = new DataSourceCreateConfigurationDto();

         }

         dataSourceConfiguration.setModelVersion(ObserveTestConfiguration.getModelVersion());

+        dataSourceConfiguration.setTemporaryDirectory(getTemporaryDirectoryRoot());

         return dataSourceConfiguration;

     }

     public <S extends ObserveService> S newService(ObserveDataSourceConfiguration dataSourceConfiguration, Class<S> serviceType) {

+        dataSourceConfiguration.setTemporaryDirectory(getTemporaryDirectoryRoot());

         ObserveServiceInitializer observeServiceInitializer = ObserveServiceInitializer.create(

                 Locale.FRANCE,

                 ReferentialLocale.FR,

+package fr.ird.observe.services.service;

+

+/*-

+ * #%L

+ * ObServe :: Services API

+ * %%

+ * Copyright (C) 2008 - 2020 IRD, Code Lutin, Ultreia.io

+ * %%

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public

+ * License along with this program.  If not, see

+ * <http://www.gnu.org/licenses/gpl-3.0.html>.

+ * #L%

+ */

+

+import io.ultreia.java4all.util.Dates;

+import org.apache.logging.log4j.LogManager;

+import org.apache.logging.log4j.Logger;

+

+import java.io.IOException;

+import java.nio.file.DirectoryStream;

+import java.nio.file.Files;

+import java.nio.file.Path;

+import java.util.Calendar;

+import java.util.Date;

+import java.util.Objects;

+import java.util.Timer;

+import java.util.TimerTask;

+import java.util.concurrent.TimeUnit;

+

+/**

+ * To clean temporaries files.

+ *

+ * @author Tony Chemit - dev@tchemit.fr

+ * @since 8.0

+ */

+

+public class CleanTemporaryFilesTask extends TimerTask {

+

+    private static final Logger log = LogManager.getLogger(CleanTemporaryFilesTask.class);

+

+    private final CleanTemporaryFilesTaskConfiguration configuration;

+

+    public static Timer create(CleanTemporaryFilesTaskConfiguration configuration) {

+        Timer result = new Timer("Delete temporary files daemon", true);

+        result.scheduleAtFixedRate(new CleanTemporaryFilesTask(configuration), new Date(), TimeUnit.HOURS.toMillis(1));

+        return result;

+    }

+

+    public CleanTemporaryFilesTask(CleanTemporaryFilesTaskConfiguration configuration) {

+        this.configuration = configuration;

+    }

+

+    @Override

+    public void run() {

+

+        Path temporaryDirectory = configuration.getTemporaryDirectory().toPath();

+        Calendar calendar = Calendar.getInstance();

+        calendar.setTime(new Date());

+        calendar.add(Calendar.HOUR_OF_DAY, -configuration.getTemporaryFilesTimeout());

+        Date deleteBefore = calendar.getTime();

+        long deleteBeforeTime = deleteBefore.getTime();

+

+        log.info(String.format("Delete temporary files in directory %s before %s", temporaryDirectory, deleteBefore));

+        delete(temporaryDirectory, deleteBeforeTime);

+    }

+

+    private boolean delete(Path path, long deleteBeforeTime) {

+        try {

+            Files.walk(path).forEach(p -> {

+                if (Objects.equals(path, p)) {

+                    return;

+                }

+                if (Files.isDirectory(p)) {

+                    boolean deleted = delete(p, deleteBeforeTime);

+                    if (deleted) {

+                        delete0(p, deleteBeforeTime);

+                    }

+                }

+                if (Files.isRegularFile(p)) {

+                    delete0(p, deleteBeforeTime);

+                }

+            });

+            if (Files.isRegularFile(path)) {

+                return Files.notExists(path);

+            }

+            if (Files.isDirectory(path)) {

+                return isDirEmpty(path);

+            }

+            return false;

+        } catch (IOException e) {

+            throw new RuntimeException(String.format("Could not walk through temporary directory: %s", path), e);

+        }

+    }

+

+    private static boolean isDirEmpty(final Path directory) throws IOException {

+        try(DirectoryStream<Path> dirStream = Files.newDirectoryStream(directory)) {

+            return !dirStream.iterator().hasNext();

+        }

+    }

+    private void delete0(Path p, long deleteBeforeTime) {

+        try {

+            if (Files.getLastModifiedTime(p).toMillis() < deleteBeforeTime) {

+                log.info("Delete temporary file: " + p);

+                Files.delete(p);

+            }

+        } catch (IOException e) {

+            log.error("Something wrong while process file: " + p, e);

+        }

+    }

+}
-package fr.ird.observe.entities;

+package fr.ird.observe.services.service;

-/*

+/*-

  * #%L

- * ObServe :: Persistence

+ * ObServe :: Services API

  * %%

  * Copyright (C) 2008 - 2020 IRD, Code Lutin, Ultreia.io

  * %%

  * #L%

  */

+import java.io.File;

+

 /**

- * Created on 21/08/15.

- *

  * @author Tony Chemit - dev@tchemit.fr

+ * @since 8.0

  */

-public class ObserveTopiaIdFactory extends ObserveTopiaIdFactorySupport {

+public interface CleanTemporaryFilesTaskConfiguration {

+

+    File getTemporaryDirectory();

-    private static final long serialVersionUID = 1L;

+    void setTemporaryDirectory(File temporaryDirectory);

-    public ObserveTopiaIdFactory() {

-        super("fr.ird.observe.entities.");

-    }

+    int getTemporaryFilesTimeout();

+    void setTemporaryFilesTimeout(int temporaryFilesTimeout);

 }

Tony CHEMIT pushed to branch develop at ultreiaio / ird-observe

Commits:

26 changed files:

Changes: