/*
* Copyright (c) 2010-2013 Evolveum
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.evolveum.midpoint.task.quartzimpl;
import com.evolveum.midpoint.common.configuration.api.MidpointConfiguration;
import com.evolveum.midpoint.repo.sql.SqlRepositoryConfiguration;
import com.evolveum.midpoint.task.api.TaskManagerConfigurationException;
import com.evolveum.midpoint.task.api.UseThreadInterrupt;
import com.evolveum.midpoint.util.logging.Trace;
import com.evolveum.midpoint.util.logging.TraceManager;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.lang.StringUtils;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* Task Manager configuration, derived from "taskManager" section of midPoint config,
* SQL repository configuration (if present), and some system properties.
*
* See also the description in midPoint wiki (TODO URL).
*
* On configuration failures, it throws TaskManagerConfigurationException.
*
* @author Pavol Mederly
*/
public class TaskManagerConfiguration {
private static final transient Trace LOGGER = TraceManager.getTrace(TaskManagerConfiguration.class);
private static final String TASK_MANAGER_CONFIG_SECTION = "midpoint.taskManager";
private static final String STOP_ON_INITIALIZATION_FAILURE_CONFIG_ENTRY = "stopOnInitializationFailure";
private static final String THREADS_CONFIG_ENTRY = "threads";
private static final String CLUSTERED_CONFIG_ENTRY = "clustered";
private static final String JDBC_JOB_STORE_CONFIG_ENTRY = "jdbcJobStore";
private static final String JDBC_DRIVER_CONFIG_ENTRY = "jdbcDriver";
private static final String JDBC_URL_CONFIG_ENTRY = "jdbcUrl";
private static final String JDBC_USER_CONFIG_ENTRY = "jdbcUser";
private static final String JDBC_PASSWORD_CONFIG_ENTRY = "jdbcPassword";
private static final String DATA_SOURCE_CONFIG_ENTRY = "dataSource";
private static final String SQL_SCHEMA_FILE_CONFIG_ENTRY = "sqlSchemaFile";
private static final String CREATE_QUARTZ_TABLES_CONFIG_ENTRY = "createQuartzTables";
private static final String JDBC_DRIVER_DELEGATE_CLASS_CONFIG_ENTRY = "jdbcDriverDelegateClass";
private static final String USE_THREAD_INTERRUPT_CONFIG_ENTRY = "useThreadInterrupt";
private static final String JMX_CONNECT_TIMEOUT_CONFIG_ENTRY = "jmxConnectTimeout";
private static final String QUARTZ_NODE_REGISTRATION_INTERVAL_CONFIG_ENTRY = "quartzNodeRegistrationInterval";
private static final String NODE_REGISTRATION_INTERVAL_CONFIG_ENTRY = "nodeRegistrationInterval";
private static final String NODE_TIMEOUT_CONFIG_ENTRY = "nodeTimeout";
private static final String JMX_USERNAME_CONFIG_ENTRY = "jmxUsername";
private static final String JMX_PASSWORD_CONFIG_ENTRY = "jmxPassword";
private static final String TEST_MODE_CONFIG_ENTRY = "testMode";
private static final String WAITING_TASKS_CHECK_INTERVAL_CONFIG_ENTRY = "waitingTasksCheckInterval";
private static final String STALLED_TASKS_CHECK_INTERVAL_CONFIG_ENTRY = "stalledTasksCheckInterval";
private static final String STALLED_TASKS_THRESHOLD_CONFIG_ENTRY = "stalledTasksThreshold";
private static final String STALLED_TASKS_REPEATED_NOTIFICATION_INTERVAL_CONFIG_ENTRY = "stalledTasksRepeatedNotificationInterval";
private static final String RUN_NOW_KEEPS_ORIGINAL_SCHEDULE_CONFIG_ENTRY = "runNowKeepsOriginalSchedule";
private static final String MIDPOINT_NODE_ID_PROPERTY = "midpoint.nodeId";
private static final String MIDPOINT_JMX_HOST_NAME_PROPERTY = "midpoint.jmxHostName";
private static final String JMX_PORT_PROPERTY = "com.sun.management.jmxremote.port";
private static final String SUREFIRE_PRESENCE_PROPERTY = "surefire.real.class.path";
private static final boolean STOP_ON_INITIALIZATION_FAILURE_DEFAULT = true;
private static final int THREADS_DEFAULT = 10;
private static final boolean CLUSTERED_DEFAULT = false; // do not change this value!
private static final boolean CREATE_QUARTZ_TABLES_DEFAULT = true;
private static final String NODE_ID_DEFAULT = "DefaultNode";
private static final int JMX_PORT_DEFAULT = 20001;
private static final int JMX_CONNECT_TIMEOUT_DEFAULT = 5;
private static final String USE_THREAD_INTERRUPT_DEFAULT = "whenNecessary";
private static final int QUARTZ_NODE_REGISTRATION_CYCLE_TIME_DEFAULT = 10;
private static final int NODE_REGISTRATION_CYCLE_TIME_DEFAULT = 10;
private static final int NODE_TIMEOUT_DEFAULT = 30;
private static final String JMX_USERNAME_DEFAULT = "midpoint";
private static final String JMX_PASSWORD_DEFAULT = "secret";
private static final int WAITING_TASKS_CHECK_INTERVAL_DEFAULT = 600;
private static final int STALLED_TASKS_CHECK_INTERVAL_DEFAULT = 600;
private static final int STALLED_TASKS_THRESHOLD_DEFAULT = 600; // if a task does not advance its progress for 10 minutes, it is considered stalled
private static final int STALLED_TASKS_REPEATED_NOTIFICATION_INTERVAL_DEFAULT = 3600;
private static final boolean RUN_NOW_KEEPS_ORIGINAL_SCHEDULE_DEFAULT = false;
private boolean stopOnInitializationFailure;
private int threads;
private boolean jdbcJobStore;
private boolean clustered;
private String nodeId;
private String jmxHostName;
private int jmxPort;
private int jmxConnectTimeout;
private int quartzNodeRegistrationCycleTime; // UNUSED (currently) !
private int nodeRegistrationCycleTime, nodeTimeout;
private UseThreadInterrupt useThreadInterrupt;
private int waitingTasksCheckInterval;
private int stalledTasksCheckInterval;
private int stalledTasksThreshold;
private int stalledTasksRepeatedNotificationInterval;
private boolean runNowKeepsOriginalSchedule;
// JMX credentials for connecting to remote nodes
private String jmxUsername;
private String jmxPassword;
// quartz jdbc job store specific information
private String sqlSchemaFile;
private String jdbcDriverDelegateClass;
private String jdbcDriver;
private String jdbcUrl;
private String jdbcUser;
private String jdbcPassword;
private String dataSource;
private boolean createQuartzTables;
private String hibernateDialect;
private boolean databaseIsEmbedded;
/*
* Are we in the test mode?
*
* It affects e.g. whether to allow reusing quartz scheduler after task manager shutdown.
*
* Concretely, if in test mode, quartz scheduler will not be shut down, only paused.
* This allows for restarting it (scheduler cannot be started, if it was shut down:
* http://quartz-scheduler.org/api/2.1.0/org/quartz/Scheduler.html#shutdown())
*
* If not run in test mode (i.e. within Tomcat), we do not, because pausing
* the scheduler does NOT stop the execution threads.
*
* We determine whether in test mode by examining testMode property and, if not present,
* by looking for SUREFIRE_PRESENCE_PROPERTY.
*/
private boolean midPointTestMode = false;
public static final List<String> KNOWN_KEYS = Arrays.asList(
"midpoint.home",
STOP_ON_INITIALIZATION_FAILURE_CONFIG_ENTRY,
THREADS_CONFIG_ENTRY,
CLUSTERED_CONFIG_ENTRY,
JDBC_JOB_STORE_CONFIG_ENTRY,
JDBC_DRIVER_CONFIG_ENTRY,
JDBC_URL_CONFIG_ENTRY,
JDBC_USER_CONFIG_ENTRY,
JDBC_PASSWORD_CONFIG_ENTRY,
DATA_SOURCE_CONFIG_ENTRY,
SQL_SCHEMA_FILE_CONFIG_ENTRY,
CREATE_QUARTZ_TABLES_CONFIG_ENTRY,
JDBC_DRIVER_DELEGATE_CLASS_CONFIG_ENTRY,
USE_THREAD_INTERRUPT_CONFIG_ENTRY,
JMX_CONNECT_TIMEOUT_CONFIG_ENTRY,
QUARTZ_NODE_REGISTRATION_INTERVAL_CONFIG_ENTRY,
NODE_REGISTRATION_INTERVAL_CONFIG_ENTRY,
NODE_TIMEOUT_CONFIG_ENTRY,
JMX_USERNAME_CONFIG_ENTRY,
JMX_PASSWORD_CONFIG_ENTRY,
TEST_MODE_CONFIG_ENTRY,
WAITING_TASKS_CHECK_INTERVAL_CONFIG_ENTRY,
STALLED_TASKS_CHECK_INTERVAL_CONFIG_ENTRY,
STALLED_TASKS_THRESHOLD_CONFIG_ENTRY,
STALLED_TASKS_REPEATED_NOTIFICATION_INTERVAL_CONFIG_ENTRY,
RUN_NOW_KEEPS_ORIGINAL_SCHEDULE_CONFIG_ENTRY
);
void checkAllowedKeys(MidpointConfiguration masterConfig) throws TaskManagerConfigurationException {
Configuration c = masterConfig.getConfiguration(TASK_MANAGER_CONFIG_SECTION);
checkAllowedKeys(c, KNOWN_KEYS);
}
// todo copied from WfConfiguration -- refactor
private void checkAllowedKeys(Configuration c, List<String> knownKeys) throws TaskManagerConfigurationException {
Set<String> knownKeysSet = new HashSet<String>(knownKeys);
Iterator<String> keyIterator = c.getKeys();
while (keyIterator.hasNext()) {
String keyName = keyIterator.next();
String normalizedKeyName = StringUtils.substringBefore(keyName, "."); // because of subkeys
normalizedKeyName = StringUtils.substringBefore(normalizedKeyName, "["); // because of [@xmlns:c]
int colon = normalizedKeyName.indexOf(':'); // because of c:generalChangeProcessorConfiguration
if (colon != -1) {
normalizedKeyName = normalizedKeyName.substring(colon + 1);
}
if (!knownKeysSet.contains(keyName) && !knownKeysSet.contains(normalizedKeyName)) { // ...we need to test both because of keys like 'midpoint.home'
throw new TaskManagerConfigurationException("Unknown key " + keyName + " in task manager configuration");
}
}
}
void setBasicInformation(MidpointConfiguration masterConfig) throws TaskManagerConfigurationException {
Configuration c = masterConfig.getConfiguration(TASK_MANAGER_CONFIG_SECTION);
stopOnInitializationFailure = c.getBoolean(STOP_ON_INITIALIZATION_FAILURE_CONFIG_ENTRY, STOP_ON_INITIALIZATION_FAILURE_DEFAULT);
threads = c.getInt(THREADS_CONFIG_ENTRY, THREADS_DEFAULT);
clustered = c.getBoolean(CLUSTERED_CONFIG_ENTRY, CLUSTERED_DEFAULT);
jdbcJobStore = c.getBoolean(JDBC_JOB_STORE_CONFIG_ENTRY, clustered);
nodeId = System.getProperty(MIDPOINT_NODE_ID_PROPERTY);
if (StringUtils.isEmpty(nodeId) && !clustered) {
nodeId = NODE_ID_DEFAULT;
}
jmxHostName = System.getProperty(MIDPOINT_JMX_HOST_NAME_PROPERTY);
String portString = System.getProperty(JMX_PORT_PROPERTY);
if (StringUtils.isEmpty(portString)) {
jmxPort = JMX_PORT_DEFAULT;
} else {
try {
jmxPort = Integer.parseInt(portString);
} catch(NumberFormatException nfe) {
throw new TaskManagerConfigurationException("Cannot get JMX management port - invalid integer value of " + portString, nfe);
}
}
jmxConnectTimeout = c.getInt(JMX_CONNECT_TIMEOUT_CONFIG_ENTRY, JMX_CONNECT_TIMEOUT_DEFAULT);
if (c.containsKey(TEST_MODE_CONFIG_ENTRY)) {
midPointTestMode = c.getBoolean(TEST_MODE_CONFIG_ENTRY);
LOGGER.trace(TEST_MODE_CONFIG_ENTRY + " present, its value = " + midPointTestMode);
} else {
LOGGER.trace(TEST_MODE_CONFIG_ENTRY + " NOT present");
Properties sp = System.getProperties();
if (sp.containsKey(SUREFIRE_PRESENCE_PROPERTY)) {
LOGGER.info("Determined to run in a test environment, setting midPointTestMode to 'true'.");
midPointTestMode = true;
} else {
midPointTestMode = false;
}
}
LOGGER.trace("midPointTestMode = " + midPointTestMode);
String useTI = c.getString(USE_THREAD_INTERRUPT_CONFIG_ENTRY, USE_THREAD_INTERRUPT_DEFAULT);
try {
useThreadInterrupt = UseThreadInterrupt.fromValue(useTI);
} catch(IllegalArgumentException e) {
throw new TaskManagerConfigurationException("Illegal value for " + USE_THREAD_INTERRUPT_CONFIG_ENTRY + ": " + useTI, e);
}
quartzNodeRegistrationCycleTime = c.getInt(QUARTZ_NODE_REGISTRATION_INTERVAL_CONFIG_ENTRY, QUARTZ_NODE_REGISTRATION_CYCLE_TIME_DEFAULT);
nodeRegistrationCycleTime = c.getInt(NODE_REGISTRATION_INTERVAL_CONFIG_ENTRY, NODE_REGISTRATION_CYCLE_TIME_DEFAULT);
nodeTimeout = c.getInt(NODE_TIMEOUT_CONFIG_ENTRY, NODE_TIMEOUT_DEFAULT);
jmxUsername = c.getString(JMX_USERNAME_CONFIG_ENTRY, JMX_USERNAME_DEFAULT);
jmxPassword = c.getString(JMX_PASSWORD_CONFIG_ENTRY, JMX_PASSWORD_DEFAULT);
waitingTasksCheckInterval = c.getInt(WAITING_TASKS_CHECK_INTERVAL_CONFIG_ENTRY, WAITING_TASKS_CHECK_INTERVAL_DEFAULT);
stalledTasksCheckInterval = c.getInt(STALLED_TASKS_CHECK_INTERVAL_CONFIG_ENTRY, STALLED_TASKS_CHECK_INTERVAL_DEFAULT);
stalledTasksThreshold = c.getInt(STALLED_TASKS_THRESHOLD_CONFIG_ENTRY, STALLED_TASKS_THRESHOLD_DEFAULT);
stalledTasksRepeatedNotificationInterval = c.getInt(STALLED_TASKS_REPEATED_NOTIFICATION_INTERVAL_CONFIG_ENTRY, STALLED_TASKS_REPEATED_NOTIFICATION_INTERVAL_DEFAULT);
runNowKeepsOriginalSchedule = c.getBoolean(RUN_NOW_KEEPS_ORIGINAL_SCHEDULE_CONFIG_ENTRY, RUN_NOW_KEEPS_ORIGINAL_SCHEDULE_DEFAULT);
}
private static final Map<String,String> schemas = new HashMap<String,String>();
private static final Map<String,String> delegates = new HashMap<String,String>();
static void addDbInfo(String dialect, String schema, String delegate) {
schemas.put(dialect, schema);
delegates.put(dialect, delegate);
}
static {
addDbInfo("org.hibernate.dialect.H2Dialect", "tables_h2.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.PostgreSQLDialect", "tables_postgres.sql", "org.quartz.impl.jdbcjobstore.PostgreSQLDelegate");
addDbInfo("org.hibernate.dialect.PostgresPlusDialect", "tables_postgres.sql", "org.quartz.impl.jdbcjobstore.PostgreSQLDelegate");
addDbInfo("com.evolveum.midpoint.repo.sql.util.MidPointPostgreSQLDialect", "tables_postgres.sql", "org.quartz.impl.jdbcjobstore.PostgreSQLDelegate");
addDbInfo("org.hibernate.dialect.MySQLDialect", "tables_mysql.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.MySQLInnoDBDialect", "tables_mysql_innodb.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("com.evolveum.midpoint.repo.sql.util.MidPointMySQLDialect", "tables_mysql_innodb.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.OracleDialect", "tables_oracle.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.Oracle9Dialect", "tables_oracle.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.Oracle8iDialect", "tables_oracle.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.Oracle9iDialect", "tables_oracle.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.Oracle10gDialect", "tables_oracle.sql", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
addDbInfo("org.hibernate.dialect.SQLServerDialect", "tables_sqlServer.sql", "org.quartz.impl.jdbcjobstore.MSSQLDelegate");
addDbInfo("com.evolveum.midpoint.repo.sql.util.UnicodeSQLServer2008Dialect", "tables_sqlServer.sql", "org.quartz.impl.jdbcjobstore.MSSQLDelegate");
}
void setJdbcJobStoreInformation(MidpointConfiguration masterConfig, SqlRepositoryConfiguration sqlConfig, String defaultJdbcUrlPrefix) {
Configuration c = masterConfig.getConfiguration(TASK_MANAGER_CONFIG_SECTION);
jdbcDriver = c.getString(JDBC_DRIVER_CONFIG_ENTRY, sqlConfig != null ? sqlConfig.getDriverClassName() : null);
String explicitJdbcUrl = c.getString(JDBC_URL_CONFIG_ENTRY, null);
if (explicitJdbcUrl == null) {
if (sqlConfig.isEmbedded()) {
jdbcUrl = defaultJdbcUrlPrefix + "-quartz;MVCC=TRUE;DB_CLOSE_ON_EXIT=FALSE";
} else {
jdbcUrl = sqlConfig.getJdbcUrl();
}
} else {
jdbcUrl = explicitJdbcUrl;
}
dataSource = c.getString(DATA_SOURCE_CONFIG_ENTRY, null);
if (dataSource == null && explicitJdbcUrl == null && sqlConfig != null) {
dataSource = sqlConfig.getDataSource(); // we want to use quartz-specific JDBC if there is one (i.e. we do not want to inherit data source from repo in such a case)
}
if (dataSource != null) {
LOGGER.info("Quartz database is at {} (a data source)", dataSource);
} else {
LOGGER.info("Quartz database is at {} (a JDBC URL)", jdbcUrl);
}
jdbcUser = c.getString(JDBC_USER_CONFIG_ENTRY, sqlConfig != null ? sqlConfig.getJdbcUsername() : null);
jdbcPassword = c.getString(JDBC_PASSWORD_CONFIG_ENTRY, sqlConfig != null ? sqlConfig.getJdbcPassword() : null);
hibernateDialect = sqlConfig != null ? sqlConfig.getHibernateDialect() : "";
String defaultSqlSchemaFile = schemas.get(hibernateDialect);
String defaultDriverDelegate = delegates.get(hibernateDialect);
sqlSchemaFile = c.getString(SQL_SCHEMA_FILE_CONFIG_ENTRY, defaultSqlSchemaFile);
jdbcDriverDelegateClass = c.getString(JDBC_DRIVER_DELEGATE_CLASS_CONFIG_ENTRY, defaultDriverDelegate);
createQuartzTables = c.getBoolean(CREATE_QUARTZ_TABLES_CONFIG_ENTRY, CREATE_QUARTZ_TABLES_DEFAULT);
}
/**
* Check configuration, except for JDBC JobStore-specific parts.
*
* @throws TaskManagerConfigurationException
*/
void validateBasicInformation() throws TaskManagerConfigurationException {
if (threads < 1) {
LOGGER.warn("The configured number of threads is too low, setting it to 5.");
threads = 5;
}
if (clustered) {
mustBeTrue(jdbcJobStore, "Clustered task manager requires JDBC Quartz job store.");
}
notEmpty(nodeId, "Node identifier must be set when run in clustered mode.");
mustBeFalse(clustered && jmxPort == 0, "JMX port number must be known when run in clustered mode.");
mustBeTrue(quartzNodeRegistrationCycleTime > 1 && quartzNodeRegistrationCycleTime <= 600, "Quartz node registration cycle time must be between 1 and 600 seconds");
mustBeTrue(nodeRegistrationCycleTime > 1 && nodeRegistrationCycleTime <= 600, "Node registration cycle time must be between 1 and 600 seconds");
mustBeTrue(nodeTimeout > 5 && nodeTimeout <= 3600, "Node timeout must be between 5 and 3600 seconds");
}
void validateJdbcJobStoreInformation() throws TaskManagerConfigurationException {
if (StringUtils.isEmpty(dataSource)) {
notEmpty(jdbcDriver, "JDBC driver must be specified (either explicitly or via data source; in task manager or in SQL repository configuration)");
notEmpty(jdbcUrl, "JDBC URL must be specified (either explicitly or via data source; in task manager or in SQL repository configuration)");
notNull(jdbcUser, "JDBC user name must be specified (either explicitly or via data source; in task manager or in SQL repository configuration)");
notNull(jdbcPassword, "JDBC password must be specified (either explicitly or via data source; in task manager or in SQL repository configuration)");
}
if (StringUtils.isEmpty(jdbcDriverDelegateClass)) {
throw new TaskManagerConfigurationException("JDBC driver delegate class must be specified (either explicitly or "
+ "through one of supported Hibernate dialects). It seems that the currently specified dialect ("
+ hibernateDialect + ") is not among supported dialects (" + delegates.keySet() + "). "
+ "Please check " + TaskManagerConfiguration.class.getName() + " class or specify driver delegate explicitly.");
}
notEmpty(sqlSchemaFile, "SQL schema file must be specified (either explicitly or through one of supported Hibernate dialects).");
}
private void notEmpty(String value, String message) throws TaskManagerConfigurationException {
if (StringUtils.isEmpty(value)) {
throw new TaskManagerConfigurationException(message);
}
}
private void notNull(String value, String message) throws TaskManagerConfigurationException {
if (value == null) {
throw new TaskManagerConfigurationException(message);
}
}
private void mustBeTrue(boolean condition, String message) throws TaskManagerConfigurationException {
if (!condition) {
throw new TaskManagerConfigurationException(message);
}
}
private void mustBeFalse(boolean condition, String message) throws TaskManagerConfigurationException {
if (condition) {
throw new TaskManagerConfigurationException(message);
}
}
public int getThreads() {
return threads;
}
public boolean isJdbcJobStore() {
return jdbcJobStore;
}
public boolean isClustered() {
return clustered;
}
public String getNodeId() {
return nodeId;
}
public int getJmxPort() {
return jmxPort;
}
public String getSqlSchemaFile() {
return sqlSchemaFile;
}
public String getJdbcDriverDelegateClass() {
return jdbcDriverDelegateClass;
}
public String getJdbcDriver() {
return jdbcDriver;
}
public String getJdbcUrl() {
return jdbcUrl;
}
public String getJdbcUser() {
return jdbcUser;
}
public String getJdbcPassword() {
return jdbcPassword;
}
public boolean isTestMode() {
return midPointTestMode;
}
public UseThreadInterrupt getUseThreadInterrupt() {
return useThreadInterrupt;
}
public int getJmxConnectTimeout() {
return jmxConnectTimeout;
}
public boolean isStopOnInitializationFailure() {
return stopOnInitializationFailure;
}
public boolean isDatabaseIsEmbedded() {
return databaseIsEmbedded;
}
public int getNodeTimeout() {
return nodeTimeout;
}
public int getNodeRegistrationCycleTime() {
return nodeRegistrationCycleTime;
}
public int getQuartzNodeRegistrationCycleTime() {
return quartzNodeRegistrationCycleTime;
}
public String getJmxUsername() {
return jmxUsername;
}
public String getJmxPassword() {
return jmxPassword;
}
public String getJmxHostName() {
return jmxHostName;
}
public int getWaitingTasksCheckInterval() {
return waitingTasksCheckInterval;
}
public int getStalledTasksCheckInterval() {
return stalledTasksCheckInterval;
}
public int getStalledTasksThreshold() {
return stalledTasksThreshold;
}
public int getStalledTasksRepeatedNotificationInterval() {
return stalledTasksRepeatedNotificationInterval;
}
public boolean isRunNowKeepsOriginalSchedule() {
return runNowKeepsOriginalSchedule;
}
public boolean isCreateQuartzTables() {
return createQuartzTables;
}
public void setCreateQuartzTables(boolean createQuartzTables) {
this.createQuartzTables = createQuartzTables;
}
public String getDataSource() {
return dataSource;
}
}