org.flowable.engine.ProcessEngineConfiguration Maven / Gradle / Ivy
/* 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 org.flowable.engine;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.flowable.common.engine.api.async.AsyncTaskExecutor;
import org.flowable.common.engine.api.async.AsyncTaskInvoker;
import org.flowable.common.engine.api.engine.EngineLifecycleListener;
import org.flowable.common.engine.impl.AbstractEngineConfiguration;
import org.flowable.common.engine.impl.cfg.BeansConfigurationHelper;
import org.flowable.common.engine.impl.cfg.mail.MailServerInfo;
import org.flowable.common.engine.impl.history.HistoryLevel;
import org.flowable.common.engine.impl.runtime.Clock;
import org.flowable.engine.cfg.HttpClientConfig;
import org.flowable.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration;
import org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration;
import org.flowable.image.ProcessDiagramGenerator;
import org.flowable.job.service.impl.asyncexecutor.AsyncExecutor;
import org.flowable.task.service.TaskPostProcessor;
/**
* Configuration information from which a process engine can be build.
*
*
* Most common is to create a process engine based on the default configuration file:
*
*
* ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault().buildProcessEngine();
*
*
*
* To create a process engine programmatic, without a configuration file, the first option is {@link #createStandaloneProcessEngineConfiguration()}
*
*
* ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration().buildProcessEngine();
*
*
*
* This creates a new process engine with all the defaults to connect to a remote h2 database (jdbc:h2:tcp://localhost/flowable) in standalone mode. Standalone mode means that the process engine will
* manage the transactions on the JDBC connections that it creates. One transaction per service method. For a description of how to write the configuration files, see the userguide.
*
*
*
* The second option is great for testing: {@link #createStandaloneInMemProcessEngineConfiguration()}
*
*
* ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration().buildProcessEngine();
*
*
*
* This creates a new process engine with all the defaults to connect to an memory h2 database (jdbc:h2:tcp://localhost/flowable) in standalone mode. The DB schema strategy default is in this case
* {@code create-drop}. Standalone mode means that Flowable will manage the transactions on the JDBC connections that it creates. One transaction per service method.
*
*
*
* On all forms of creating a process engine, you can first customize the configuration before calling the {@link #buildProcessEngine()} method by calling any of the setters like this:
*
*
* ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault().setMailServerHost("gmail.com").setJdbcUsername("mickey").setJdbcPassword("mouse")
* .buildProcessEngine();
*
*
* @see ProcessEngines
* @author Tom Baeyens
*/
public abstract class ProcessEngineConfiguration extends AbstractEngineConfiguration {
protected String processEngineName = ProcessEngines.NAME_DEFAULT;
protected int idBlockSize = 2500;
protected String history = HistoryLevel.AUDIT.getKey();
protected boolean asyncExecutorActivate;
protected boolean asyncHistoryExecutorActivate;
protected String mailServerHost = "localhost";
protected String mailServerUsername; // by default no name and password are provided, which
protected String mailServerPassword; // means no authentication for mail server
protected int mailServerPort = 25;
protected int mailServerSSLPort = 465;
protected boolean useSSL;
protected boolean useTLS;
protected String mailServerDefaultFrom = "flowable@localhost";
protected String mailServerForceTo;
protected String mailSessionJndi;
protected Map mailServers = new HashMap<>();
protected Map mailSessionsJndi = new HashMap<>();
// Set Http Client config defaults
protected HttpClientConfig httpClientConfig = new HttpClientConfig();
protected HistoryLevel historyLevel;
protected boolean enableProcessDefinitionHistoryLevel;
protected String jpaPersistenceUnitName;
protected Object jpaEntityManagerFactory;
protected boolean jpaHandleTransaction;
protected boolean jpaCloseEntityManager;
protected AsyncExecutor asyncExecutor;
protected AsyncTaskExecutor asyncTaskExecutor;
protected boolean shutdownAsyncTaskExecutor;
protected AsyncTaskInvoker asyncTaskInvoker;
protected AsyncExecutor asyncHistoryExecutor;
protected AsyncTaskExecutor asyncHistoryTaskExecutor;
protected boolean shutdownAsyncHistoryTaskExecutor;
/**
* Define the default lock time for an async job in seconds. The lock time is used when creating an async job and when it expires the async executor assumes that the job has failed. It will be
* retried again.
*/
protected int lockTimeAsyncJobWaitTime = 60;
/** define the default wait time for a failed job in seconds */
protected int defaultFailedJobWaitTime = 10;
/** define the default wait time for a failed async job in seconds */
protected int asyncFailedJobWaitTime = 10;
/**
* Process diagram generator. Default value is DefaultProcessDiagramGenerator
*/
protected ProcessDiagramGenerator processDiagramGenerator;
protected boolean isCreateDiagramOnDeploy = true;
protected boolean alwaysUseArraysForDmnMultiHitPolicies = true;
/**
* include the sequence flow name in case there's no Label DI,
*/
protected boolean drawSequenceFlowNameWithNoLabelDI = false;
protected String defaultCamelContext = "camelContext";
protected String activityFontName = "Arial";
protected String labelFontName = "Arial";
protected String annotationFontName = "Arial";
protected boolean enableProcessDefinitionInfoCache;
// History Cleanup
protected boolean enableHistoryCleaning = false;
protected String historyCleaningTimeCycleConfig = "0 0 1 * * ?";
protected int cleanInstancesEndedAfterNumberOfDays = 365;
protected HistoryCleaningManager historyCleaningManager;
/** postprocessor for a task builder */
protected TaskPostProcessor taskPostProcessor = null;
/** use one of the static createXxxx methods instead */
protected ProcessEngineConfiguration() {
}
public abstract ProcessEngine buildProcessEngine();
public static ProcessEngineConfiguration createProcessEngineConfigurationFromResourceDefault() {
return createProcessEngineConfigurationFromResource("flowable.cfg.xml", "processEngineConfiguration");
}
public static ProcessEngineConfiguration createProcessEngineConfigurationFromResource(String resource) {
return createProcessEngineConfigurationFromResource(resource, "processEngineConfiguration");
}
public static ProcessEngineConfiguration createProcessEngineConfigurationFromResource(String resource, String beanName) {
return (ProcessEngineConfiguration) BeansConfigurationHelper.parseEngineConfigurationFromResource(resource, beanName);
}
public static ProcessEngineConfiguration createProcessEngineConfigurationFromInputStream(InputStream inputStream) {
return createProcessEngineConfigurationFromInputStream(inputStream, "processEngineConfiguration");
}
public static ProcessEngineConfiguration createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName) {
return (ProcessEngineConfiguration) BeansConfigurationHelper.parseEngineConfigurationFromInputStream(inputStream, beanName);
}
public static ProcessEngineConfiguration createStandaloneProcessEngineConfiguration() {
return new StandaloneProcessEngineConfiguration();
}
public static ProcessEngineConfiguration createStandaloneInMemProcessEngineConfiguration() {
return new StandaloneInMemProcessEngineConfiguration();
}
// TODO add later when we have test coverage for this
// public static ProcessEngineConfiguration
// createJtaProcessEngineConfiguration() {
// return new JtaProcessEngineConfiguration();
// }
public abstract RepositoryService getRepositoryService();
public abstract RuntimeService getRuntimeService();
public abstract FormService getFormService();
public abstract TaskService getTaskService();
public abstract HistoryService getHistoryService();
public abstract IdentityService getIdentityService();
public abstract ManagementService getManagementService();
public abstract ProcessEngineConfiguration getProcessEngineConfiguration();
// getters and setters
// //////////////////////////////////////////////////////
@Override
public String getEngineName() {
return processEngineName;
}
public ProcessEngineConfiguration setEngineName(String processEngineName) {
this.processEngineName = processEngineName;
return this;
}
public int getIdBlockSize() {
return idBlockSize;
}
public ProcessEngineConfiguration setIdBlockSize(int idBlockSize) {
this.idBlockSize = idBlockSize;
return this;
}
public String getHistory() {
return history;
}
public ProcessEngineConfiguration setHistory(String history) {
this.history = history;
return this;
}
public String getMailServerHost() {
return mailServerHost;
}
public ProcessEngineConfiguration setMailServerHost(String mailServerHost) {
this.mailServerHost = mailServerHost;
return this;
}
public String getMailServerUsername() {
return mailServerUsername;
}
public ProcessEngineConfiguration setMailServerUsername(String mailServerUsername) {
this.mailServerUsername = mailServerUsername;
return this;
}
public String getMailServerPassword() {
return mailServerPassword;
}
public ProcessEngineConfiguration setMailServerPassword(String mailServerPassword) {
this.mailServerPassword = mailServerPassword;
return this;
}
public String getMailSessionJndi() {
return mailSessionJndi;
}
public ProcessEngineConfiguration setMailSessionJndi(String mailSessionJndi) {
this.mailSessionJndi = mailSessionJndi;
return this;
}
public int getMailServerPort() {
return mailServerPort;
}
public ProcessEngineConfiguration setMailServerPort(int mailServerPort) {
this.mailServerPort = mailServerPort;
return this;
}
public int getMailServerSSLPort() {
return mailServerSSLPort;
}
public ProcessEngineConfiguration setMailServerSSLPort(int mailServerSSLPort) {
this.mailServerSSLPort = mailServerSSLPort;
return this;
}
public boolean getMailServerUseSSL() {
return useSSL;
}
public ProcessEngineConfiguration setMailServerUseSSL(boolean useSSL) {
this.useSSL = useSSL;
return this;
}
public boolean getMailServerUseTLS() {
return useTLS;
}
public ProcessEngineConfiguration setMailServerUseTLS(boolean useTLS) {
this.useTLS = useTLS;
return this;
}
public String getMailServerDefaultFrom() {
return mailServerDefaultFrom;
}
public ProcessEngineConfiguration setMailServerDefaultFrom(String mailServerDefaultFrom) {
this.mailServerDefaultFrom = mailServerDefaultFrom;
return this;
}
public String getMailServerForceTo() {
return mailServerForceTo;
}
public ProcessEngineConfiguration setMailServerForceTo(String mailServerForceTo) {
this.mailServerForceTo = mailServerForceTo;
return this;
}
public MailServerInfo getMailServer(String tenantId) {
return mailServers.get(tenantId);
}
public Map getMailServers() {
return mailServers;
}
public ProcessEngineConfiguration setMailServers(Map mailServers) {
this.mailServers.putAll(mailServers);
return this;
}
public String getMailSessionJndi(String tenantId) {
return mailSessionsJndi.get(tenantId);
}
public Map getMailSessionsJndi() {
return mailSessionsJndi;
}
public ProcessEngineConfiguration setMailSessionsJndi(Map mailSessionsJndi) {
this.mailSessionsJndi.putAll(mailSessionsJndi);
return this;
}
public HttpClientConfig getHttpClientConfig() {
return httpClientConfig;
}
public void setHttpClientConfig(HttpClientConfig httpClientConfig) {
this.httpClientConfig.merge(httpClientConfig);
}
@Override
public ProcessEngineConfiguration setDatabaseType(String databaseType) {
this.databaseType = databaseType;
return this;
}
@Override
public ProcessEngineConfiguration setDatabaseSchemaUpdate(String databaseSchemaUpdate) {
this.databaseSchemaUpdate = databaseSchemaUpdate;
return this;
}
@Override
public ProcessEngineConfiguration setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcDriver(String jdbcDriver) {
this.jdbcDriver = jdbcDriver;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcUrl(String jdbcUrl) {
this.jdbcUrl = jdbcUrl;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcUsername(String jdbcUsername) {
this.jdbcUsername = jdbcUsername;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcPassword(String jdbcPassword) {
this.jdbcPassword = jdbcPassword;
return this;
}
@Override
public ProcessEngineConfiguration setTransactionsExternallyManaged(boolean transactionsExternallyManaged) {
this.transactionsExternallyManaged = transactionsExternallyManaged;
return this;
}
public HistoryLevel getHistoryLevel() {
return historyLevel;
}
public ProcessEngineConfiguration setHistoryLevel(HistoryLevel historyLevel) {
this.historyLevel = historyLevel;
return this;
}
public boolean isEnableProcessDefinitionHistoryLevel() {
return enableProcessDefinitionHistoryLevel;
}
public ProcessEngineConfiguration setEnableProcessDefinitionHistoryLevel(boolean enableProcessDefinitionHistoryLevel) {
this.enableProcessDefinitionHistoryLevel = enableProcessDefinitionHistoryLevel;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcMaxActiveConnections(int jdbcMaxActiveConnections) {
this.jdbcMaxActiveConnections = jdbcMaxActiveConnections;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcMaxIdleConnections(int jdbcMaxIdleConnections) {
this.jdbcMaxIdleConnections = jdbcMaxIdleConnections;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcMaxCheckoutTime(int jdbcMaxCheckoutTime) {
this.jdbcMaxCheckoutTime = jdbcMaxCheckoutTime;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcMaxWaitTime(int jdbcMaxWaitTime) {
this.jdbcMaxWaitTime = jdbcMaxWaitTime;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcPingEnabled(boolean jdbcPingEnabled) {
this.jdbcPingEnabled = jdbcPingEnabled;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcPingQuery(String jdbcPingQuery) {
this.jdbcPingQuery = jdbcPingQuery;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcPingConnectionNotUsedFor(int jdbcPingNotUsedFor) {
this.jdbcPingConnectionNotUsedFor = jdbcPingNotUsedFor;
return this;
}
@Override
public ProcessEngineConfiguration setJdbcDefaultTransactionIsolationLevel(int jdbcDefaultTransactionIsolationLevel) {
this.jdbcDefaultTransactionIsolationLevel = jdbcDefaultTransactionIsolationLevel;
return this;
}
public boolean isAsyncExecutorActivate() {
return asyncExecutorActivate;
}
public ProcessEngineConfiguration setAsyncExecutorActivate(boolean asyncExecutorActivate) {
this.asyncExecutorActivate = asyncExecutorActivate;
return this;
}
public boolean isAsyncHistoryExecutorActivate() {
return asyncHistoryExecutorActivate;
}
public ProcessEngineConfiguration setAsyncHistoryExecutorActivate(boolean asyncHistoryExecutorActivate) {
this.asyncHistoryExecutorActivate = asyncHistoryExecutorActivate;
return this;
}
@Override
public ProcessEngineConfiguration setClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
return this;
}
@Override
public ProcessEngineConfiguration setUseClassForNameClassLoading(boolean useClassForNameClassLoading) {
this.useClassForNameClassLoading = useClassForNameClassLoading;
return this;
}
public Object getJpaEntityManagerFactory() {
return jpaEntityManagerFactory;
}
public ProcessEngineConfiguration setJpaEntityManagerFactory(Object jpaEntityManagerFactory) {
this.jpaEntityManagerFactory = jpaEntityManagerFactory;
return this;
}
public boolean isJpaHandleTransaction() {
return jpaHandleTransaction;
}
public ProcessEngineConfiguration setJpaHandleTransaction(boolean jpaHandleTransaction) {
this.jpaHandleTransaction = jpaHandleTransaction;
return this;
}
public boolean isJpaCloseEntityManager() {
return jpaCloseEntityManager;
}
public ProcessEngineConfiguration setJpaCloseEntityManager(boolean jpaCloseEntityManager) {
this.jpaCloseEntityManager = jpaCloseEntityManager;
return this;
}
public String getJpaPersistenceUnitName() {
return jpaPersistenceUnitName;
}
public ProcessEngineConfiguration setJpaPersistenceUnitName(String jpaPersistenceUnitName) {
this.jpaPersistenceUnitName = jpaPersistenceUnitName;
return this;
}
@Override
public ProcessEngineConfiguration setDataSourceJndiName(String dataSourceJndiName) {
this.dataSourceJndiName = dataSourceJndiName;
return this;
}
public String getDefaultCamelContext() {
return defaultCamelContext;
}
public ProcessEngineConfiguration setDefaultCamelContext(String defaultCamelContext) {
this.defaultCamelContext = defaultCamelContext;
return this;
}
public boolean isCreateDiagramOnDeploy() {
return isCreateDiagramOnDeploy;
}
public ProcessEngineConfiguration setCreateDiagramOnDeploy(boolean createDiagramOnDeploy) {
this.isCreateDiagramOnDeploy = createDiagramOnDeploy;
return this;
}
public boolean isDrawSequenceFlowNameWithNoLabelDI() {
return drawSequenceFlowNameWithNoLabelDI;
}
public ProcessEngineConfiguration setDrawSequenceFlowNameWithNoLabelDI(boolean drawSequenceFlowNameWithNoLabelDI) {
this.drawSequenceFlowNameWithNoLabelDI = drawSequenceFlowNameWithNoLabelDI;
return this;
}
public String getActivityFontName() {
return activityFontName;
}
public ProcessEngineConfiguration setActivityFontName(String activityFontName) {
this.activityFontName = activityFontName;
return this;
}
/**
* @deprecated Use {@link #setEngineLifecycleListeners(List)}.
*/
@Deprecated
public ProcessEngineConfiguration setProcessEngineLifecycleListener(ProcessEngineLifecycleListener processEngineLifecycleListener) {
// Backwards compatibility (when there was only one typed engine listener)
if (engineLifecycleListeners == null || engineLifecycleListeners.isEmpty()) {
List engineLifecycleListeners = new ArrayList<>(1);
engineLifecycleListeners.add(processEngineLifecycleListener);
super.setEngineLifecycleListeners(engineLifecycleListeners);
} else {
ProcessEngineLifecycleListener originalEngineLifecycleListener = (ProcessEngineLifecycleListener) engineLifecycleListeners.get(0);
ProcessEngineLifecycleListener wrappingEngineLifecycleListener = new ProcessEngineLifecycleListener() {
@Override
public void onProcessEngineBuilt(ProcessEngine processEngine) {
originalEngineLifecycleListener.onProcessEngineBuilt(processEngine);
}
@Override
public void onProcessEngineClosed(ProcessEngine processEngine) {
originalEngineLifecycleListener.onProcessEngineClosed(processEngine);
}
};
engineLifecycleListeners.set(0, wrappingEngineLifecycleListener);
}
return this;
}
/**
* @deprecated Use {@link #getEngineLifecycleListeners()}.
*/
@Deprecated
public ProcessEngineLifecycleListener getProcessEngineLifecycleListener() {
// Backwards compatibility (when there was only one typed engine listener)
if (engineLifecycleListeners != null && !engineLifecycleListeners.isEmpty()) {
return (ProcessEngineLifecycleListener) engineLifecycleListeners.get(0);
}
return null;
}
public String getLabelFontName() {
return labelFontName;
}
public ProcessEngineConfiguration setLabelFontName(String labelFontName) {
this.labelFontName = labelFontName;
return this;
}
public String getAnnotationFontName() {
return annotationFontName;
}
public ProcessEngineConfiguration setAnnotationFontName(String annotationFontName) {
this.annotationFontName = annotationFontName;
return this;
}
@Override
public ProcessEngineConfiguration setDatabaseTablePrefix(String databaseTablePrefix) {
this.databaseTablePrefix = databaseTablePrefix;
return this;
}
@Override
public ProcessEngineConfiguration setTablePrefixIsSchema(boolean tablePrefixIsSchema) {
this.tablePrefixIsSchema = tablePrefixIsSchema;
return this;
}
@Override
public ProcessEngineConfiguration setDatabaseWildcardEscapeCharacter(String databaseWildcardEscapeCharacter) {
this.databaseWildcardEscapeCharacter = databaseWildcardEscapeCharacter;
return this;
}
@Override
public ProcessEngineConfiguration setDatabaseCatalog(String databaseCatalog) {
this.databaseCatalog = databaseCatalog;
return this;
}
@Override
public ProcessEngineConfiguration setDatabaseSchema(String databaseSchema) {
this.databaseSchema = databaseSchema;
return this;
}
@Override
public ProcessEngineConfiguration setXmlEncoding(String xmlEncoding) {
this.xmlEncoding = xmlEncoding;
return this;
}
@Override
public ProcessEngineConfiguration setClock(Clock clock) {
this.clock = clock;
return this;
}
public ProcessDiagramGenerator getProcessDiagramGenerator() {
return this.processDiagramGenerator;
}
public ProcessEngineConfiguration setProcessDiagramGenerator(ProcessDiagramGenerator processDiagramGenerator) {
this.processDiagramGenerator = processDiagramGenerator;
return this;
}
public AsyncExecutor getAsyncExecutor() {
return asyncExecutor;
}
public ProcessEngineConfiguration setAsyncExecutor(AsyncExecutor asyncExecutor) {
this.asyncExecutor = asyncExecutor;
return this;
}
public AsyncTaskExecutor getAsyncTaskExecutor() {
return asyncTaskExecutor;
}
public ProcessEngineConfiguration setAsyncTaskExecutor(AsyncTaskExecutor asyncTaskExecutor) {
this.asyncTaskExecutor = asyncTaskExecutor;
return this;
}
public AsyncTaskInvoker getAsyncTaskInvoker() {
return asyncTaskInvoker;
}
public ProcessEngineConfiguration setAsyncTaskInvoker(AsyncTaskInvoker asyncTaskInvoker) {
this.asyncTaskInvoker = asyncTaskInvoker;
return this;
}
public AsyncExecutor getAsyncHistoryExecutor() {
return asyncHistoryExecutor;
}
public ProcessEngineConfiguration setAsyncHistoryExecutor(AsyncExecutor asyncHistoryExecutor) {
this.asyncHistoryExecutor = asyncHistoryExecutor;
return this;
}
public AsyncTaskExecutor getAsyncHistoryTaskExecutor() {
return asyncHistoryTaskExecutor;
}
public ProcessEngineConfiguration setAsyncHistoryTaskExecutor(AsyncTaskExecutor asyncHistoryTaskExecutor) {
this.asyncHistoryTaskExecutor = asyncHistoryTaskExecutor;
return this;
}
public int getLockTimeAsyncJobWaitTime() {
return lockTimeAsyncJobWaitTime;
}
public ProcessEngineConfiguration setLockTimeAsyncJobWaitTime(int lockTimeAsyncJobWaitTime) {
this.lockTimeAsyncJobWaitTime = lockTimeAsyncJobWaitTime;
return this;
}
public int getDefaultFailedJobWaitTime() {
return defaultFailedJobWaitTime;
}
public ProcessEngineConfiguration setDefaultFailedJobWaitTime(int defaultFailedJobWaitTime) {
this.defaultFailedJobWaitTime = defaultFailedJobWaitTime;
return this;
}
public int getAsyncFailedJobWaitTime() {
return asyncFailedJobWaitTime;
}
public ProcessEngineConfiguration setAsyncFailedJobWaitTime(int asyncFailedJobWaitTime) {
this.asyncFailedJobWaitTime = asyncFailedJobWaitTime;
return this;
}
public boolean isEnableProcessDefinitionInfoCache() {
return enableProcessDefinitionInfoCache;
}
public ProcessEngineConfiguration setEnableProcessDefinitionInfoCache(boolean enableProcessDefinitionInfoCache) {
this.enableProcessDefinitionInfoCache = enableProcessDefinitionInfoCache;
return this;
}
public TaskPostProcessor getTaskPostProcessor() {
return taskPostProcessor;
}
public void setTaskPostProcessor(TaskPostProcessor processor) {
this.taskPostProcessor = processor;
}
public boolean isEnableHistoryCleaning() {
return enableHistoryCleaning;
}
public ProcessEngineConfiguration setEnableHistoryCleaning(boolean enableHistoryCleaning) {
this.enableHistoryCleaning = enableHistoryCleaning;
return this;
}
public String getHistoryCleaningTimeCycleConfig() {
return historyCleaningTimeCycleConfig;
}
public ProcessEngineConfiguration setHistoryCleaningTimeCycleConfig(String historyCleaningTimeCycleConfig) {
this.historyCleaningTimeCycleConfig = historyCleaningTimeCycleConfig;
return this;
}
public int getCleanInstancesEndedAfterNumberOfDays() {
return cleanInstancesEndedAfterNumberOfDays;
}
public ProcessEngineConfiguration setCleanInstancesEndedAfterNumberOfDays(int cleanInstancesEndedAfterNumberOfDays) {
this.cleanInstancesEndedAfterNumberOfDays = cleanInstancesEndedAfterNumberOfDays;
return this;
}
public HistoryCleaningManager getHistoryCleaningManager() {
return historyCleaningManager;
}
public ProcessEngineConfiguration setHistoryCleaningManager(HistoryCleaningManager historyCleaningManager) {
this.historyCleaningManager = historyCleaningManager;
return this;
}
public boolean isAlwaysUseArraysForDmnMultiHitPolicies() {
return alwaysUseArraysForDmnMultiHitPolicies;
}
public ProcessEngineConfiguration setAlwaysUseArraysForDmnMultiHitPolicies(boolean alwaysUseArraysForDmnMultiHitPolicies) {
this.alwaysUseArraysForDmnMultiHitPolicies = alwaysUseArraysForDmnMultiHitPolicies;
return this;
}
}