ProcessEngineConfiguration (camunda BPM

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.camunda.bpm.engine
Class ProcessEngineConfiguration

java.lang.Object
  org.camunda.bpm.engine.ProcessEngineConfiguration

Direct Known Subclasses:: ProcessEngineConfigurationImpl

public abstract class ProcessEngineConfiguration
extends Object
extends Object

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 programatic, without a configuration file, the first option is 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/activiti) in standalone mode. Standalone mode means that Activiti 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: #createStandalonInMemeProcessEngineConfiguration()

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/activiti) in standalone mode. The DB schema strategy default is in this case create-drop. Standalone mode means that Activiti 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 buildProcessEngine() method by calling any of the setters like this:

ProcessEngine processEngine = ProcessEngineConfiguration
   .createProcessEngineConfigurationFromResourceDefault()
   .setMailServerHost("gmail.com")
   .setJdbcUsername("mickey")
   .setJdbcPassword("mouse")
   .buildProcessEngine();

Author:: Tom Baeyens
See Also:: ProcessEngines

Field Summary
`static String`	`AUTHORIZATION_CHECK_REVOKE_ALWAYS` Always enables check for `revoke` authorizations.
`static String`	`AUTHORIZATION_CHECK_REVOKE_AUTO` This mode only checks for `revoke` authorizations if at least one revoke authorization currently exits for the current user or one of the groups the user is a member of.
`static String`	`AUTHORIZATION_CHECK_REVOKE_NEVER` Never checks for `revoke` authorizations.
`protected String`	`authorizationCheckRevokes`
`protected boolean`	`authorizationEnabled` switch for controlling whether the process engine performs authorization checks.
`protected boolean`	`authorizationEnabledForCustomCode` The following flag `authorizationEnabledForCustomCode` will only be taken into account iff `authorizationEnabled` is set `true`.
`protected ClassLoader`	`classLoader`
`protected boolean`	`createIncidentOnFailedJobEnabled`
`protected String`	`databaseSchemaUpdate`
`protected String`	`databaseType`
`protected DataSource`	`dataSource`
`protected String`	`dataSourceJndiName`
`static String`	`DB_SCHEMA_UPDATE_CREATE_DROP` Creates the schema when the process engine is being created and drops the schema when the process engine is being closed.
`static String`	`DB_SCHEMA_UPDATE_FALSE` Checks the version of the DB schema against the library when the process engine is being created and throws an exception if the versions don't match.
`static String`	`DB_SCHEMA_UPDATE_TRUE` Upon building of the process engine, a check is performed and an update of the schema is performed if it is necessary.
`protected int`	`defaultNumberOfRetries`
`protected String`	`defaultUserPermissionNameForTask` Provides the default task permission for the user related to a task User can be related to a task in the following ways - Candidate user - Part of candidate group - Assignee - Owner The default value is UPDATE.
`protected boolean`	`hintJobExecutor` The flag will be used inside the method "JobManager#send()".
`protected String`	`history`
`static String`	`HISTORY_ACTIVITY` Value for `setHistory(String)` to ensure that only historic process instances and historic activity instances are being recorded.
`static String`	`HISTORY_AUDIT` Value for `setHistory(String)` to ensure that only historic process instances, historic activity instances and submitted form property values are being recorded.
`static String`	`HISTORY_AUTO` Value for `setHistory(String)`.
`static String`	`HISTORY_DEFAULT` The default history level that is used when no history level is configured
`static String`	`HISTORY_FULL` Value for `setHistory(String)` to ensure that all historic information is being recorded, including the variable updates.
`static String`	`HISTORY_NONE` Value for `setHistory(String)` to ensure that no history is being recorded.
`static String`	`HISTORY_VARIABLE` Deprecated.
`protected int`	`idBlockSize`
`protected String`	`jdbcDriver`
`protected int`	`jdbcMaxActiveConnections`
`protected int`	`jdbcMaxCheckoutTime`
`protected int`	`jdbcMaxIdleConnections`
`protected int`	`jdbcMaxWaitTime`
`protected String`	`jdbcPassword`
`protected int`	`jdbcPingConnectionNotUsedFor`
`protected boolean`	`jdbcPingEnabled`
`protected String`	`jdbcPingQuery`
`protected Integer`	`jdbcStatementTimeout` the number of seconds the jdbc driver will wait for a response from the database
`protected String`	`jdbcUrl`
`protected String`	`jdbcUsername`
`protected boolean`	`jobExecutorAcquireByDueDate`
`protected boolean`	`jobExecutorAcquireByPriority`
`protected boolean`	`jobExecutorActivate`
`protected boolean`	`jobExecutorDeploymentAware`
`protected boolean`	`jobExecutorPreferTimerJobs`
`protected boolean`	`jpaCloseEntityManager`
`protected Object`	`jpaEntityManagerFactory`
`protected boolean`	`jpaHandleTransaction`
`protected String`	`jpaPersistenceUnitName`
`protected String`	`mailServerDefaultFrom`
`protected String`	`mailServerHost`
`protected String`	`mailServerPassword`
`protected int`	`mailServerPort`
`protected String`	`mailServerUsername`
`protected String`	`processEngineName`
`protected boolean`	`producePrioritizedExternalTasks`
`protected boolean`	`producePrioritizedJobs`
`protected SchemaOperationsCommand`	`schemaOperationsCommand`
`protected boolean`	`tenantCheckEnabled` If the value of this flag is set `true` then the process engine performs tenant checks to ensure that an authenticated user can only access data that belongs to one of his tenants.
`protected boolean`	`transactionsExternallyManaged`
`protected boolean`	`useTLS`
`protected org.camunda.bpm.engine.variable.type.ValueTypeResolver`	`valueTypeResolver`

Constructor Summary
`protected`	`ProcessEngineConfiguration()` use one of the static createXxxx methods instead

Method Summary
`abstract ProcessEngine`	`buildProcessEngine()`
`static ProcessEngineConfiguration`	`createProcessEngineConfigurationFromInputStream(InputStream inputStream)`
`static ProcessEngineConfiguration`	`createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName)`
`static ProcessEngineConfiguration`	`createProcessEngineConfigurationFromResource(String resource)`
`static ProcessEngineConfiguration`	`createProcessEngineConfigurationFromResource(String resource, String beanName)`
`static ProcessEngineConfiguration`	`createProcessEngineConfigurationFromResourceDefault()`
`static ProcessEngineConfiguration`	`createStandaloneInMemProcessEngineConfiguration()`
`static ProcessEngineConfiguration`	`createStandaloneProcessEngineConfiguration()`
`String`	`getAuthorizationCheckRevokes()`
`ClassLoader`	`getClassLoader()`
`String`	`getDatabaseSchemaUpdate()`
`String`	`getDatabaseType()`
`DataSource`	`getDataSource()`
`String`	`getDataSourceJndiName()`
`int`	`getDefaultNumberOfRetries()`
`String`	`getDefaultUserPermissionNameForTask()`
`String`	`getHistory()`
`int`	`getIdBlockSize()`
`String`	`getJdbcDriver()`
`int`	`getJdbcMaxActiveConnections()`
`int`	`getJdbcMaxCheckoutTime()`
`int`	`getJdbcMaxIdleConnections()`
`int`	`getJdbcMaxWaitTime()`
`String`	`getJdbcPassword()`
`int`	`getJdbcPingConnectionNotUsedFor()`
`String`	`getJdbcPingQuery()`
`Integer`	`getJdbcStatementTimeout()` Gets the number of seconds the jdbc driver will wait for a response from the database.
`String`	`getJdbcUrl()`
`String`	`getJdbcUsername()`
`Object`	`getJpaEntityManagerFactory()`
`String`	`getJpaPersistenceUnitName()`
`String`	`getMailServerDefaultFrom()`
`String`	`getMailServerHost()`
`String`	`getMailServerPassword()`
`int`	`getMailServerPort()`
`String`	`getMailServerUsername()`
`boolean`	`getMailServerUseTLS()`
`String`	`getProcessEngineName()`
`SchemaOperationsCommand`	`getSchemaOperationsCommand()`
`org.camunda.bpm.engine.variable.type.ValueTypeResolver`	`getValueTypeResolver()`
`boolean`	`isAuthorizationEnabled()`
`boolean`	`isAuthorizationEnabledForCustomCode()`
`boolean`	`isCreateIncidentOnFailedJobEnabled()`
`boolean`	`isHintJobExecutor()`
`boolean`	`isJdbcPingEnabled()`
`boolean`	`isJobExecutorAcquireByDueDate()`
`boolean`	`isJobExecutorAcquireByPriority()`
`boolean`	`isJobExecutorActivate()`
`boolean`	`isJobExecutorDeploymentAware()`
`boolean`	`isJobExecutorPreferTimerJobs()`
`boolean`	`isJpaCloseEntityManager()`
`boolean`	`isJpaHandleTransaction()`
`boolean`	`isProducePrioritizedExternalTasks()`
`boolean`	`isProducePrioritizedJobs()`
`boolean`	`isTenantCheckEnabled()`
`boolean`	`isTransactionsExternallyManaged()`
`void`	`setAuthorizationCheckRevokes(String authorizationCheckRevokes)`
`ProcessEngineConfiguration`	`setAuthorizationEnabled(boolean isAuthorizationChecksEnabled)`
`ProcessEngineConfiguration`	`setAuthorizationEnabledForCustomCode(boolean authorizationEnabledForCustomCode)`
`ProcessEngineConfiguration`	`setClassLoader(ClassLoader classLoader)`
`ProcessEngineConfiguration`	`setCreateIncidentOnFailedJobEnabled(boolean createIncidentOnFailedJobEnabled)`
`ProcessEngineConfiguration`	`setDatabaseSchemaUpdate(String databaseSchemaUpdate)`
`ProcessEngineConfiguration`	`setDatabaseType(String databaseType)`
`ProcessEngineConfiguration`	`setDataSource(DataSource dataSource)`
`void`	`setDataSourceJndiName(String dataSourceJndiName)`
`void`	`setDefaultNumberOfRetries(int defaultNumberOfRetries)`
`ProcessEngineConfiguration`	`setDefaultUserPermissionNameForTask(String defaultUserPermissionNameForTask)`
`ProcessEngineConfiguration`	`setHintJobExecutor(boolean hintJobExecutor)`
`ProcessEngineConfiguration`	`setHistory(String history)`
`ProcessEngineConfiguration`	`setIdBlockSize(int idBlockSize)`
`ProcessEngineConfiguration`	`setJdbcDriver(String jdbcDriver)`
`ProcessEngineConfiguration`	`setJdbcMaxActiveConnections(int jdbcMaxActiveConnections)`
`ProcessEngineConfiguration`	`setJdbcMaxCheckoutTime(int jdbcMaxCheckoutTime)`
`ProcessEngineConfiguration`	`setJdbcMaxIdleConnections(int jdbcMaxIdleConnections)`
`ProcessEngineConfiguration`	`setJdbcMaxWaitTime(int jdbcMaxWaitTime)`
`ProcessEngineConfiguration`	`setJdbcPassword(String jdbcPassword)`
`ProcessEngineConfiguration`	`setJdbcPingConnectionNotUsedFor(int jdbcPingNotUsedFor)`
`ProcessEngineConfiguration`	`setJdbcPingEnabled(boolean jdbcPingEnabled)`
`ProcessEngineConfiguration`	`setJdbcPingQuery(String jdbcPingQuery)`
`ProcessEngineConfiguration`	`setJdbcStatementTimeout(Integer jdbcStatementTimeout)` Sets the number of seconds the jdbc driver will wait for a response from the database.
`ProcessEngineConfiguration`	`setJdbcUrl(String jdbcUrl)`
`ProcessEngineConfiguration`	`setJdbcUsername(String jdbcUsername)`
`ProcessEngineConfiguration`	`setJobExecutorAcquireByDueDate(boolean jobExecutorAcquireByDueDate)`
`void`	`setJobExecutorAcquireByPriority(boolean jobExecutorAcquireByPriority)`
`ProcessEngineConfiguration`	`setJobExecutorActivate(boolean jobExecutorActivate)`
`ProcessEngineConfiguration`	`setJobExecutorDeploymentAware(boolean jobExecutorDeploymentAware)`
`ProcessEngineConfiguration`	`setJobExecutorPreferTimerJobs(boolean jobExecutorPreferTimerJobs)`
`ProcessEngineConfiguration`	`setJpaCloseEntityManager(boolean jpaCloseEntityManager)`
`ProcessEngineConfiguration`	`setJpaEntityManagerFactory(Object jpaEntityManagerFactory)`
`ProcessEngineConfiguration`	`setJpaHandleTransaction(boolean jpaHandleTransaction)`
`void`	`setJpaPersistenceUnitName(String jpaPersistenceUnitName)`
`ProcessEngineConfiguration`	`setMailServerDefaultFrom(String mailServerDefaultFrom)`
`ProcessEngineConfiguration`	`setMailServerHost(String mailServerHost)`
`ProcessEngineConfiguration`	`setMailServerPassword(String mailServerPassword)`
`ProcessEngineConfiguration`	`setMailServerPort(int mailServerPort)`
`ProcessEngineConfiguration`	`setMailServerUsername(String mailServerUsername)`
`ProcessEngineConfiguration`	`setMailServerUseTLS(boolean useTLS)`
`ProcessEngineConfiguration`	`setProcessEngineName(String processEngineName)`
`void`	`setProducePrioritizedExternalTasks(boolean producePrioritizedExternalTasks)`
`void`	`setProducePrioritizedJobs(boolean producePrioritizedJobs)`
`void`	`setSchemaOperationsCommand(SchemaOperationsCommand schemaOperationsCommand)`
`ProcessEngineConfiguration`	`setTenantCheckEnabled(boolean isTenantCheckEnabled)`
`ProcessEngineConfiguration`	`setTransactionsExternallyManaged(boolean transactionsExternallyManaged)`
`ProcessEngineConfiguration`	`setValueTypeResolver(org.camunda.bpm.engine.variable.type.ValueTypeResolver valueTypeResolver)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

DB_SCHEMA_UPDATE_FALSE

public static final String DB_SCHEMA_UPDATE_FALSE

Checks the version of the DB schema against the library when the process engine is being created and throws an exception if the versions don't match.

See Also:: Constant Field Values

DB_SCHEMA_UPDATE_CREATE_DROP

public static final String DB_SCHEMA_UPDATE_CREATE_DROP

Creates the schema when the process engine is being created and drops the schema when the process engine is being closed.

See Also:: Constant Field Values

DB_SCHEMA_UPDATE_TRUE

public static final String DB_SCHEMA_UPDATE_TRUE

Upon building of the process engine, a check is performed and an update of the schema is performed if it is necessary.

See Also:: Constant Field Values

HISTORY_NONE

public static final String HISTORY_NONE

Value for setHistory(String) to ensure that no history is being recorded.

See Also:: Constant Field Values

HISTORY_ACTIVITY

public static final String HISTORY_ACTIVITY

Value for setHistory(String) to ensure that only historic process instances and historic activity instances are being recorded. This means no details for those entities.

See Also:: Constant Field Values

HISTORY_VARIABLE

@Deprecated
public static final String HISTORY_VARIABLE

Deprecated.

Value for setHistory(String) to ensure that only historic process instances, historic activity instances and last process variable values are being recorded.

NOTE: This history level has been deprecated. Use level HISTORY_ACTIVITY instead.

See Also:: Constant Field Values

HISTORY_AUDIT

public static final String HISTORY_AUDIT

Value for setHistory(String) to ensure that only historic process instances, historic activity instances and submitted form property values are being recorded.

See Also:: Constant Field Values

HISTORY_FULL

public static final String HISTORY_FULL

Value for setHistory(String) to ensure that all historic information is being recorded, including the variable updates.

See Also:: Constant Field Values

HISTORY_AUTO

public static final String HISTORY_AUTO

Value for setHistory(String). Choosing auto causes the configuration to choose the level already present on the database. If none can be found, "audit" is taken.

See Also:: Constant Field Values

HISTORY_DEFAULT

public static final String HISTORY_DEFAULT

The default history level that is used when no history level is configured

See Also:: Constant Field Values

AUTHORIZATION_CHECK_REVOKE_ALWAYS

public static final String AUTHORIZATION_CHECK_REVOKE_ALWAYS

Always enables check for revoke authorizations. This mode is equal to the < 7.5 behavior.

*NOTE:* Checking revoke authorizations is very expensive for resources with a high potential cardinality like tasks or process instances and can render authorized access to the process engine effectively unusable on most databases. You are therefore strongly discouraged from using this mode.

See Also:: Constant Field Values

AUTHORIZATION_CHECK_REVOKE_NEVER

public static final String AUTHORIZATION_CHECK_REVOKE_NEVER

Never checks for revoke authorizations. This mode has best performance effectively disables the use of Authorization.AUTH_TYPE_REVOKE. *Note*: It is strongly recommended to use this mode.

See Also:: Constant Field Values

AUTHORIZATION_CHECK_REVOKE_AUTO

public static final String AUTHORIZATION_CHECK_REVOKE_AUTO

This mode only checks for revoke authorizations if at least one revoke authorization currently exits for the current user or one of the groups the user is a member of. To achieve this it is checked once per command whether potentially applicable revoke authorizations exist. Based on the outcome, the authorization check then uses revoke or not.

See Also:: Constant Field Values

processEngineName

protected String processEngineName

idBlockSize

protected int idBlockSize

history

protected String history

jobExecutorActivate

protected boolean jobExecutorActivate

jobExecutorDeploymentAware

protected boolean jobExecutorDeploymentAware

jobExecutorPreferTimerJobs

protected boolean jobExecutorPreferTimerJobs

jobExecutorAcquireByDueDate

protected boolean jobExecutorAcquireByDueDate

jobExecutorAcquireByPriority

protected boolean jobExecutorAcquireByPriority

producePrioritizedJobs

protected boolean producePrioritizedJobs

producePrioritizedExternalTasks

protected boolean producePrioritizedExternalTasks

hintJobExecutor

protected boolean hintJobExecutor

The flag will be used inside the method "JobManager#send()". It will be used to decide whether to notify the job executor that a new job has been created. It will be used for performance improvement, so that the new job could be executed in some situations immediately.

mailServerHost

protected String mailServerHost

mailServerUsername

protected String mailServerUsername

mailServerPassword

protected String mailServerPassword

mailServerPort

protected int mailServerPort

useTLS

protected boolean useTLS

mailServerDefaultFrom

protected String mailServerDefaultFrom

databaseType

protected String databaseType

databaseSchemaUpdate

protected String databaseSchemaUpdate

jdbcDriver

protected String jdbcDriver

jdbcUrl

protected String jdbcUrl

jdbcUsername

protected String jdbcUsername

jdbcPassword

protected String jdbcPassword

dataSourceJndiName

protected String dataSourceJndiName

jdbcMaxActiveConnections

protected int jdbcMaxActiveConnections

jdbcMaxIdleConnections

protected int jdbcMaxIdleConnections

jdbcMaxCheckoutTime

protected int jdbcMaxCheckoutTime

jdbcMaxWaitTime

protected int jdbcMaxWaitTime

jdbcPingEnabled

protected boolean jdbcPingEnabled

jdbcPingQuery

protected String jdbcPingQuery

jdbcPingConnectionNotUsedFor

protected int jdbcPingConnectionNotUsedFor

dataSource

protected DataSource dataSource

schemaOperationsCommand

protected SchemaOperationsCommand schemaOperationsCommand

transactionsExternallyManaged

protected boolean transactionsExternallyManaged

jdbcStatementTimeout

protected Integer jdbcStatementTimeout

the number of seconds the jdbc driver will wait for a response from the database

jpaPersistenceUnitName

protected String jpaPersistenceUnitName

jpaEntityManagerFactory

protected Object jpaEntityManagerFactory

jpaHandleTransaction

protected boolean jpaHandleTransaction

jpaCloseEntityManager

protected boolean jpaCloseEntityManager

defaultNumberOfRetries

protected int defaultNumberOfRetries

classLoader

protected ClassLoader classLoader

createIncidentOnFailedJobEnabled

protected boolean createIncidentOnFailedJobEnabled

authorizationEnabled

protected boolean authorizationEnabled

switch for controlling whether the process engine performs authorization checks. The default value is false.

defaultUserPermissionNameForTask

protected String defaultUserPermissionNameForTask

Provides the default task permission for the user related to a task User can be related to a task in the following ways - Candidate user - Part of candidate group - Assignee - Owner The default value is UPDATE.

authorizationEnabledForCustomCode

protected boolean authorizationEnabledForCustomCode

The following flag authorizationEnabledForCustomCode will only be taken into account iff authorizationEnabled is set true.

If the value of the flag authorizationEnabledForCustomCode is set true then an authorization check will be performed by executing commands inside custom code (e.g. inside JavaDelegate).

The default value is false.

tenantCheckEnabled

protected boolean tenantCheckEnabled

If the value of this flag is set true then the process engine performs tenant checks to ensure that an authenticated user can only access data that belongs to one of his tenants.

valueTypeResolver

protected org.camunda.bpm.engine.variable.type.ValueTypeResolver valueTypeResolver

authorizationCheckRevokes

protected String authorizationCheckRevokes

Constructor Detail