All Classes and Interfaces
Class
Description
Abstract class that modifies
AbstractSetTaskPropertyCmd to customize validation & logging for
Add Identity Link related Commands.Common methods for batch job handlers based on list of ids, providing serialization, configuration instantiation, etc.
Denotes an 'activity' in the sense of BPMN 2.0:
a parent class for all tasks, subprocess and callActivity.
Abstract base class for implementing a
BpmnParseListener without being forced to implement
all methods provided, which makes the implementation more robust to future changes.Abstract base class for implementing a
CmmnTransformListener without being forced to implement
all methods provided, which make the implementation more robust to future changes.Deployer responsible to parse resource files and create the proper entities.Created by aakhmerov on 16.09.16.
Abstract superclass for all native query types.
Abstract implementation of a
TypedValueSerializer for ObjectValues.Deployment operation step responsible for parsing and attaching the bpm-platform.xml file.
Adapter class for implementing process engine plugins
Abstract superclass for all query types.
AbstractSerializableValueSerializer<T extends org.camunda.bpm.engine.variable.value.SerializableValue>
This base class provides a template method to handle servlet applications annotated
with the
ProcessApplication.Abstract command class, meant to encapsulate boilerplate logic for concrete commands that wish to set a property
on a task and inherit authorization, multi-tenancy
Deployment operation step that is responsible for starting all process
engines declared in a
List of ProcessEngineXml files.Base class for handling the context of a transaction.
Base interceptor class for handling transactions for a command.
Base class for a JTA-based process engine configuration.
AbstractTypedValueSerializer<T extends org.camunda.bpm.engine.variable.value.TypedValue>
Abstract query class that adds methods to query for variable values.
Combination of flow scope and execution walker.
Collect the mappings of scopes and executions.
Maps an activity (plain activities + their containing flow scopes) to the scope executions
that are executing them.
Tuple of a scope and an execution.
Delegate interface for the asyncAfter property update
Delegate interface for the asyncBefore property update.
An activity instance represents an instance of an activity.
Contains a predefined set of states activity instances may be in
during the execution of a process instance.
Defines the start behavior for
activities.Class contains constants that identifies the activity types, which are used by Camunda.
This class represents the data structure used for collecting information
about the application server.
Create and destroy artifacts of a given class in a container specific way.
Deprecated.
An invocation of an atomic operation
Any type of content that is be associated with
a task or with a process instance.
Contains the attachment names of all attachments used by the
ProcessApplication deployment OperationSteps.
Allows to expose the id of the currently authenticated user,
his groups and his tenants to the process engine.
Input for the authorization check algorithm
Command allowing to perform an authorization check
CommandChecker that uses the AuthorizationManager to perform
authorization checks.Exception thrown by the process engine in case a user tries to
interact with a resource in an unauthorized way.
Contains the possible properties that can be used in an
AuthorizationQuery.The authorization service allows managing
Authorizations.Determines the number of jobs to acquire and the time to wait between acquisition cycles
by an exponential backoff strategy.
Exception resulting from a bad user request.
Provides Base64 encoding and decoding as defined by RFC 2045.
A batch represents a number of jobs which
execute a number of commands asynchronously.
For mybatis
ExecutorType.BATCHConfiguration information on the elements of a batch
A batch job handler manages batch jobs based
on the configuration
BatchJobHandler.Job declaration for batch monitor jobs.
Job handler for batch monitor jobs.
The set of built-in
Permissions for Batch operations in Camunda Platform.Query for
Batch instances.Contains the possible properties that can be used in a
BatchQuery.Job declaration for batch seed jobs.
The batch seed job handler is responsible to
create all jobs to be executed by the batch.
Additional statistics for a single batch.
Util class for manipulating bit-flag in ints.
Serializes booleans as long values.
The BPMN Boundary Event.
XML
NamespaceContext containing the namespaces used by BPMN 2.0 XML documents.Helper class for implementing BPMN 2.0 activities, offering convenience
methods specific to BPMN 2.0.
Deployer responsible to parse BPMN 2.0 XML files and create the proper
ProcessDefinitionEntitys.Special exception that can be used to throw a BPMN Error from
JavaDelegates and expressions.Helper class handling the propagation of BPMN Errors.
Implemented by classes which provide access to the
BpmnModelInstance
and the currently executed FlowElement.Specific parsing of one BPMN 2.0 XML file, created by the
BpmnParser.Exception during the parsing of an BPMN model.
Listener which can be registered within the engine to receive events during parsing (and
maybe influence it).
Parser for BPMN 2.0 process models.
Helper methods to reused for common parsing tasks.
Properties of bpmn elements.
Provides access to the Camunda Platform services.
Java API representation of the bpm-platform.xml file.
Implementation of the BpmPlatformXml SPI
Parse implementation for parsing the
BpmPlatformXmlA SAX Parser for the bpm-platform.xml file
The set of built-in exception codes the built-in
ExceptionCodeProvider
uses to assign a code to a ProcessEngineException.A byte array value field what load and save
ByteArrayEntity.This HistoryEventProducer is aware of the
DbEntityManager cache
and works in combination with the DbHistoryEventHandler.A cached entity
Builds the caches for the
DeploymentCache.Implementation of the BPMN 2.0 call activity
(limited currently to calling a subprocess and not (yet) a global task).
Represents a callback which should be called after work was done.
An object structure representing a Camunda Form used to present forms to users
either when starting a process instance or when assigned to a User Task.
A
CamundaFormRef represents a reference to a deployed Camunda Form.See CancelEndEventActivityBehavior: the cancel end event interrupts the scope and performs compensation.
Validates that the target process definition cannot add a migrating multi-instance body.
Validates that the target process definition cannot add a new inner activity to a migrating multi-instance body.
Validates that the target process definition cannot add a remove the inner activity of a
migrating multi-instance body.
Implementation to create a new
CaseInstance using the BPMN 2.0 call activityThis is exception is thrown when a specific case definition is not found.
This is exception is thrown when something happens in the execution
of a case instance.
Represent a planned item in a case instance.
A fluent builder for defining a command to execute for a case execution.
Listener interface implemented by user code which wants to be notified
when a state transition happens on a
CaseExecution.Class handling invocations of ExecutionListeners
This is exception is thrown when a specific case execution is not found.
This is exception is thrown when a state transition on a case execution
is not possible.
A fluent builder to create a new case instance.
This query is currently not public API on purpose.
Service which provides access to
case instances
and case executions.A variable listener can be defined on a scope in a case model.
Helper class for bpmn constructs that allow class delegation.
Runtime exception indicating the requested class was not found or an error occurred
while loading the class.
Scans for bpmn20.xml files in the classpath of the given classloader.
Defines a report query for cleanable batches.
This interface defines the result of Cleanable historic batch report.
Defines a report query for cleanable case instances.
This interface defines the result of Historic finished case instance report.
Defines a report query for finished decision instances.
This interface defines the result of Cleanable historic decision instance report.
Defines a report query for cleanable process instances.
This interface defines the result of Cleanable historic process instance report.
Deployer responsible to parse CMMN 1.0 XML files and create the
proper CaseDefinitionEntitys.This handler handles an instance of a
CmmnElement to create
a new activity.This context contains necessary information (like caseDefinition)
to be accessed by a
CmmnHandlerContext.The producer for CMMN history events.
Implemented by classes which provide access to the
CmmnModelInstance
and the currently executed CmmnElement.This is exception is thrown when a
CmmnModelInstance is not found.Exception throw for errors during the transformation of a cmmn model.
Listener which can be registered within the engine to receive events during transforming (and
maybe influence it).
Maps the decision result to a list of untyped entries.
helper/convience methods for working with collections.
This class represents the data structure used for collecting information
about executed commands for telemetry data.
Is invoked while executing a command to check if the current operation is
allowed on the entity.
Interceptor used for opening the
CommandContext and CommandInvocationContext.Command context lifecycle events
The command executor for internal usage/
In contrast to
CommandContext, this context holds resources that are only valid
during execution of a single command (i.e.User comments that form discussions around tasks.
Util class for comparisons.
Contains the oddities required by compensation due to the execution structures it creates.
Behavior for a compensation end event.
Ensures that event subscriptions are visited in a top-down fashion, i.e.
Composite Condition implementation which allows multiple consumers
to subscribe to signals with their own
SingleConsumerCondition.A
CompositeHistoryEventHandler implementation which additionally adds
to the list of HistoryEventHandler the DbHistoryEventHandler
which persists events to a database.A
HistoryEventHandler implementation which delegates to a list of
HistoryEventHandler.
A composite incident handler that handles incidents of a certain type by the multiple handlers.
ProcessEnginePlugin that provides composite behavior.Represents an interface for the condition event behaviors.
Represents the conditional event definition corresponding to the
ConditionalEvent defined by the BPMN 2.0 spec.
A fluent builder for defining conditional start event correlation
A constant parameter value.
Defines the base API for the execution of an activity.
The result of a message correlation.
Exception that is thrown when an optimistic locking error occurs in
CockroachDB, caused by concurrent access to the same data entries by
multiple transactions.
A CockroachDB-specific Command interceptor to catch optimistic locking
errors (classified as a
CrdbTransactionRetryException).Provides a parser and evaluator for unix-like cron expressions.
A data association (Input or Output) between a source and a target
This class represents the data structure used for collecting information
about the connected database.
In order to distinguish between the used hashed algorithm
for the password encryption, as prefix is persisted with the
encrypted to the database.
Utility for
DateTime that uses the JVM timezone
for date / time related operations.Serializes Dates as long values
A bulk operation
Orders bulk operations according to the lexicographical ordering of their statement names
A simple first level cache for
Entities.Provides the keys used by
DbEntityCache for organizing the different DbEntity types.Interface which can be implemented by
DbEntities which
want to be aware of their lifecycle.An operation on a single DbEntity
History event handler that writes history events to the process engine
database using the DbEntityManager.
WritableIdentityProvider implementation backed by a
database.A database operation.
Manages a set of
database operations.Read only implementation of DB-backed identity service
Provides the
DbSqlSession as PersistenceSession.Definition of a decision resource
Deployer responsible to parse DMN 1.1 XML files and create the proper
DecisionDefinitionEntitys.This exception is thrown when a specific decision definition is not found.
Properties to sort decision definition queries by
Fluent builder to evaluate a decision.
This exception is thrown when something happens related to a decision.
Container of
DecisionDefinitions which belongs to the same decision
requirements graph (i.e.Deployer responsible to parse DMN 1.1 XML files and create the proper
DecisionRequirementsDefinitionEntitys.Properties to sort decision requirements definition queries by.
Mapping function for a decision result.
Service to evaluate decisions inside the DMN engine.
Fluent builder to evaluate a decision.
Default ArtifactService implementation.
Provides the default authorizations for Camunda Platform.
Provides the default cache implementation for the deployment caches see
DeploymentCache.The default implementation of the DelegateInterceptor.
Validate a type against a list of allowed packages and classes.
Represents the default priority provider for external tasks.
An incident handler that logs incidents of a certain type
as instances of
Incident to the engine database.This is a simple implementation of the
JobExecutor using self-managed
threads for performing background work.Default implementation of
PermissionProviderRepresents a default priority provider, which contains some functionality to evaluate the priority.
Execution used in
JavaDelegates and ExecutionListeners.Represents a delegation execution context which should return the current
delegation execution.
FormFieldValidator delegating to a custom, user-provided validator implementation.Interceptor responsible for handling calls to 'user code'.
Provides context about the invocation of usercode and handles the actual
invocation
Represents a delegated mapping of input and output variables.
Defines the different states of delegation that a task can be in.
Deletes historic decision instances with the given id of the decision definition.
Deletes historic decision instances with the given id of the instance.
Deletes historic decision instances with the given ids in bulk manner.
Fluent builder to delete process definitions by a process definition key or process definition ids.
Fluent builder implementation to delete process definitions.
Command to delete process definitions by ids.
Command to delete process definitions by a given key.
Fluent builder to delete process definitions by a process definition key or process definition ids.
Fluent builder to delete process definitions by a process definition key or process definition ids.
Configuration object that is passed to the Job that will actually perform execution of
deletion.
Perform serialization of DeleteProcessInstanceBatchConfiguration into JSON format.
Represents a deployment that is already present in the process repository.
Annotation for a test method or class to create and delete a deployment around a test method.
Builder for creating new deployments.
The
DeploymentHandler interface should be implemented when there is a need to
define a custom behavior for determining what Resources should be added to a new Deployment.Builds the
DeploymentHandler for determining of the deployment process for the
Process Engine.Aggregated information on deployment ids and the number of related resources
List of aggregated information on deployment ids and the number of related resources
Collection of constant string values used by the parsers.
Parse implementation for Deployment Metadata.A DeploymentOperation allows bundling multiple deployment steps into a
composite operation that succeeds or fails atomically.
An atomic step that is part of a composite
DeploymentOperation.Allows programmatic querying of
Deployments.Contains the possible properties that can be used in a
DeploymentQuery.An extension of the deployment interface to expose the deployed definitions.
Deployment step responsible for creating individual
DeployProcessArchiveStep instances for each process archive
configured in the META-INF/processes.xml file.
Deployment operation step responsible for deploying a process archive
Validate a type before deserialization
Read the already configured historyLevel from DB and map to given list of total levels.
Stores waypoints of a diagram edge.
Stores the position of a waypoint of a diagram edge.
Represents a diagram node.
Stores a two-dimensional graph layout.
Stores position and dimensions of a diagram node.
Implementation of a Bpmn BusinessRuleTask executing a DMN Decision.
Modify the given DMN engine configuration so that the DMN engine can be used
from the process engine.
The producer for DMN history events.
This exception is thrown when a
DmnModelInstance is not found.helper class for parsing ISO8601 duration format (also recurring) and computing next timer date
Represents a report result about duration of completed instances for a given period.
A script which is dynamically determined during the execution.
A script which resource path is dynamically determined during the execution.
A script which source code is dynamically determined during the execution.
Common base class for writing EJB process applications.
A reference to an EJB process application.
Represents one XML element.
Implementations indicate that they are compatible with
ElProvider and
can provide one.Makes it possible to use expression in
IoParameter mappings.An embedded process application is a ProcessApplication that uses an embedded
process engine.
The process engine holds a strong reference to the embedded process application.
Represents a instance which will be created by a migration, i.e.
Compares operations by Entity type.
Represents a BPMN Error definition, whereas
BpmnError represents an
actual instance of an Error.Represents an 'escalation' element.
Represents an escalation event definition that reference an 'escalation' element.
Helper class handling the propagation of escalation.
Evaluates the decision with the given key or id.
Evaluates the decision table with the given key or id.
Evaluates the conditions to start processes by conditional start events
Deprecated.
Specialization of the Start Event for Event Sub-Processes.
A message event subscription exists, if an
Execution waits for an event like a message.Describes and creates jobs for handling an event asynchronously.
Allows querying of event subscriptions.
Defines the existing event types, on which the subscription can be done.
JobEntity for ever living job, which can be rescheduled and executed again.
A command interceptor to catch
ProcessEngineException errors and assign error codes.One of the provider methods are called when a
ProcessEngineException occurs.implementation of the Exclusive Gateway/XOR gateway/exclusive data-based gateway
as defined in the BPMN specification.
Represents an executable script.
Represent a 'path of execution' in a process instance.
Deprecated.
Callback interface to be notified of execution events like starting a process instance,
ending an activity instance or taking a transition.
Class handling invocations of ExecutionListeners
Represents an observer for the exeuction.
Allows programmatic querying of
Executions.Contains the possible properties that can be used in a
ExecutionQuery.Provides access to the snapshot of latest variables of an execution.
An
ExecutionListener that evaluates a Expression when notified.Class used to get hold of a
ExpressionFactory.Class responsible for handling Expression.getValue invocations
Central manager for all expressions.
Class responsible for handling Expression.setValue() invocations.
Represents an instance of an external task that is created when
a service-task like activity (i.e.
Implements behavior of external task activities, i.e.
Represents a base class for the external task commands.
Represents the logger for the external task.
Service that provides access to
ExternalTask instances.Fetch And Lock Builder used to enable a Fluent API that exposes all parameters for fetch and Lock operation.
Implementation of
FetchAndLockBuilder.Represents a field declaration in object form:
<field name='someField> <string ...
Expression that always returns the same value when
getValue is
called.Superclass for all 'connectable' BPMN 2.0 process elements: tasks, gateways and events.
Walks the flow scope hierarchy upwards
Contains all metadata for displaying a form and serves as
base interface for
StartFormData and TaskFormDataRepresents an individual field in a form.
Wrapper for a validation constraint
Runtime exception for use within a FormFieldValidator.
Interface for implenting form field validators.
Object passed in to a
FormFieldValidator providing access to validation propertiesRuntime exception for validation of form fields.
Deprecated.
Access to form data and rendered forms for starting new process instances and completing tasks.
Used to indicate the type on a
FormProperty.Registry for built-in
FormFieldValidator implementations.super class for all gateway activity implementations.
For synchronizing gateways (inclusive; parallel), the situation in which
more tokens end up at the target gateway than there are incoming sequence flows
must be avoided.
Creates an activity instance tree according to the following strategy:
Event scope executions are not considered at all
For every leaf execution, generate an activity/transition instance;
the activity instance id is set in the leaf execution and the parent instance id is set in the parent execution
For every non-leaf scope execution, generate an activity instance;
the activity instance id is always set in the parent execution and the parent activity
instance id is always set in the parent's parent (because of tree compactation, we ensure
that an activity instance id for a scope activity is always stored in the corresponding scope execution's parent,
unless the execution is a leaf)
Compensation is an exception to the above procedure: A compensation throw event is not a scope, however the compensating executions
are added as child executions of the (probably non-scope) execution executing the throw event.
Gives access to a deploy BPMN model instance which can be accessed by
the BPMN model API.
Gives access to a deployed case diagram, e.g., a PNG image, through a stream
of bytes.
Gives access to a deployed decision definition instance.
Gives access to a deployed decision diagram, e.g., a PNG image, through a stream of bytes.
Gives access to a deployed decision model, e.g., a DMN 1.0 XML file, through a stream of bytes.
Gives access to a deployed decision requirements definition instance.
Gives access to a deployed decision requirements diagram, e.g., a PNG image, through a stream of bytes.
Gives access to a deployed decision requirements model, e.g., a DMN 1.1 XML file, through a stream of bytes.
Gives access to a deployed DMN model instance which can be accessed by the
DMN model API.
Gives access to a deployed process diagram, e.g., a PNG image, through a
stream of bytes.
Provides positions and dimensions of elements in a process diagram as
provided by
GetDeploymentProcessDiagramCmd.Gives access to a deployed process model, e.g., a BPMN 2.0 XML file, through
a stream of bytes.
GetExecutionVariableTypedCmd<T extends org.camunda.bpm.engine.variable.value.TypedValue>
Command for retrieving start or task form keys.
Represents a group, used in
IdentityService.Allows to programmatically query for
Groups.Contains the possible properties that can be used by the
GroupQuery.Holds the set of built-in user identities for Camunda Platform.
Command to handle an external task BPMN error.
Represents an abstract class for the handle of external task commands.
An implementation of this context should contain necessary
information to be accessed by a
ModelElementHandler.Command to handle a task BPMN error.
Command to handle a task escalation.
Entities that are using revisions for optimistic locking, need to implement this interface.
Marks implementing class as having DI-information bounded by a rectangle
at a certain location.
Represents one execution of an activity and it's stored permanent for statistics, audit and other business intelligence purposes.
HistoryEvent implementation for events that happen in an activity.Programmatic querying for
HistoricActivityInstances.Contains the possible properties which can be used in a
HistoricActivityInstanceQuery.Historic representation of a
Batch.Query for
HistoricBatch instances.Contains the possible properties that can be used in a
HistoricBatchQuery.Represents one execution of a case activity which is stored permanent for statistics, audit and other business intelligence purposes.
HistoryEvent implementation for events that happen in a case activity.Programmatic querying for
HistoricCaseActivityInstances.Contains the possible properties which can be used in a
HistoricCaseActivityInstanceQuery.A single execution of a case definition that is stored permanently.
Allows programmatic querying of
HistoricCaseInstances.Contains the possible properties which can be used in a
HistoricCaseInstanceQueryProperty.Container for history entities which belongs to a decision evaluation.
Represents one input variable of a decision evaluation.
Represents one evaluation of a decision.
History entry for an evaluated decision.
Data base operations for
HistoricDecisionInstanceEntity.Allows programmatic querying of
HistoricDecisionInstances.Properties which can be used in
HistoricDecisionInstanceQuery to sort historic decision instances.Represents one output variable of a decision evaluation.
Base class for all kinds of information that is related to
either a
HistoricProcessInstance or a HistoricActivityInstance.Programmatic querying for
HistoricDetails.Contains the possible properties which can be used in a
HistoricDetailQuery.Marks an entity as an historic entity to ensure that
OptimisticLockingExceptions
are swallowed on UPDATE or DELETE operations.The
HistoricExternalTaskLog is used to have a log containing
information about task execution.Historic form fields
Deprecated.
An historic identity link stores the association of a task with a certain identity.
Represents a historic
incident that is stored permanently.The
HistoricJobLog is used to have a log containing
information about job execution.A single execution of a whole process definition that is stored permanently.
HistoryEvent signifying a top-level event in a process instance.The set of built-in
Permissions for
Historic Process Instance in Camunda Platform.Allows programmatic querying of
HistoricProcessInstances.Contains the possible properties which can be used in a
HistoricProcessInstanceQueryProperty.Defines a report query for
HistoricProcessInstances.Represents a historic task instance (waiting, finished or deleted) that is stored permanent for
statistics, audit and other business intelligence purposes.
Allows programmatic querying for
HistoricTaskInstances.The set of built-in
Permissions for
Historic Task in Camunda Platform.A single process variable containing the last value when its process instance has finished.
Programmatic querying for
HistoricVariableInstances.Contains the possible properties which can be used in a
HistoricVariableInstanceQuery.Update of a process variable.
Batch of work for history cleanup.
Job declaration for history cleanup.
Job handler for history cleanup job.
The base class for all history events.
The interface for implementing an history event handler.
The
HistoryEventProcessor should be used to process an history event.The
HistoryEventProcessor.HistoryEventCreator interface which is used to interchange the implementation
of the creation of different HistoryEvents.The producer for history events.
An history event type.
The set of built-in history event types.
An
ExecutionListener implementation that delegates to a
HistoryEventProducer.The history level controls what kind of data is logged to the history database.
This class is responsible for wiring history as execution listeners into process execution.
The provider is either invoked on root process instance start or end
based on the selected history removal time strategy.
Service exposing information about ongoing and past process instances.
A
TaskListener implementation that delegates to a
HistoryEventProducer.Class that encapsulates the business logic of parsing HistoryTimeToLive of different deployable resources (process, definition, case).
The
HtmlDocumentBuilder is part of the HtmlFormEngine
and maintains a stack of element which are written out to a StringWriter.Simple writer for html elements.
A simple
FormEngine implementaiton which renders
forms as HTML such that they can be used as embedded forms
inside camunda Tasklist.An identity link is used to associate a task with a certain identity.
Contains constants for all types of identity links that can be used to involve a
user or group with a certain task.
Holds the result of an
IdentityService operation including the
operation that was executed and optionally a resulting value.Marks an exception triggered inside an identity provider implementation
generates
IdBlocks that are used to assign ids to new objects.Immutable representation of a 2-tuple of elements.
An
Incident represents a failure in the execution of
a process instance.The context of an
Incident.The
IncidentHandler interface may be implemented by components
that handle and resolve incidents of a specific type that occur during the
execution of a process instance.Represents a statistic which the aggregate number of incidents to
the corresponding incident type.
Implementation of the Inclusive Gateway/OR gateway/inclusive data-based
gateway as defined in the BPMN specification.
+-----------------+
| |
outer scope-----> inner scope |
| |
+-----------------+
Expresses that the list of activities should be instantiated and optionally a transition
afterwards.
This class represents the structure of data describing Camunda internal
metrics and the technical environment in which Camunda is set-up.
The context of an invocation.
Maps variables in and out of a variable scope.
An
IoParameter creates a variable
in a target variable scope.Common base class for writing Jakarta Enterprise Bean process applications.
A reference to an EJB process application.
A
AbstractProcessApplication Implementation to be used in a Servlet
container environment.This class is an implementation of
ServletContainerInitializer and
is notified whenever a subclass of ServletProcessApplication annotated
with the ProcessApplication annotation is deployed.Jakarta Transactions-based implementation of the
AbstractTransactionContextJakarta Transactions-based implementation of the
AbstractTransactionInterceptorJakarta Transactions-based implementation of the
AbstractTransactionProcessEngineConfigurationConvience class that should be used when a Java delegation in a BPMN 2.0
process is required (for example, to call custom business logic).
Class handling invocations of JavaDelegates
Uses default java serialization to serialize java objects as byte streams.
This class represents the data structure used for collecting information
about the installed Java runtime environment.
MBean interface exposing management properties of the jobExecutor through JMX.
MBean interface for
ProcessApplications.Represents a process engine managed by the
MBeanServiceContainerRepresents a managed process engine that is started / stopped inside the
MBeanServiceContainerAn MBean interface for the
ProcessEngine.MBean responsible for controlling a Thread Pool.
Represents one job (timer, message, etc.).
Java API to the JobAcquisition deployment metadata
Implementation of the
JobAcquisitionXml SPI interfaceA job declaration is associated with an activity in the process definition graph.
A Job Definition provides details about asynchronous background
processing ("Jobs") performed by the process engine.
Manager implementation for
JobDefinitionEntityAllows programmatic querying of
JobDefinitions.Contains the possible properties that can be used in a
JobDefinitionQuery.Stub of the common parts of a Job.
Interface to the component responsible for performing
background work (
Jobs).Deployment Metadata for the JobExecutor Service.
Implementation of the
JobExecutorXmlAllows programmatic querying of
Jobs.Contains the possible properties that can be used in a
JobQuery.Deserializes query ordering properties from the deprecated 7.2 format in which
the SQL-like orderBy parameter was used.
JTA-based implementation of the
AbstractTransactionProcessEngineConfigurationJTA-based implementation of the
AbstractTransactionContextJTA-based implementation of the
AbstractTransactionInterceptorExpression implementation backed by a JUEL
ValueExpression.JUEL-specific implementation of an
ExpressionManager.ScriptEngine that used JUEL for script evaluation and compilation (JSR-223).
Factory to create
JuelScriptEngines.A single lane in a BPMN 2.0 LaneSet, currently only used internally for rendering the
diagram.
A BPMN 2.0 LaneSet, containg
Lanes, currently only used for
rendering the DI info.Collects executions that execute an activity instance that is a leaf in the activity instance tree.
This class encapsulates legacy runtime behavior for the process engine.
This class represents the data structure used for collecting information
about the license key issued for enterprise versions of Camunda Platform.
Represents an external task that was fetched and locked.
Deprecated.
since 7.4, use slf4j
Service for admin and maintenance operations on the process engine.
Implementation of the BPMN 2.0 'manual task': a task that is external to the
BPMS and to which there is no reference to IT systems whatsoever.
A simple Service Container that delegates to the JVM's
MBeanServer.A fluent builder for defining asynchronous message correlation
Job handler for message correlation jobs.
A fluent builder for defining message correlation
The result of a message correlation.
The message correlation result type indicates which type
of message correlation result is returned after a message correlation.
* The result of a
message correlation
containing the process variablesImplementation of the BPMN 2.0 'message'
NOTE: instances of Message Entity should be created via
MessageJobDeclaration.Declaration of a Message Job (Asynchronous continuation job)
A Meter implementation based on AtomicLong
This class represents the data structure used for collecting information
about certain internal metrics for telemetry data.
Represents a metric which contains a name, reporter like the node,
timestamp and corresponding value.
Deprecated.
Please use
HostnameProvider
for providing the Metrics Reporter id.How migration works:
Validate migration instructions.
Collects all failures for a migrating activity instance.
Builds a
MigratingProcessInstance, a data structure that contains meta-data for the activity
instances that are migrated.Walks the hierarchy of
MigratingProcessElementInstances in a top-down-fashion.Thrown if at least one migration instruction cannot be applied to the activity instance it matches.
Collects general failures and the migrating activity instance validation
reports for a migrating process instance.
A process element instance that can have other process element instances as children
Keeps track of scope instances (activity instances; event scope instances) created in a branch
of the activity/event scope tree from the process instance downwards
Collects all failures for a migrating transition instance.
Check if two activities are equal in the context
of the migration of two process definitions.
Check if an activity can be migrated.
Job handler for batch migration jobs.
Represents an instruction to migrate instances of one activity to another activity.
Generates all migration instructions which represent a direct one
to one mapping of mapped entities in two process definitions.
Collects the validation failures for a single migration
instruction.
Checks that a migration instruction is valid for the
migration plan.
Specifies how process instances from one process definition (the source process definition)
should be migrated to another process definition (the target process definition).
Builder to execute a migration.
Thrown if a migration plan is not valid, e.g.
Collects the migration validation reports for
all instructions and variables of the migration plan which contain failures.
Collects the validation failures for a single migration
variable.
Wrapper containing the missing authorization information.
Registry for mock objects.
ModelElementHandler<T extends org.camunda.bpm.model.xml.instance.ModelElementInstance,V extends HandlerContext,E>
ModelInstanceCache<InstanceType extends org.camunda.bpm.model.xml.ModelInstance,DefinitionType extends ResourceDefinitionEntity>
When a (scope) activity behavior implements this behavior,
its scope execution is notified in case of an external modification about the following:
the scope execution is newly created
a new concurrent execution is created in that scope
a concurrent execution is removed in that scope
Abstract Multi Instance Behavior: used for both parallel and sequential
multi instance implementation.
Allows querying of
Executions via native (SQL) queriesAllows querying of
HistoricActivityInstanceQuerys via native (SQL) queriesAllows querying of
HistoricCaseActivityInstances via native (SQL) queriesAllows querying of
HistoricCaseInstances via native (SQL) queriesAllows querying of
HistoricDecisionInstances via native (SQL) queries.Allows querying of
HistoricTaskInstanceQuerys via native (SQL) queriesAllows querying of
HistoricTaskInstanceQuerys via native (SQL) queriesAllows querying of
HistoricVariableInstanceQuerys via native (SQL) queriesAllows querying of
ProcessInstances via native (SQL) queriesDescribes basic methods for doing native queries
Allows querying of
Tasks via native (SQL) queriesAllows querying of
Users via native (SQL) queriesimplementation of the 'none start event': a start event that has no
specific trigger but the programmatic one (processService.startProcessInstanceXXX()).
This exception is thrown, if an operation is not allowed to be executed.
This exception is thrown, if an entity (case execution, case definition) is not found.
This exception is thrown, if a given value is not valid.
Subscriptions for compensation start events must be migrated, similar to compensation boundary events.
Used to serialize untyped null values.
This is a functional interface to pass a callback that writes
the Operation Log.
This is a functional interface to pass a callback that writes
the Operation Log.
Contains sortable properties which can be used in a
UserOperationLogQuery.Exception that is thrown when an optimistic locking occurs in the datastore
caused by concurrent access of the same data entry.
Allows registering a listener which is notified when an
DbOperationType.UPDATE or DbOperationType.DELETE
could not be performed.Deprecated.
These permissions have no effect
+--------------+
| |
| inner scope ------> outer scope
| |
+--------------+
Pass the output variables from the process instance of a subprocess to the
calling process instance.
holds the parameters of a page (partial result) for a query.
Implementation of the Parallel Gateway/AND gateway as definined in the BPMN
2.0 specification.
Detects and parses all META-INF/processes.xml files within the process application
and attaches the parsed Metadata to the operation context.
Object indicating that a
ProcessDefinitionImpl is a participant in a collaboration (pool).Exception thrown during the encryption process.
The
PasswordEncryptor provides the api to customize
the encryption of passwords.Different Camunda versions use different hashing algorithms.
Contains a list of
rules that must be matched by
passwords for engine-managed users.The result of a password which was checked against a
PasswordPolicy.Describes a rule of a
PasswordPolicy.Patches execution variables: First, applies modifications to existing variables and then deletes
specified variables.
Patches task variables: First, applies modifications to existing variables and then deletes
specified variables.
Specifies a unit for a span of time (i.e.
A permission represents an authorization to interact with a given
resource in a specific way.
Converts between the String-Array based and the Integer-based representation
of permissions.
This is a functional interface to pass a callback that performs
the permission check.
A simple provider used to determine custom
Permissions and
ResourcesThe set of built-in
Permissions for Camunda Platform.A ServiceType is a collection of services that share a common name prefix.
Retrieves the List of ProcessEngines from an attached
ProcessesXml.Base class for the process engine test cases.
Annotation that can be placed on a method of a
ProcessApplication class.Operation step responsible for invoking the @
PostDeploy method of a
ProcessApplication class.Annotation that can be placed on a method of a
ProcessApplication class.Operation step responsible for invoking the @
PreUndeploy method of a
ProcessApplication class.PrimitiveValueSerializer<T extends org.camunda.bpm.engine.variable.value.PrimitiveValue<?>>
Interface of a problem occurred during parsing
Used to annotate a user-provided
AbstractProcessApplication class and specify
the unique name of the process application.Resolves a
BeanELResolver from the current process application.Wrapps the user-provided
Callable and records the
Thread Context Classloader after the context switch has been performed.A utility to declare the process application in which subsequent engine API calls
are executed.
Builder for a
ProcessApplication deploymentObject holding information about a deployment made by a process application.
SPI interface that allows providing a custom ElResolver implementation.
Comparator used for sorting providers
This is an
ELResolver implementation that delegates to a ProcessApplication-provided
ELResolver.ExecutionListener and TaskListener implementation delegating to
the ExecutionListener and TaskListener provided by a
ProcessApplication.ProcessEnginePlugin enabling the process application event listener support.Object holding information about a deployed Process Application
A Process Application is an ordinary Java Application that uses the camunda process engine for
BPM and Worklow functionality.
A reference to a process application.
A
ProcessApplicationReference implementation using
WeakReference.Represents a registration of a process application with a process engine
The process application service provides access to all deployed process applications.
ObjectFactory that can be used for binding the ProcessApplicationService into JNDIChecked exception thrown by a
ProcessApplicationReference if the referenced
process application is unavailable.Java API representation of a ProcessArchive definition inside a processes.xml file
Holds the contextual process data.
New context properties are always part of a section that can be started by
New context properties are always part of a section that can be started by
ProcessDataContext.pushSection(ExecutionEntity).An object structure representing an executable process composed of
activities and transitions.
The set of built-in
Permissions for Process definition in Camunda Platform.Allows programmatic querying of
ProcessDefinitions.Contains the possible properties that can be used in a
ProcessDefinitionQuery.Provides positions and dimensions of elements in a process diagram as
provided by
RepositoryService.getProcessDiagram(String).A ProcessElementInstance is an instance of a process construct
such as an Activity (see
ActivityInstance) or a transition
(see TransitionInstance).Provides access to all the services that expose the BPM and workflow operations.
Configuration information from which a process engine can be build.
When a Process Engine API call is performed, the engine
will create a Process Engine Context.
Holds process engine version and edition (enterprise or community)
Used in retrieving the process engine details when sending telemetry data
ELContext used by the process engine.Runtime exception that is the superclass of all exceptions in the process engine.
Represents information about the initialization of the process engine.
Exception thrown by the persistence layer of the process engine in the occurrence of a problematic interaction
with the datasource.
A process engine plugin allows customizing the process engine
Java API representation of a
ProcessEnginePlugin configuration inside a deployment descriptor.Implementation of the
ProcessEnginePluginXml descriptorConvenience for ProcessEngine and services initialization in the form of a
JUnit rule.
Helper for initializing and closing process engines in server environments.
The
ProcessEngineService provides access to the list of Managed Process Engines.ObjectFactory that can be used for binding the ProcessEngineService into JNDIBase interface providing access to the process engine's
public API services.
Interface providing access to the
ProcessEngineServices from Java
delegation code.Convenience for ProcessEngine and services initialization in the form of a JUnit base class.
Java API representation of a ProcessEngine definition inside an XML
deployment descriptor.
Implementation of the
ProcessEngineXml descriptor.Java API representation of the
ProcessesXml Metadata.Parse object for the processes.xml file.A SAX Parser for the processes.xml file
Retrieves the List of ProcessEngines from an attached
ProcessesXml.Deployment operation responsible for stopping all process engines started by the deployment.
Represents one execution of a
ProcessDefinition.A fluent builder to specify a modification of process instance state in terms
of cancellation of activity instances and instantiations of activities and sequence flows.
The set of built-in
Permissions for Process instances in Camunda Platform.Allows programmatic querying of
ProcessInstances.Contains the possible properties that can be used in a
ProcessInstanceQuery.Represents a process instance with the corresponding latest variables.
Simply wraps a modification builder because their API is equivalent.
This class represents the data structure of information about the Camunda
product.
Provides product information data loaded from a *.properties file.
Properties that maps property keys to values.
Contains data about a property change.
Key of a typed property.
Key of a list property.
Key of a map property.
Purges the database and the deployment cache.
The purge report contains information about the deleted rows for each table
and also the deleted values which are removed from the deployment cache.
Represents an interface for the purge reporting.
Defines an activity insisde a process.
Instantiates the next activity on the stack of the current execution's start context.
Base Atomic operation for implementing atomic operations which mark the creation
of a new activity instance.
Cancel scope operation performed when an execution starts at an
ActivityImpl#isCancelActivity()
activity.Implements
ActivityStartBehavior.CANCEL_EVENT_SCOPE.Base atomic operation used for implementing atomic operations which
create a new concurrent execution for executing an activity.
This atomic operation simply fires the activity end event
In BPMN this is used for terminate end events
Describes basic methods for querying.
Specifies a condition by which two entity types can be related.
Used to indicate the operator that should be used to comparing values in a query clause.
A QueryOrderingProperty specifies a condition by which the results of a query should be
sorted.
Describes a property that can be used in a Query.
Represents a variable value used in queries.
SPI interface for read-only identity Service Providers.
An
ELResolver that exposed object values in the map, under the name of the entry's key.A receive task is a wait state that waits for the receival of some message.
A walker for walking through an object reference structure (e.g.
Strategy for handling jobs that were acquired but cannot be
executed at this point (queue-size exceeded).
Represents a instance which will be removed by a migration, i.e.
Describes basic methods for creating a report.
This interface defines basic methods for resulting reports.
Service providing access to the repository of process definitions and deployments.
This only works if
ProcessEngineRule or AbstractProcessEngineTestCase is used.Annotation for a test method or class to specify the required history level.
A resolver for Objects bound to a key.
Resources are entities for which a user or a group is authorized.
Manages (create/update/delete) default authorization when an entity is
changed
Definition of a resource which was deployed
Entity of a deployed resource definition
A script which is provided by an external resource.
This a report created during a parsing.
Resource report created during resource parsing
The set of built-in
Resource names.Maps the decision result to a list of pairs that contains output name and
untyped entry.
Contains the constants for the possible values the property
ProcessApplicationDeploymentBuilder.resumePreviousVersionsBy(String).The
RuntimeContainerDelegate in an SPI that allows the process engine to integrate with the
runtime container in which it is deployed.Holder of the current
RuntimeContainerDelegate instance.This is the default
RuntimeContainerDelegate implementation that delegates
to the local MBeanServer infrastructure.JobExecutor implementation that delegates the execution of jobs
to the
RuntimeContainerLog entry for database schema version changes.
A Bpmn scope.
Represents the backlog error callback interface.
Keeps track of the execution state when a hierarchy of
scopes is instantiated at once (e.g.
A
Bindings implementation which wraps an existing binding and enhances the key / value map with
read-only access to:
variables provided in a VariableScope,
additional bindings provided through a set of Resolvers.
Factory for the Bindings used by the
ScriptingEngines.An
CaseExecutionListener which invokes a ExecutableScript when notified.Exception resulting from a error during a script compilation.
A
Condition which invokes a ExecutableScript when evaluated.Base exception resulting from a script engine interaction.
Resolver for environment scripts.
Exception resulting from a error during a script evaluation.
An
ExecutionListener which invokes a ExecutableScript when notified.A script factory is responsible for creating a
ExecutableScript
instance.Manager for JSR-223
ScriptEngine handling.The scripting environment contains scripts that provide an environment to
a user provided script.
ActivityBehavior implementation of the BPMN 2.0 script task.A
TaskListener which invokes a ExecutableScript when notified.Makes it possible to use scripts in
IoParameter mappings.AcquireJobsRunnable able to serve multiple process engines.ActivityBehavior used when 'delegateExpression' is used
for a serviceTask.ActivityBehavior that evaluates an expression when executed.
The service types managed by this container.
A
AbstractProcessApplication Implementation to be used in a Servlet
container environment.This class is an implementation of
ServletContainerInitializer and
is notified whenever a subclass of ServletProcessApplication annotated
with the ProcessApplication annotation is deployed.Represents the command to set the priority of an existing external task.
Fluent builder to update the number of retries for one or multiple jobs asynchronously.
Fluent builder to update the number of retries for one or multiple jobs synchronously.
Fluent builder to update the number of retries for one or multiple jobs asynchronously.
Fluent builder to update the number of retries for one or multiple jobs referenced by process asynchronously.
Command that changes the process definition version of an existing
process instance.Command which can be used for setting the value of a property
Fluent builder to select the mode to set the removal time for historic batches.
Fluent builder to select the mode to set the removal time for historic decision instances.
Fluent builder to select the mode to set the removal time for historic process instances.
Fluent builder to set the removal time to historic batches and
all associated historic entities.
Fluent builder to set the removal time to historic decision instances and
all associated historic entities.
Fluent builder to set the removal time to historic process instances and
all associated historic entities.
Command that changes the description of a task.
Command to change task priority to a new value.
Command to change task followUpDate to a new value.
Command to change a Task's name to a new value.
Command to change task priority to a new value.
PasswordEncryptor implementation using base64 encoded SHA-512 password hashesPasswordEncryptor implementation using base64 encoded SHA password hashesRepresents a bpmn signal definition
Fluent builder to notify the process engine that a signal event has been
received.
For mybatis
ExecutorType.SIMPLEThe SimpleFormFieldType can be used when the form value and the model value are equal.
MPSC Condition implementation.
Maps the decision result to a single typed entry.
Maps the decision result to pairs of output name and untyped entries.
A script which is provided as source code.
Specific
FormData for starting a new process instance.Deployment operation step responsible for starting a JobEexecutor
Deployment operation step responsible for starting the JobExecutor
Deployment operation step responsible for deploying a thread pool for the
JobExecutor
This deployment operation step starts an
MBeanService for the process application.Deployment operation step responsible for starting a managed process engine
inside the runtime container.
Variable-scope only used to resolve variables when NO execution is active but
expression-resolving is needed.
Deployment operation step responsible for stopping all job acquisitions
Deployment operations step responsible for removing the
JmxManagedProcessApplication service.Deployment operation step that is responsible for stopping (undeploying) all process applications
Deployment operation step that stops ALL process engines registered inside the container.
Converts String to and from bytes using the encodings required by the Java specification.
IdGenerator implementation based on the current time and the ethernet
address of the machine it is running on.Implementation of the BPMN 2.0 subprocess (formally known as 'embedded' subprocess):
a subprocess defined within another process definition.
behavior for activities that delegate to a complete separate execution of
a process definition.
*Supported* refers to whether an activity instance of a certain activity type can be migrated.
Validator for events that passively wait for an event, i.e.
This exception is thrown, if an operation that requires a non-suspended entity (execution, task, process definition)
is executed on a suspended one.
Contains a predefined set of states for process definitions and process instances
Interface for Commands that synchronously modify multiple entities in one operation.
Structure containing meta data (column names, column types, etc.)
about a certain database table.
Data structure used for retrieving database table content.
Allows programmatic querying of
TablePages.Represents one task for a human user.
Parent class for all BPMN 2.0 task types such as ServiceTask, ScriptTask, UserTask, etc.
This exception is thrown when you try to claim a task that is already claimed
by someone else.
Container for task definition information gathered at parsing time.
Specific
FormData for completing a task.Listener interface implemented by user code which wants to be notified when a property of a task changes.
Deprecated.
use org.camunda.bpm.engine.delegate.TaskListener instead
Class handling invocations of
TaskListenersThe set of built-in
Permissions for Task in Camunda Platform.Allows programmatic querying of
Tasks;Contains the possible properties that can be used in a
TaskQuery.Represents a variable value used in a task query.
Service which provides access to
Task and form related operations.The engine collects information about multiple aspects of the installation.
Represents a tenant, used in
IdentityService.CommandChecker to ensure that commands are only executed for
entities which belongs to one of the authenticated tenants.SPI which can be implemented to assign tenant ids to process instances, case instances and historic decision instances.
Provides information about a starting case instance to a
TenantIdProvider implementation.Provides information about a historic decision instance to a
TenantIdProvider implementation.Provides information about a starting process instance to a
TenantIdProvider implementation.A relationship between a tenant and an user or a group.
Allows to programmatically query for
Tenants.Contains the possible properties that can be used by the
TenantQuery.The BPMN terminate End Event.
The activity behavior for an intermediate throwing escalation event and an escalation end event.
Defines activity behavior for signal end event and intermediate throw signal event.
JobHandler implementation for timer start events which are embedded into an event subprocess.JobHandler implementation for timer task listeners which can be defined for user tasks.Set of constant keys to be used in apache tomcat deployment operations
Apache Tomcat server listener responsible for deploying the Camunda Platform.
This deployment operation step is responsible for parsing and attaching the bpm-platform.xml file on tomcat.
The transaction context is an abstraction for different transaction management strategies
existing the Java Ecosystem.
Implementations may not assume that this is executed by the same thread as the command itself.
A transition instance represents an execution token that
has just completed a transition (sequence flow in BPMN) or is about
to take an outgoing transition.
A visitor for
SingleReferenceWalker.This
CommandContextFactory allows to explicitly pass in a TransactionContextFactory.A field what provide a typed version of a value.
TypedValueSerializer<T extends org.camunda.bpm.engine.variable.value.TypedValue>
Condition that resolves an UEL expression at runtime.Deployment operation responsible for undeploying all process archives.
Deployment operation step responsible for performing the undeployment of a
process archive
Unlock job.
Allows to unlock users.
Ensure that the option updateEventTriggers can only be used activities defining an event trigger
Fluent builder to update the suspension state of job definitions.
Fluent builder to update the suspension state of job definitions.
Fluent builder to update the suspension state of job definitions.
Fluent builder to update the suspension state of jobs.
Fluent builder to update the suspension state of jobs.
Fluent builder to update the suspension state of jobs.
Fluent builder to update the suspension state of process definitions.
Fluent builder to update the suspension state of process definitions.
Fluent builder to update the suspension state of process definitions.
Fluent builder to update the suspension state of process instances.
Fluent builder to update the suspension state of process instances.
Fluent builder to update the suspension state of process instances.
Represents a user, used in
IdentityService.The set of built-in
Permissions for User operation log based on categories in Camunda Platform.Provides information about user operations.
One op log context entry represents an operation on a set of entities of the same type (see entityType field).
Log entry about an operation performed by a user.
Manager for
UserOperationLogEntryEventEntity that also provides a generic and some specific log methods.Programmatic querying for
UserOperationLogEntry instances.Allows programmatic querying of
UserContains the possible properties that can be used by the
UserQuery.activity implementation for the user task.
Validators must be equal (in terms of
#equals(Object)) if they validate
the exact same thing.Resolves ValueType by name.
Validates that when an activity instance has a variable with the same name twice (as a scope execution variable and a
a concurrent variable parent execution variable), no situation occurs in which either one is overwritten.
Deprecated.
A
VariableInstance represents a variable in the execution of
a process instance.Implementation of the
VariableContext interface backed
by a VariableScope.Implementation of an
ELResolver that resolves expressions
with the process variables of a given VariableScope as context.Wraps a variable scope as if it has no parent such that it is reduced to its local
variables.
Bindings implementation using an
ExecutionImpl as 'back-end'.Interface describing a container for all available
TypedValueSerializers of variables.A
ProcessArchiveScanner which uses Jboss VFS for
scanning the process archive for processes.Validate a type before deserialization against a whitelist of allowed types
SPI Interface for identity service implementations which offer
read / write access to the user database.
Exception that is thrown when the Activiti engine discovers a mismatch between the
database schema version and the engine version.
A XML importer
BpmnExecutionContext