diff --git a/src/tap/config/ConfigurableTAPFactory.java b/src/tap/config/ConfigurableTAPFactory.java
index 84cf99e1b7b08666bc51411046991e3ad5ac497a..4108fda1ec1acb625aa13b01d077a111c3203005 100644
--- a/src/tap/config/ConfigurableTAPFactory.java
+++ b/src/tap/config/ConfigurableTAPFactory.java
@@ -33,6 +33,7 @@ import static tap.config.TAPConfiguration.KEY_SQL_TRANSLATOR;
import static tap.config.TAPConfiguration.VALUE_JDBC;
import static tap.config.TAPConfiguration.VALUE_JDBC_DRIVERS;
import static tap.config.TAPConfiguration.VALUE_JNDI;
+import static tap.config.TAPConfiguration.VALUE_NEVER;
import static tap.config.TAPConfiguration.VALUE_PGSPHERE;
import static tap.config.TAPConfiguration.VALUE_POSTGRESQL;
import static tap.config.TAPConfiguration.VALUE_USER_ACTION;
@@ -66,7 +67,7 @@ import adql.translator.PostgreSQLTranslator;
*
*
* @author Grégory Mantelet (ARI)
- * @version 2.0 (03/2015)
+ * @version 2.0 (04/2015)
*/
public final class ConfigurableTAPFactory extends AbstractTAPFactory {
@@ -182,24 +183,23 @@ public final class ConfigurableTAPFactory extends AbstractTAPFactory {
/* 5. Set the UWS Backup Parameter */
// Set the backup frequency:
String propValue = getProperty(tapConfig, KEY_BACKUP_FREQUENCY);
- boolean isTime = false;
// determine whether the value is a time period ; if yes, set the frequency:
if (propValue != null){
try{
backupFrequency = Long.parseLong(propValue);
- if (backupFrequency > 0)
- isTime = true;
+ if (backupFrequency <= 0)
+ backupFrequency = DEFAULT_BACKUP_FREQUENCY;
}catch(NumberFormatException nfe){
- throw new TAPException("Long expected for the property \"" + KEY_BACKUP_FREQUENCY + "\", instead of: \"" + propValue + "\"!");
+ // if the value was not a valid numeric time period, try to identify the different textual options:
+ if (propValue.equalsIgnoreCase(VALUE_NEVER))
+ backupFrequency = DefaultTAPBackupManager.MANUAL;
+ else if (propValue.equalsIgnoreCase(VALUE_USER_ACTION))
+ backupFrequency = DefaultTAPBackupManager.AT_USER_ACTION;
+ else
+ throw new TAPException("Long expected for the property \"" + KEY_BACKUP_FREQUENCY + "\", instead of: \"" + propValue + "\"!");
}
- }
- // if the value was not a valid numeric time period, try to identify the different textual options:
- if (!isTime){
- if (propValue != null && propValue.equalsIgnoreCase(VALUE_USER_ACTION))
- backupFrequency = DefaultTAPBackupManager.AT_USER_ACTION;
- else
- backupFrequency = DEFAULT_BACKUP_FREQUENCY;
- }
+ }else
+ backupFrequency = DEFAULT_BACKUP_FREQUENCY;
// Specify whether the backup must be organized by user or not:
propValue = getProperty(tapConfig, KEY_BACKUP_BY_USER);
backupByUser = (propValue == null) ? DEFAULT_BACKUP_BY_USER : Boolean.parseBoolean(propValue);
diff --git a/src/tap/config/TAPConfiguration.java b/src/tap/config/TAPConfiguration.java
index b9a91b277e20df8c84e3e4a64468d2e45709ef6d..2701519a1525853c636c1acc01b17258c9c1766c 100644
--- a/src/tap/config/TAPConfiguration.java
+++ b/src/tap/config/TAPConfiguration.java
@@ -1,5 +1,24 @@
package tap.config;
+/*
+ * This file is part of TAPLibrary.
+ *
+ * TAPLibrary is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * TAPLibrary 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with TAPLibrary. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2015 - Astronomisches Rechen Institut (ARI)
+ */
+
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
@@ -9,33 +28,80 @@ import tap.ServiceConnection.LimitUnit;
import tap.TAPException;
import tap.backup.DefaultTAPBackupManager;
+/**
+ * <p>Utility class gathering tool functions and properties' names useful to deal with a TAP configuration file.</p>
+ *
+ * <p><i>This class implements the Design Pattern "Utility": no instance of this class can be created, it can not be extended,
+ * and it must be used only thanks to its static classes and attributes.</i></p>
+ *
+ * @author Grégory Mantelet (ARI)
+ * @version 2.0 (04/2015)
+ * @since 2.0
+ */
public final class TAPConfiguration {
+ /** Name of the initial parameter to set in the WEB-INF/web.xml file
+ * in order to specify the location and the name of the TAP configuration file to load. */
public final static String TAP_CONF_PARAMETER = "tapconf";
+ /** Default TAP configuration file. This file is research automatically
+ * if none is specified in the WEB-INF/web.xml initial parameter {@value #TAP_CONF_PARAMETER}. */
public final static String DEFAULT_TAP_CONF_FILE = "tap.properties";
/* FILE MANAGER KEYS */
+ /** Name/Key of the property setting the file manager to use in the TAP service. */
public final static String KEY_FILE_MANAGER = "file_manager";
+ /** Value of the property {@link #KEY_FILE_MANAGER} specifying a local file manager. */
public final static String VALUE_LOCAL = "local";
+ /** Default value of the property {@link #KEY_FILE_MANAGER}: {@value #DEFAULT_FILE_MANAGER}. */
public final static String DEFAULT_FILE_MANAGER = VALUE_LOCAL;
+ /** Name/Key of the property setting the local root directory where all TAP files must be stored.
+ * <em>This property is used only if {@link #KEY_FILE_MANAGER} is set to {@link #VALUE_LOCAL}.</em> */
public final static String KEY_FILE_ROOT_PATH = "file_root_path";
+ /** Name/Key of the property indicating whether the jobs must be saved by user or not.
+ * If yes, there will be one directory per user. Otherwise, all jobs are backuped in the same directory
+ * (generally {@link #KEY_FILE_ROOT_PATH}). */
public final static String KEY_DIRECTORY_PER_USER = "directory_per_user";
+ /** Default value of the property {@link #KEY_DIRECTORY_PER_USER}: {@value #DEFAULT_DIRECTORY_PER_USER}. */
public final static boolean DEFAULT_DIRECTORY_PER_USER = false;
+ /** Name/Key of the property indicating whether the user directories (in which jobs of the user are backuped)
+ * must be gathered in less directories. If yes, the groups are generally made using the alphabetic order.
+ * The idea is to reduce the number of apparent directories and to easier the research of a user directory. */
public final static String KEY_GROUP_USER_DIRECTORIES = "group_user_directories";
+ /** Default value of the property {@link #KEY_GROUP_USER_DIRECTORIES}: {@value #DEFAULT_GROUP_USER_DIRECTORIES}. */
public final static boolean DEFAULT_GROUP_USER_DIRECTORIES = false;
+ /** Name/Key of the property specifying the default period (in seconds) while a job must remain on the server.
+ * This value is set automatically to any job whose the retention period has never been specified by the user. */
public final static String KEY_DEFAULT_RETENTION_PERIOD = "default_retention_period";
+ /** Name/Key of the property specifying the maximum period (in seconds) while a job can remain on the server. */
public final static String KEY_MAX_RETENTION_PERIOD = "max_retention_period";
+ /** Default value of the properties {@link #KEY_DEFAULT_RETENTION_PERIOD} and {@link #KEY_MAX_RETENTION_PERIOD}:
+ * {@value #DEFAULT_RETENTION_PERIOD}. */
public final static int DEFAULT_RETENTION_PERIOD = 0;
/* LOG KEYS */
+ /** Name/Key of the property specifying the minimum type of messages (i.e. DEBUG, INFO, WARNING, ERROR, FATAL)
+ * that must be logged. By default all messages are logged...which is equivalent to set this property to "DEBUG". */
public final static String KEY_MIN_LOG_LEVEL = "min_log_level";
+ /** Name/Key of the property specifying the frequency of the log file rotation.
+ * By default the log rotation occurs every day at midnight. */
public final static String KEY_LOG_ROTATION = "log_rotation";
/* UWS BACKUP */
+ /** Name/Key of the property specifying the frequency (in milliseconds) of jobs backup.
+ * This property accepts three types of value: "never" (default), "user_action" (the backup of a job is done when
+ * it is modified), or a numeric positive value (expressed in milliseconds). */
public final static String KEY_BACKUP_FREQUENCY = "backup_frequency";
+ /** Value of the property {@link #KEY_BACKUP_FREQUENCY} indicating that jobs should never be backuped. */
+ public final static String VALUE_NEVER = "never";
+ /** Value of the property {@link #KEY_BACKUP_FREQUENCY} indicating that job backup should occur only when the user
+ * creates or modifies one of his jobs. This value can be used ONLY IF {@link #KEY_BACKUP_BY_USER} is "true". */
public final static String VALUE_USER_ACTION = "user_action";
+ /** Default value of the property {@link #KEY_BACKUP_FREQUENCY}: {@link #DEFAULT_BACKUP_FREQUENCY}. */
public final static long DEFAULT_BACKUP_FREQUENCY = DefaultTAPBackupManager.MANUAL; // = "never" => no UWS backup manager
+ /** Name/Key of the property indicating whether there should be one backup file per user or one file for all. */
public final static String KEY_BACKUP_BY_USER = "backup_by_user";
+ /** Default value of the property {@link #KEY_BACKUP_BY_USER}: {@value #DEFAULT_BACKUP_BY_USER}.
+ * This property can be enabled only if a user identification method is provided. */
public final static boolean DEFAULT_BACKUP_BY_USER = false;
/* ASYNCHRONOUS JOBS */
@@ -123,6 +189,9 @@ public final class TAPConfiguration {
/* CUSTOM FACTORY */
public final static String KEY_TAP_FACTORY = "tap_factory";
+ /** No instance of this class should be created. */
+ private TAPConfiguration(){}
+
/**
* <p>Read the asked property from the given Properties object.</p>
* <ul>
diff --git a/src/tap/config/tap_configuration_file.html b/src/tap/config/tap_configuration_file.html
index 57c6967ed2a63b000697a45b682867db7f7a5251..0bebdc978d0b190839d13f9c9b1ae186a4c58cae 100644
--- a/src/tap/config/tap_configuration_file.html
+++ b/src/tap/config/tap_configuration_file.html
@@ -419,21 +419,22 @@
<td>text or integer</td>
<td>
<p>Frequency at which the UWS service (that's to say, all its users and jobs) must be backuped.</p>
- <p>Allowed values are: never (no backup will never be done), user_action (each time a user does a writing action, like creating or execution a job), a time (must be positive and not null) in milliseconds.</p>
+ <p>Allowed values are: <code>never</code> (no backup will never be done), <code>user_action</code> (each time a user does a writing action, like creating or execution a job), a time (must be positive and not null) in milliseconds.</p>
+ <p><em>The value <code>user_action</code> can be used ONLY IF <code>backup_mode=true</code>.</em></p>
<p><em>Default: <code>backup_frequency=never</code> (no backup)</em></p>
</td>
<td><ul><li>never <em>(default)</em></li><li>user_action</li><li>3600000 <em>(1 hour)</em></li></ul></td>
</tr>
<tr class="optional">
- <td class="done">backup_mode</td>
+ <td class="done">backup_by_user</td>
<td></td>
<td>text</td>
<td>
- <p>Tells whether the backup must be one file for every user, or one file for each user. This second option should be chosen if your TAP Service is organizing its files by user directories ; see the property <em>directory_per_user</em>.</p>
- <p>Allowed values are: user (one backup file for each user), whole (one file for all users ; may generates a big file).</p>
- <p><em>Default: <code>whole</code></em></p>
+ <p>Tells whether the backup must be one file for every user (<code>false</code>), or one file for each user (<code>true</code>). This second option should be chosen if your TAP Service is organizing its files by user directories ; see the property <em>directory_per_user</em>.</p>
+ <p>This option can be enabled ONLY IF a user identification method is provided ; see property <code>user_identifier</code>.</p>
+ <p><em>Default: <code>false</code></em></p>
</td>
- <td><ul><li>whole <em>(default)</em></li><li>user</li></ul></td>
+ <td><ul><li>false <em>(default)</em></li><li>true</li></ul></td>
</tr>
<tr><td colspan="5">Asynchronous jobs management</td></tr>
diff --git a/src/tap/config/tap_full.properties b/src/tap/config/tap_full.properties
index 42d614460d592c4cc0bea9187256f2d8558abc0b..b223d59420f1927188439eadc2b48ee90ca23340 100644
--- a/src/tap/config/tap_full.properties
+++ b/src/tap/config/tap_full.properties
@@ -2,7 +2,7 @@
# FULL TAP CONFIGURATION FILE #
# #
# TAP Version: 2.0 #
-# Date: 9 April 2015 #
+# Date: 13 April 2015 #
# Author: Gregory Mantelet (ARI) #
# #
##########################################################
@@ -268,15 +268,21 @@ log_rotation =
#
# Allowed values: never (no backup will never be done ; default), user_action (each time a user does a writing action, like creating or execution a job),
# a time (must be positive and not null) in milliseconds.
+#
+# The value user_action can be used ONLY IF backup_mode=true.
+#
+# Default: never
backup_frequency = never
# [OPTIONAL]
-# Tells whether the backup must be one file for every user, or one file for each user.
+# Tells whether the backup must be one file for every user (false), or one file for each user (true).
+# This second option should be chosen if your TAP Service is organizing its files by user directories ;
+# see the property directory_per_user.
#
-# This second option should be chosen if your TAP Service is organizing its files by user directories ; see the property directory_per_user.
+# This option can be enabled ONLY IF a user identification method is provided ; see property user_identifier.
#
-# Allowed values: user (one backup file for each user ; default), whole (one file for all users ; may generates a big file).
-backup_mode = user
+# Default: false
+backup_by_user = false
#####################
# ASYNCHRONOUS JOBS #
diff --git a/test/tap/config/TestConfigurableTAPFactory.java b/test/tap/config/TestConfigurableTAPFactory.java
index 87407bd8970edd106b0e7573316ff6fdf5fa0f8e..c6bf1006c15def6481952a1cd627f37aef3e2890 100644
--- a/test/tap/config/TestConfigurableTAPFactory.java
+++ b/test/tap/config/TestConfigurableTAPFactory.java
@@ -5,6 +5,8 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static tap.config.TAPConfiguration.KEY_BACKUP_BY_USER;
+import static tap.config.TAPConfiguration.KEY_BACKUP_FREQUENCY;
import static tap.config.TAPConfiguration.KEY_DATABASE_ACCESS;
import static tap.config.TAPConfiguration.KEY_DATASOURCE_JNDI_NAME;
import static tap.config.TAPConfiguration.KEY_DB_PASSWORD;
@@ -21,11 +23,13 @@ import java.io.File;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Iterator;
+import java.util.Map;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
+import javax.servlet.http.HttpServletRequest;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -35,6 +39,7 @@ import org.postgresql.util.PSQLException;
import tap.ServiceConnection;
import tap.TAPException;
import tap.TAPFactory;
+import tap.backup.DefaultTAPBackupManager;
import tap.db.DBConnection;
import tap.db.DBException;
import tap.db.JDBCConnection;
@@ -42,7 +47,10 @@ import tap.formatter.OutputFormat;
import tap.log.DefaultTAPLog;
import tap.log.TAPLog;
import tap.metadata.TAPMetadata;
+import uws.UWSException;
+import uws.job.user.JobOwner;
import uws.service.UWSService;
+import uws.service.UWSUrl;
import uws.service.UserIdentifier;
import uws.service.file.LocalUWSFileManager;
import uws.service.file.UWSFileManager;
@@ -55,7 +63,8 @@ public class TestConfigurableTAPFactory {
missingDatasourceJNDINameProp, wrongDatasourceJNDINameProp,
noJdbcProp1, noJdbcProp2, noJdbcProp3, badJdbcProp,
missingTranslatorProp, badTranslatorProp, badDBNameProp,
- badUsernameProp, badPasswordProp;
+ badUsernameProp, badPasswordProp, validBackupFrequency, noBackup,
+ userBackup, badBackupFrequency;
private static ServiceConnection serviceConnection = null;
@@ -133,6 +142,18 @@ public class TestConfigurableTAPFactory {
badPasswordProp = (Properties)validJDBCProp.clone();
badPasswordProp.setProperty(KEY_DB_PASSWORD, "foo");
+
+ validBackupFrequency = (Properties)validJDBCProp.clone();
+ validBackupFrequency.setProperty(KEY_BACKUP_FREQUENCY, "3600");
+
+ noBackup = (Properties)validJDBCProp.clone();
+ noBackup.setProperty(KEY_BACKUP_FREQUENCY, "never");
+
+ userBackup = (Properties)validJDBCProp.clone();
+ userBackup.setProperty(KEY_BACKUP_FREQUENCY, "user_action");
+
+ badBackupFrequency = (Properties)validJDBCProp.clone();
+ badBackupFrequency.setProperty(KEY_BACKUP_FREQUENCY, "foo");
}
@Test
@@ -291,6 +312,66 @@ public class TestConfigurableTAPFactory {
assertEquals(PSQLException.class, ex.getCause().getClass());
assertTrue(ex.getCause().getMessage().matches("FATAL: password authentication failed for user \"[^\\\"]*\""));
}
+
+ // Valid backup frequency:
+ try{
+ ConfigurableTAPFactory factory = new ConfigurableTAPFactory(serviceConnection, validBackupFrequency);
+ DefaultTAPBackupManager backupManager = (DefaultTAPBackupManager)factory.createUWSBackupManager(new UWSService(factory, new LocalUWSFileManager(new File("/tmp"))));
+ assertEquals(3600L, backupManager.getBackupFreq());
+ }catch(Exception ex){
+ fail(getPertinentMessage(ex));
+ }
+
+ // No backup:
+ try{
+ ConfigurableTAPFactory factory = new ConfigurableTAPFactory(serviceConnection, noBackup);
+ assertNull(factory.createUWSBackupManager(new UWSService(factory, new LocalUWSFileManager(new File("/tmp")))));
+ }catch(Exception ex){
+ fail(getPertinentMessage(ex));
+ }
+
+ // User backup:
+ try{
+ UWSService uws;
+ UserIdentifier userIdent = new UserIdentifier(){
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ public JobOwner restoreUser(String id, String pseudo, Map<String,Object> otherData) throws UWSException{
+ return null;
+ }
+
+ @Override
+ public JobOwner extractUserId(UWSUrl urlInterpreter, HttpServletRequest request) throws UWSException{
+ return null;
+ }
+ };
+ /* The value user_action has no effect if the by_user mode is not enabled.
+ * So, if this value is given, it's falling back to manual.*/
+ userBackup.setProperty(KEY_BACKUP_BY_USER, "false");
+ ConfigurableTAPFactory factory = new ConfigurableTAPFactory(serviceConnection, userBackup);
+ uws = new UWSService(factory, new LocalUWSFileManager(new File("/tmp")));
+ DefaultTAPBackupManager backupManager = (DefaultTAPBackupManager)factory.createUWSBackupManager(uws);
+ assertEquals(DefaultTAPBackupManager.MANUAL, backupManager.getBackupFreq());
+
+ /* After having enabled the by_user mode, it should now work. */
+ userBackup.setProperty(KEY_BACKUP_BY_USER, "true");
+ factory = new ConfigurableTAPFactory(serviceConnection, userBackup);
+ uws = new UWSService(factory, new LocalUWSFileManager(new File("/tmp")));
+ uws.setUserIdentifier(userIdent);
+ backupManager = (DefaultTAPBackupManager)factory.createUWSBackupManager(uws);
+ assertEquals(DefaultTAPBackupManager.AT_USER_ACTION, backupManager.getBackupFreq());
+ }catch(Exception ex){
+ fail(getPertinentMessage(ex));
+ }
+
+ // Bad backup frequency:
+ try{
+ new ConfigurableTAPFactory(serviceConnection, badBackupFrequency);
+ }catch(Exception ex){
+ assertEquals(TAPException.class, ex.getClass());
+ assertEquals("Long expected for the property \"" + KEY_BACKUP_FREQUENCY + "\", instead of: \"foo\"!", ex.getMessage());
+ }
}
public static final String getPertinentMessage(final Exception ex){